长沙回收名牌包包回收MichaelKors迈克科尔斯包包 - 胶东新闻网

Directory:	../../../ffmpeg/
File:	src/libavformat/cafdec.c
Date:	2025-08-05 11:35:17
	Exec	Total	Coverage
Lines:	173	299	57.9%
Functions:	7	8	87.5%
Branches:	99	217	45.6%
  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Core Audio Format demuxer
    
       * Copyright (c) 2007 Justin Ruggles
    
       * Copyright (c) 2009 Peter Ross
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      /**
    
       * @file
    
       * Core Audio Format demuxer
    
       */
    
      #include <inttypes.h>
    
      #include "avformat.h"
    
      #include "demux.h"
    
      #include "internal.h"
    
      #include "isom.h"
    
      #include "mov_chan.h"
    
      #include "libavcodec/flac.h"
    
      #include "libavutil/intreadwrite.h"
    
      #include "libavutil/intfloat.h"
    
      #include "libavutil/dict.h"
    
      #include "libavutil/mem.h"
    
      #include "caf.h"
    
      typedef struct CafContext {
    
          int bytes_per_packet;           ///< bytes in a packet, or 0 if variable
    
          int frames_per_packet;          ///< frames in a packet, or 0 if variable
    
          int64_t num_bytes;              ///< total number of bytes in stream
    
          int64_t packet_cnt;             ///< packet counter
    
          int64_t frame_cnt;              ///< frame counter
    
          int64_t data_start;             ///< data start position, in bytes
    
          int64_t data_size;              ///< raw data size, in bytes
    
      } CafContext;
    
      7252
      static int probe(const AVProbeData *p)
    
      {
    
        2/2✓ Branch 0 taken 7243 times.
✓ Branch 1 taken 9 times.

      7252
          if (AV_RB32(p->buf) != MKBETAG('c','a','f','f'))
    
      7243
              return 0;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (AV_RB16(&p->buf[4]) != 1)
    
      ✗
              return 0;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (AV_RB32(p->buf + 8) != MKBETAG('d','e','s','c'))
    
      ✗
              return 0;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (AV_RB64(p->buf + 12) != 32)
    
      ✗
              return 0;
    
      9
          return AVPROBE_SCORE_MAX;
    
      }
    
      /** Read audio description chunk */
    
      9
      static int read_desc_chunk(AVFormatContext *s)
    
      {
    
      9
          AVIOContext *pb = s->pb;
    
      9
          CafContext *caf = s->priv_data;
    
          AVStream *st;
    
          int flags;
    
          /* new audio stream */
    
      9
          st = avformat_new_stream(s, NULL);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (!st)
    
      ✗
              return AVERROR(ENOMEM);
    
          /* parse format description */
    
      9
          st->codecpar->codec_type  = AVMEDIA_TYPE_AUDIO;
    
      9
          st->codecpar->sample_rate = av_clipd(av_int2double(avio_rb64(pb)), 0, INT_MAX);
    
      9
          st->codecpar->codec_tag   = avio_rl32(pb);
    
      9
          flags = avio_rb32(pb);
    
      9
          caf->bytes_per_packet  = avio_rb32(pb);
    
      9
          st->codecpar->block_align = caf->bytes_per_packet;
    
      9
          caf->frames_per_packet = avio_rb32(pb);
    
      9
          st->codecpar->ch_layout.nb_channels = avio_rb32(pb);
    
      9
          st->codecpar->bits_per_coded_sample = avio_rb32(pb);
    
        3/6✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9 times.

      9
          if (caf->bytes_per_packet < 0 || caf->frames_per_packet < 0 || st->codecpar->ch_layout.nb_channels < 0)
    
      ✗
              return AVERROR_INVALIDDATA;
    
          /* calculate bit rate for constant size packets */
    
        3/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 3 times.

      9
          if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) {
    
      6
              st->codecpar->bit_rate = (uint64_t)st->codecpar->sample_rate * (uint64_t)caf->bytes_per_packet * 8
    
      6
                                       / (uint64_t)caf->frames_per_packet;
    
          } else {
    
      3
              st->codecpar->bit_rate = 0;
    
          }
    
          /* determine codec */
    
        2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 5 times.

      9
          if (st->codecpar->codec_tag == MKTAG('l','p','c','m'))
    
      4
              st->codecpar->codec_id = ff_mov_get_lpcm_codec_id(st->codecpar->bits_per_coded_sample, (flags ^ 0x2) | 0x4);
    
          else
    
      5
              st->codecpar->codec_id = ff_codec_get_id(ff_codec_caf_tags, st->codecpar->codec_tag);
    
      9
          return 0;
    
      }
    
      /** Read magic cookie chunk */
    
      4
      static int read_kuki_chunk(AVFormatContext *s, int64_t size)
    
      {
    
      4
          AVIOContext *pb = s->pb;
    
      4
          AVStream *st      = s->streams[0];
    
          int ret;
    
        2/4✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.

      4
          if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
    
      ✗
              return -1;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

      4
          if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
    
              /* The magic cookie format for AAC is an mp4 esds atom.
    
                 The lavc AAC decoder requires the data from the codec specific
    
                 description as extradata input. */
    
              int strt, skip;
    
      ✗
              strt = avio_tell(pb);
    
      ✗
              ff_mov_read_esds(s, pb);
    
      ✗
              skip = size - (avio_tell(pb) - strt);
    
      ✗
              if (skip < 0 || !st->codecpar->extradata ||
    
      ✗
                  st->codecpar->codec_id != AV_CODEC_ID_AAC) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "invalid AAC magic cookie\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
      ✗
              avio_skip(pb, skip);
    
        2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.

      4
          } else if (st->codecpar->codec_id == AV_CODEC_ID_ALAC) {
    
      #define ALAC_PREAMBLE 12
    
      #define ALAC_HEADER   36
    
      #define ALAC_NEW_KUKI 24
    
              uint8_t preamble[12];
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
              if (size < ALAC_NEW_KUKI) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n");
    
      ✗
                  avio_skip(pb, size);
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

      2
              if (avio_read(pb, preamble, ALAC_PREAMBLE) != ALAC_PREAMBLE) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "failed to read preamble\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

      2
              if ((ret = ff_alloc_extradata(st->codecpar, ALAC_HEADER)) < 0)
    
      ✗
                  return ret;
    
              /* For the old style cookie, we skip 12 bytes, then read 36 bytes.
    
               * The new style cookie only contains the last 24 bytes of what was
    
               * 36 bytes in the old style cookie, so we fabricate the first 12 bytes
    
               * in that case to maintain compatibility. */
    
        1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.

      2
              if (!memcmp(&preamble[4], "frmaalac", 8)) {
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
                  if (size < ALAC_PREAMBLE + ALAC_HEADER) {
    
      ✗
                      av_log(s, AV_LOG_ERROR, "invalid ALAC magic cookie\n");
    
      ✗
                      av_freep(&st->codecpar->extradata);
    
      ✗
                      return AVERROR_INVALIDDATA;
    
                  }
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

      2
                  if (avio_read(pb, st->codecpar->extradata, ALAC_HEADER) != ALAC_HEADER) {
    
      ✗
                      av_log(s, AV_LOG_ERROR, "failed to read kuki header\n");
    
      ✗
                      av_freep(&st->codecpar->extradata);
    
      ✗
                      return AVERROR_INVALIDDATA;
    
                  }
    
      2
                  avio_skip(pb, size - ALAC_PREAMBLE - ALAC_HEADER);
    
              } else {
    
      ✗
                  AV_WB32(st->codecpar->extradata, 36);
    
      ✗
                  memcpy(&st->codecpar->extradata[4], "alac", 4);
    
      ✗
                  AV_WB32(&st->codecpar->extradata[8], 0);
    
      ✗
                  memcpy(&st->codecpar->extradata[12], preamble, 12);
    
      ✗
                  if (avio_read(pb, &st->codecpar->extradata[24], ALAC_NEW_KUKI - 12) != ALAC_NEW_KUKI - 12) {
    
      ✗
                      av_log(s, AV_LOG_ERROR, "failed to read new kuki header\n");
    
      ✗
                      av_freep(&st->codecpar->extradata);
    
      ✗
                      return AVERROR_INVALIDDATA;
    
                  }
    
      ✗
                  avio_skip(pb, size - ALAC_NEW_KUKI);
    
              }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
          } else if (st->codecpar->codec_id == AV_CODEC_ID_FLAC) {
    
              int last, type, flac_metadata_size;
    
              uint8_t buf[4];
    
              /* The magic cookie format for FLAC consists mostly of an mp4 dfLa atom. */
    
      ✗
              if (size < (16 + FLAC_STREAMINFO_SIZE)) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "invalid FLAC magic cookie\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
              /* Check cookie version. */
    
      ✗
              if (avio_r8(pb) != 0) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "unknown FLAC magic cookie\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
      ✗
              avio_rb24(pb); /* Flags */
    
              /* read dfLa fourcc */
    
      ✗
              if (avio_read(pb, buf, 4) != 4) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "failed to read FLAC magic cookie\n");
    
      ✗
                  return pb->error < 0 ? pb->error : AVERROR_INVALIDDATA;
    
              }
    
      ✗
              if (memcmp(buf, "dfLa", 4)) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "invalid FLAC magic cookie\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
              /* Check dfLa version. */
    
      ✗
              if (avio_r8(pb) != 0) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "unknown dfLa version\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
      ✗
              avio_rb24(pb); /* Flags */
    
      ✗
              if (avio_read(pb, buf, sizeof(buf)) != sizeof(buf)) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "failed to read FLAC metadata block header\n");
    
      ✗
                  return pb->error < 0 ? pb->error : AVERROR_INVALIDDATA;
    
              }
    
      ✗
              flac_parse_block_header(buf, &last, &type, &flac_metadata_size);
    
      ✗
              if (type != FLAC_METADATA_TYPE_STREAMINFO || flac_metadata_size != FLAC_STREAMINFO_SIZE) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "STREAMINFO must be first FLACMetadataBlock\n");
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
      ✗
              ret = ff_get_extradata(s, st->codecpar, pb, FLAC_STREAMINFO_SIZE);
    
      ✗
              if (ret < 0)
    
      ✗
                  return ret;
    
      ✗
              if (!last)
    
      ✗
                  av_log(s, AV_LOG_WARNING, "non-STREAMINFO FLACMetadataBlock(s) ignored\n");
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
          } else if (st->codecpar->codec_id == AV_CODEC_ID_OPUS) {
    
              // The data layout for Opus is currently unknown, so we do not export
    
              // extradata at all. Multichannel streams are not supported.
    
      ✗
              if (st->codecpar->ch_layout.nb_channels > 2) {
    
      ✗
                  avpriv_request_sample(s, "multichannel Opus in CAF");
    
      ✗
                  return AVERROR_PATCHWELCOME;
    
              }
    
      ✗
              avio_skip(pb, size);
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

      2
          } else if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0) {
    
      ✗
              return ret;
    
          }
    
      4
          return 0;
    
      }
    
      /** Read packet table chunk */
    
      3
      static int read_pakt_chunk(AVFormatContext *s, int64_t size)
    
      {
    
      3
          AVIOContext *pb = s->pb;
    
      3
          AVStream *st      = s->streams[0];
    
      3
          CafContext *caf   = s->priv_data;
    
      3
          int64_t pos = 0, ccount, num_packets;
    
          int i;
    
          int ret;
    
      3
          ccount = avio_tell(pb);
    
      3
          num_packets = avio_rb64(pb);
    
        2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.

      3
          if (num_packets < 0 || INT32_MAX / sizeof(AVIndexEntry) < num_packets)
    
      ✗
              return AVERROR_INVALIDDATA;
    
      3
          st->nb_frames  = avio_rb64(pb); /* valid frames */
    
      3
          st->nb_frames += avio_rb32(pb); /* priming frames */
    
      3
          st->nb_frames += avio_rb32(pb); /* remainder frames */
    
        1/4✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

      3
          if (caf->bytes_per_packet > 0 && caf->frames_per_packet > 0) {
    
      ✗
              st->duration = caf->frames_per_packet * num_packets;
    
      ✗
              pos          = caf-> bytes_per_packet * num_packets;
    
          } else {
    
      3
              st->duration = 0;
    
        2/2✓ Branch 0 taken 540 times.
✓ Branch 1 taken 3 times.

      543
              for (i = 0; i < num_packets; i++) {
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 540 times.

      540
                  if (avio_feof(pb))
    
      ✗
                      return AVERROR_INVALIDDATA;
    
      540
                  ret = av_add_index_entry(s->streams[0], pos, st->duration, 0, 0, AVINDEX_KEYFRAME);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 540 times.

      540
                  if (ret < 0)
    
      ✗
                      return ret;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 540 times.

      540
                  pos += caf->bytes_per_packet ? caf->bytes_per_packet : ff_mp4_read_descr_len(pb);
    
        1/2✓ Branch 0 taken 540 times.
✗ Branch 1 not taken.

      540
                  st->duration += caf->frames_per_packet ? caf->frames_per_packet : ff_mp4_read_descr_len(pb);
    
              }
    
          }
    
        2/4✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.

      3
          if (avio_tell(pb) - ccount > size || size > INT64_MAX - ccount) {
    
      ✗
              av_log(s, AV_LOG_ERROR, "error reading packet table\n");
    
      ✗
              return AVERROR_INVALIDDATA;
    
          }
    
      3
          avio_seek(pb, ccount + size, SEEK_SET);
    
      3
          caf->num_bytes = pos;
    
      3
          return 0;
    
      }
    
      /** Read information chunk */
    
      3
      static void read_info_chunk(AVFormatContext *s, int64_t size)
    
      {
    
      3
          AVIOContext *pb = s->pb;
    
          unsigned int i;
    
      3
          unsigned int nb_entries = avio_rb32(pb);
    
        3/4✓ Branch 0 taken 27 times.
✓ Branch 1 taken 3 times.
✓ Branch 3 taken 27 times.
✗ Branch 4 not taken.

      30
          for (i = 0; i < nb_entries && !avio_feof(pb); i++) {
    
              char key[32];
    
              char value[1024];
    
      27
              avio_get_str(pb, INT_MAX, key, sizeof(key));
    
      27
              avio_get_str(pb, INT_MAX, value, sizeof(value));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.

      27
              if (!*key)
    
      ✗
                  continue;
    
      27
              av_dict_set(&s->metadata, key, value, 0);
    
          }
    
      3
      }
    
      9
      static int read_header(AVFormatContext *s)
    
      {
    
      9
          AVIOContext *pb = s->pb;
    
      9
          CafContext *caf = s->priv_data;
    
          AVStream *st;
    
      9
          uint32_t tag = 0;
    
          int found_data, ret;
    
          int64_t size, pos;
    
      9
          avio_skip(pb, 8); /* magic, version, file flags */
    
          /* audio description chunk */
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.

      9
          if (avio_rb32(pb) != MKBETAG('d','e','s','c')) {
    
      ✗
              av_log(s, AV_LOG_ERROR, "desc chunk not present\n");
    
      ✗
              return AVERROR_INVALIDDATA;
    
          }
    
      9
          size = avio_rb64(pb);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (size != 32)
    
      ✗
              return AVERROR_INVALIDDATA;
    
      9
          ret = read_desc_chunk(s);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (ret)
    
      ✗
              return ret;
    
      9
          st = s->streams[0];
    
          /* parse each chunk */
    
      9
          found_data = 0;
    
        1/2✓ Branch 1 taken 37 times.
✗ Branch 2 not taken.

      37
          while (!avio_feof(pb)) {
    
              /* stop at data chunk if seeking is not supported or
    
                 data chunk size is unknown */
    
        4/6✓ Branch 0 taken 12 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 12 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 12 times.
✗ Branch 5 not taken.

      37
              if (found_data && (caf->data_size < 0 || !(pb->seekable & AVIO_SEEKABLE_NORMAL)))
    
                  break;
    
      37
              tag  = avio_rb32(pb);
    
      37
              size = avio_rb64(pb);
    
      37
              pos  = avio_tell(pb);
    
        2/2✓ Branch 1 taken 9 times.
✓ Branch 2 taken 28 times.

      37
              if (avio_feof(pb))
    
      9
                  break;
    
        6/7✓ Branch 0 taken 9 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 3 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.

      28
              switch (tag) {
    
      9
              case MKBETAG('d','a','t','a'):
    
      9
                  avio_skip(pb, 4); /* edit count */
    
      9
                  caf->data_start = avio_tell(pb);
    
        1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.

      9
                  caf->data_size  = size < 0 ? -1 : size - 4;
    
        2/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 9 times.

      9
                  if (caf->data_start < 0 || caf->data_size > INT64_MAX - caf->data_start)
    
      ✗
                      return AVERROR_INVALIDDATA;
    
        2/4✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✗ Branch 3 not taken.

      9
                  if (caf->data_size > 0 && (pb->seekable & AVIO_SEEKABLE_NORMAL))
    
      9
                      avio_skip(pb, caf->data_size);
    
      9
                  found_data = 1;
    
      9
                  break;
    
      8
              case MKBETAG('c','h','a','n'):
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8 times.

      8
                  if ((ret = ff_mov_read_chan(s, s->pb, st, size)) < 0)
    
      ✗
                      return ret;
    
      8
                  break;
    
              /* magic cookie chunk */
    
      4
              case MKBETAG('k','u','k','i'):
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.

      4
                  if (read_kuki_chunk(s, size))
    
      ✗
                      return AVERROR_INVALIDDATA;
    
      4
                  break;
    
              /* packet table chunk */
    
      3
              case MKBETAG('p','a','k','t'):
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.

      3
                  if (read_pakt_chunk(s, size))
    
      ✗
                      return AVERROR_INVALIDDATA;
    
      3
                  break;
    
      3
              case MKBETAG('i','n','f','o'):
    
      3
                  read_info_chunk(s, size);
    
      3
                  break;
    
      ✗
              default:
    
      ✗
                  av_log(s, AV_LOG_WARNING,
    
                         "skipping CAF chunk: %08"PRIX32" (%s), size %"PRId64"\n",
    
      ✗
                         tag, av_fourcc2str(av_bswap32(tag)), size);
    
      1
              case MKBETAG('f','r','e','e'):
    
        1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

      1
                  if (size < 0 && found_data)
    
      ✗
                      goto found_data;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
                  if (size < 0)
    
      ✗
                      return AVERROR_INVALIDDATA;
    
      1
                  break;
    
              }
    
        2/4✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.
✗ Branch 3 not taken.

      28
              if (size > 0 && (pb->seekable & AVIO_SEEKABLE_NORMAL)) {
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 28 times.

      28
                  if (pos > INT64_MAX - size)
    
      ✗
                      return AVERROR_INVALIDDATA;
    
      28
                  avio_seek(pb, pos + size, SEEK_SET);
    
              }
    
          }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

      9
          if (!found_data)
    
      ✗
              return AVERROR_INVALIDDATA;
    
      9
      found_data:
    
        3/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.

      9
          if (caf->bytes_per_packet > 0 && caf->frames_per_packet > 0) {
    
        2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.

      6
              if (caf->data_size > 0 && caf->data_size / caf->bytes_per_packet < INT64_MAX / caf->frames_per_packet)
    
      6
                  st->nb_frames = (caf->data_size / caf->bytes_per_packet) * caf->frames_per_packet;
    
        2/4✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.
✗ Branch 4 not taken.

      3
          } else if (ffstream(st)->nb_index_entries && st->duration > 0) {
    
        2/4✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.

      3
              if (st->codecpar->sample_rate && caf->data_size / st->duration > INT64_MAX / st->codecpar->sample_rate / 8) {
    
      ✗
                  av_log(s, AV_LOG_ERROR, "Overflow during bit rate calculation %d * 8 * %"PRId64"\n",
    
      ✗
                         st->codecpar->sample_rate, caf->data_size / st->duration);
    
      ✗
                  return AVERROR_INVALIDDATA;
    
              }
    
      3
              st->codecpar->bit_rate = st->codecpar->sample_rate * 8LL *
    
      3
                                       (caf->data_size / st->duration);
    
          } else {
    
      ✗
              av_log(s, AV_LOG_ERROR, "Missing packet table. It is required when "
    
                                      "block size or frame size are variable.\n");
    
      ✗
              return AVERROR_INVALIDDATA;
    
          }
    
      9
          avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
    
      9
          st->start_time = 0;
    
          /* position the stream at the start of data */
    
        1/2✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.

      9
          if (caf->data_size >= 0)
    
      9
              avio_seek(pb, caf->data_start, SEEK_SET);
    
      9
          return 0;
    
      }
    
      #define CAF_MAX_PKT_SIZE 4096
    
      125
      static int read_packet(AVFormatContext *s, AVPacket *pkt)
    
      {
    
      125
          AVIOContext *pb = s->pb;
    
      125
          AVStream *st      = s->streams[0];
    
      125
          FFStream *const sti = ffstream(st);
    
      125
          CafContext *caf   = s->priv_data;
    
      125
          int res, pkt_size = 0, pkt_frames = 0;
    
      125
          int64_t left      = CAF_MAX_PKT_SIZE;
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 125 times.

      125
          if (avio_feof(pb))
    
      ✗
              return AVERROR_EOF;
    
          /* don't read past end of data chunk */
    
        1/2✓ Branch 0 taken 125 times.
✗ Branch 1 not taken.

      125
          if (caf->data_size > 0) {
    
      125
              left = (caf->data_start + caf->data_size) - avio_tell(pb);
    
        2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 123 times.

      125
              if (!left)
    
      2
                  return AVERROR_EOF;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 123 times.

      123
              if (left < 0)
    
      ✗
                  return AVERROR(EIO);
    
          }
    
      123
          pkt_frames = caf->frames_per_packet;
    
      123
          pkt_size   = caf->bytes_per_packet;
    
        4/4✓ Branch 0 taken 94 times.
✓ Branch 1 taken 29 times.
✓ Branch 2 taken 71 times.
✓ Branch 3 taken 23 times.

      123
          if (pkt_size > 0 && pkt_frames == 1) {
    
      71
              pkt_size   = (CAF_MAX_PKT_SIZE / pkt_size) * pkt_size;
    
      71
              pkt_size   = FFMIN(pkt_size, left);
    
      71
              pkt_frames = pkt_size / caf->bytes_per_packet;
    
        2/2✓ Branch 0 taken 29 times.
✓ Branch 1 taken 23 times.

      52
          } else if (sti->nb_index_entries) {
    
        1/2✓ Branch 0 taken 29 times.
✗ Branch 1 not taken.

      29
              if (caf->packet_cnt < sti->nb_index_entries - 1) {
    
      29
                  pkt_size   = sti->index_entries[caf->packet_cnt + 1].pos       - sti->index_entries[caf->packet_cnt].pos;
    
      29
                  pkt_frames = sti->index_entries[caf->packet_cnt + 1].timestamp - sti->index_entries[caf->packet_cnt].timestamp;
    
      ✗
              } else if (caf->packet_cnt == sti->nb_index_entries - 1) {
    
      ✗
                  pkt_size   = caf->num_bytes - sti->index_entries[caf->packet_cnt].pos;
    
      ✗
                  pkt_frames = st->duration   - sti->index_entries[caf->packet_cnt].timestamp;
    
              } else {
    
      ✗
                  return AVERROR(EIO);
    
              }
    
          }
    
        3/6✓ Branch 0 taken 123 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 123 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 123 times.

      123
          if (pkt_size == 0 || pkt_frames == 0 || pkt_size > left)
    
      ✗
              return AVERROR(EIO);
    
      123
          res = av_get_packet(pb, pkt, pkt_size);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 123 times.

      123
          if (res < 0)
    
      ✗
              return res;
    
      123
          pkt->size           = res;
    
      123
          pkt->stream_index   = 0;
    
      123
          pkt->dts = pkt->pts = caf->frame_cnt;
    
      123
          caf->packet_cnt++;
    
      123
          caf->frame_cnt += pkt_frames;
    
      123
          return 0;
    
      }
    
      ✗
      static int read_seek(AVFormatContext *s, int stream_index,
    
                           int64_t timestamp, int flags)
    
      {
    
      ✗
          AVStream *st = s->streams[0];
    
      ✗
          FFStream *const sti = ffstream(st);
    
      ✗
          CafContext *caf = s->priv_data;
    
          int64_t pos, packet_cnt, frame_cnt;
    
      ✗
          timestamp = FFMAX(timestamp, 0);
    
      ✗
          if (caf->frames_per_packet > 0 && caf->bytes_per_packet > 0) {
    
              /* calculate new byte position based on target frame position */
    
      ✗
              pos = caf->bytes_per_packet * (timestamp / caf->frames_per_packet);
    
      ✗
              if (caf->data_size > 0)
    
      ✗
                  pos = FFMIN(pos, caf->data_size);
    
      ✗
              packet_cnt = pos / caf->bytes_per_packet;
    
      ✗
              frame_cnt  = caf->frames_per_packet * packet_cnt;
    
      ✗
          } else if (sti->nb_index_entries) {
    
      ✗
              packet_cnt = av_index_search_timestamp(st, timestamp, flags);
    
      ✗
              frame_cnt  = sti->index_entries[packet_cnt].timestamp;
    
      ✗
              pos        = sti->index_entries[packet_cnt].pos;
    
          } else {
    
      ✗
              return -1;
    
          }
    
      ✗
          if (avio_seek(s->pb, pos + caf->data_start, SEEK_SET) < 0)
    
      ✗
              return -1;
    
      ✗
          caf->packet_cnt = packet_cnt;
    
      ✗
          caf->frame_cnt  = frame_cnt;
    
      ✗
          return 0;
    
      }
    
      const FFInputFormat ff_caf_demuxer = {
    
          .p.name         = "caf",
    
          .p.long_name    = NULL_IF_CONFIG_SMALL("Apple CAF (Core Audio Format)"),
    
          .p.codec_tag    = ff_caf_codec_tags_list,
    
          .priv_data_size = sizeof(CafContext),
    
          .read_probe     = probe,
    
          .read_header    = read_header,
    
          .read_packet    = read_packet,
    
          .read_seek      = read_seek,
    
      };
鼠标cpi是什么意思	落红的血是什么样子的	局级干部是什么级别	四件套包括什么	咽喉炎吃什么药管用
眼色是什么意思	孕妇吃什么鱼	肺结节吃什么药	咽颊炎吃什么药	梦见砍竹子是什么意思
包皮嵌顿是什么	睡觉被口水呛醒是什么原因	女人的排卵期是什么时候	女性排卵有什么症状或感觉	卜卜脆是什么意思
no.是什么意思	买什么保险最好最划算	项羽姓什么	阿胶是什么做的	大便不正常是什么原因造成的
成也萧何败也萧何什么意思hcv8jop7ns0r.cn	彩色相片什么时候出现96micro.com	什么叫佛hcv8jop6ns5r.cn	云仓是什么hcv8jop7ns3r.cn	点灯是什么意思hcv7jop4ns8r.cn
例假期间吃什么食物好hcv7jop7ns2r.cn	fourone是什么牌子luyiluode.com	尿素测定是查什么hcv9jop0ns5r.cn	在什么什么前面hcv7jop5ns3r.cn	十字架代表什么意思hcv9jop0ns4r.cn
拉肚子可以喝什么饮料hcv9jop7ns5r.cn	中焦不通吃什么药jingluanji.com	河粉为什么叫河粉hcv8jop9ns6r.cn	巨石强森是什么人种hcv8jop4ns3r.cn	昆仑雪菊有什么作用hcv8jop0ns3r.cn
暴龙眼镜什么档次hcv9jop4ns4r.cn	什么样的水果hcv7jop7ns0r.cn	伛偻是什么意思luyiluode.com	看见蛇过马路什么征兆hcv8jop8ns2r.cn	舌头有问题看什么科hcv8jop1ns3r.cn
Function (Line)	Call count	Block coverage
probe (line 54)	called 7252 times, returned 7252 times	70.0%
read_desc_chunk (line 68)	called 9 times, returned 9 times	92.0%
read_header (line 302)	called 9 times, returned 9 times	76.0%
read_info_chunk (line 286)	called 3 times, returned 3 times	92.0%
read_kuki_chunk (line 111)	called 4 times, returned 4 times	22.0%
read_packet (line 428)	called 125 times, returned 125 times	75.0%
read_pakt_chunk (line 240)	called 3 times, returned 3 times	74.0%
read_seek (line 485)	not called	0.0%