（信息）道简心康心血管康复医生集团成立 - 生的反义词是什么新闻网

Directory:	../../../ffmpeg/
File:	src/libavformat/options.c
Date:	2025-08-04 00:43:16
	Exec	Total	Coverage
Lines:	173	244	70.9%
Functions:	16	19	84.2%
Branches:	95	138	68.8%
  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
    
       *
    
       * 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
    
       */
    
      #include "avformat.h"
    
      #include "avformat_internal.h"
    
      #include "avio_internal.h"
    
      #include "demux.h"
    
      #include "internal.h"
    
      #include "libavcodec/avcodec.h"
    
      #include "libavcodec/codec_par.h"
    
      #include "libavutil/avassert.h"
    
      #include "libavutil/iamf.h"
    
      #include "libavutil/internal.h"
    
      #include "libavutil/intmath.h"
    
      #include "libavutil/mem.h"
    
      #include "libavutil/opt.h"
    
      /**
    
       * @file
    
       * Options definition for AVFormatContext.
    
       */
    
      FF_DISABLE_DEPRECATION_WARNINGS
    
      #include "options_table.h"
    
      FF_ENABLE_DEPRECATION_WARNINGS
    
      2606
      static const char* format_to_name(void* ptr)
    
      {
    
      2606
          AVFormatContext* fc = (AVFormatContext*) ptr;
    
        2/2✓ Branch 0 taken 1688 times.
✓ Branch 1 taken 918 times.

      2606
          if(fc->iformat) return fc->iformat->name;
    
        1/2✓ Branch 0 taken 918 times.
✗ Branch 1 not taken.

      918
          else if(fc->oformat) return fc->oformat->name;
    
      ✗
          else return fc->av_class->class_name;
    
      }
    
      56821
      static void *format_child_next(void *obj, void *prev)
    
      {
    
      56821
          AVFormatContext *s = obj;
    
        4/4✓ Branch 0 taken 23218 times.
✓ Branch 1 taken 33603 times.
✓ Branch 2 taken 22750 times.
✓ Branch 3 taken 468 times.

      56821
          if (!prev && s->priv_data &&
    
        4/4✓ Branch 0 taken 22748 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 2526 times.
✓ Branch 3 taken 20222 times.

      22750
              ((s->iformat && s->iformat->priv_class) ||
    
        3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2526 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.

      2528
                s->oformat && s->oformat->priv_class))
    
      20224
              return s->priv_data;
    
        6/6✓ Branch 0 taken 27126 times.
✓ Branch 1 taken 9471 times.
✓ Branch 2 taken 27114 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 13557 times.
✓ Branch 5 taken 13557 times.

      36597
          if (s->pb && s->pb->av_class && prev != s->pb)
    
      13557
              return s->pb;
    
      23040
          return NULL;
    
      }
    
      enum {
    
          CHILD_CLASS_ITER_AVIO = 0,
    
          CHILD_CLASS_ITER_MUX,
    
          CHILD_CLASS_ITER_DEMUX,
    
          CHILD_CLASS_ITER_DONE,
    
      };
    
      #define ITER_STATE_SHIFT 16
    
      27791653
      static const AVClass *format_child_class_iterate(void **iter)
    
      {
    
          // we use the low 16 bits of iter as the value to be passed to
    
          // av_(de)muxer_iterate()
    
      27791653
          void *val = (void*)(((uintptr_t)*iter) & ((1 << ITER_STATE_SHIFT) - 1));
    
      27791653
          unsigned int state = ((uintptr_t)*iter) >> ITER_STATE_SHIFT;
    
      27791653
          const AVClass *ret = NULL;
    
        2/2✓ Branch 0 taken 117387 times.
✓ Branch 1 taken 27674266 times.

      27791653
          if (state == CHILD_CLASS_ITER_AVIO) {
    
      117387
              ret = &ff_avio_class;
    
      117387
              state++;
    
      117387
              goto finish;
    
          }
    
        2/2✓ Branch 0 taken 8563519 times.
✓ Branch 1 taken 19110747 times.

      27674266
          if (state == CHILD_CLASS_ITER_MUX) {
    
              const AVOutputFormat *ofmt;
    
        2/2✓ Branch 1 taken 21820014 times.
✓ Branch 2 taken 117258 times.

      21937272
              while ((ofmt = av_muxer_iterate(&val))) {
    
      21820014
                  ret = ofmt->priv_class;
    
        2/2✓ Branch 0 taken 8446261 times.
✓ Branch 1 taken 13373753 times.

      21820014
                  if (ret)
    
      8446261
                      goto finish;
    
              }
    
      117258
              val = NULL;
    
      117258
              state++;
    
          }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 19228005 times.

      19228005
          if (state == CHILD_CLASS_ITER_DEMUX) {
    
              const AVInputFormat *ifmt;
    
        2/2✓ Branch 1 taken 42560158 times.
✓ Branch 2 taken 117228 times.

      42677386
              while ((ifmt = av_demuxer_iterate(&val))) {
    
      42560158
                  ret = ifmt->priv_class;
    
        2/2✓ Branch 0 taken 19110777 times.
✓ Branch 1 taken 23449381 times.

      42560158
                  if (ret)
    
      19110777
                      goto finish;
    
              }
    
      117228
              val = NULL;
    
      117228
              state++;
    
          }
    
      ✗
      finish:
    
          // make sure none av_(de)muxer_iterate does not set the high bits of val
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27791653 times.

      27791653
          av_assert0(!((uintptr_t)val >> ITER_STATE_SHIFT));
    
      27791653
          *iter = (void*)((uintptr_t)val | (state << ITER_STATE_SHIFT));
    
      27791653
          return ret;
    
      }
    
      2606
      static AVClassCategory get_category(void *ptr)
    
      {
    
      2606
          AVFormatContext* s = ptr;
    
        2/2✓ Branch 0 taken 1688 times.
✓ Branch 1 taken 918 times.

      2606
          if(s->iformat) return AV_CLASS_CATEGORY_DEMUXER;
    
      918
          else           return AV_CLASS_CATEGORY_MUXER;
    
      }
    
      static const AVClass av_format_context_class = {
    
          .class_name     = "AVFormatContext",
    
          .item_name      = format_to_name,
    
          .option         = avformat_options,
    
          .version        = LIBAVUTIL_VERSION_INT,
    
          .child_next     = format_child_next,
    
          .child_class_iterate = format_child_class_iterate,
    
          .category       = AV_CLASS_CATEGORY_MUXER,
    
          .get_category   = get_category,
    
      };
    
      108125
      static int io_open_default(AVFormatContext *s, AVIOContext **pb,
    
                                 const char *url, int flags, AVDictionary **options)
    
      {
    
          int loglevel;
    
        2/2✓ Branch 0 taken 103559 times.
✓ Branch 1 taken 4566 times.

      108125
          if (!strcmp(url, s->url) ||
    
        4/4✓ Branch 0 taken 102750 times.
✓ Branch 1 taken 809 times.
✓ Branch 2 taken 62 times.
✓ Branch 3 taken 102688 times.

      103559
              s->iformat && !strcmp(s->iformat->name, "image2") ||
    
        4/4✓ Branch 0 taken 809 times.
✓ Branch 1 taken 62 times.
✓ Branch 2 taken 663 times.
✓ Branch 3 taken 146 times.

      871
              s->oformat && !strcmp(s->oformat->name, "image2")
    
          ) {
    
      107917
              loglevel = AV_LOG_DEBUG;
    
          } else
    
      208
              loglevel = AV_LOG_INFO;
    
        2/2✓ Branch 0 taken 819 times.
✓ Branch 1 taken 107306 times.

      108125
          av_log(s, loglevel, "Opening \'%s\' for %s\n", url, flags & AVIO_FLAG_WRITE ? "writing" : "reading");
    
      108125
          return ffio_open_whitelist(pb, url, flags, &s->interrupt_callback, options, s->protocol_whitelist, s->protocol_blacklist);
    
      }
    
      108124
      static int io_close2_default(AVFormatContext *s, AVIOContext *pb)
    
      {
    
      108124
          return avio_close(pb);
    
      }
    
      16148
      AVFormatContext *avformat_alloc_context(void)
    
      {
    
          FormatContextInternal *fci;
    
          FFFormatContext *si;
    
          AVFormatContext *s;
    
      16148
          fci = av_mallocz(sizeof(*fci));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16148 times.

      16148
          if (!fci)
    
      ✗
              return NULL;
    
      16148
          si = &fci->fc;
    
      16148
          s = &si->pub;
    
      16148
          s->av_class = &av_format_context_class;
    
      16148
          s->io_open  = io_open_default;
    
      16148
          s->io_close2= io_close2_default;
    
      16148
          av_opt_set_defaults(s);
    
      16148
          si->pkt = av_packet_alloc();
    
      16148
          si->parse_pkt = av_packet_alloc();
    
        2/4✓ Branch 0 taken 16148 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16148 times.

      16148
          if (!si->pkt || !si->parse_pkt) {
    
      ✗
              avformat_free_context(s);
    
      ✗
              return NULL;
    
          }
    
      16148
          return s;
    
      }
    
      132269
      const AVClass *avformat_get_class(void)
    
      {
    
      132269
          return &av_format_context_class;
    
      }
    
      #define DISPOSITION_OPT(ctx)                                                                                                        \
    
          { "disposition", NULL, offsetof(ctx, disposition), AV_OPT_TYPE_FLAGS, { .i64 = 0 },                                             \
    
              .flags = AV_OPT_FLAG_ENCODING_PARAM, .unit = "disposition" },                                                               \
    
              { "default",            .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT           },    .unit = "disposition" }, \
    
              { "dub",                .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB               },    .unit = "disposition" }, \
    
              { "original",           .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL          },    .unit = "disposition" }, \
    
              { "comment",            .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT           },    .unit = "disposition" }, \
    
              { "lyrics",             .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS            },    .unit = "disposition" }, \
    
              { "karaoke",            .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE           },    .unit = "disposition" }, \
    
              { "forced",             .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED            },    .unit = "disposition" }, \
    
              { "hearing_impaired",   .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED  },    .unit = "disposition" }, \
    
              { "visual_impaired",    .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED   },    .unit = "disposition" }, \
    
              { "clean_effects",      .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS     },    .unit = "disposition" }, \
    
              { "attached_pic",       .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ATTACHED_PIC      },    .unit = "disposition" }, \
    
              { "timed_thumbnails",   .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_TIMED_THUMBNAILS  },    .unit = "disposition" }, \
    
              { "non_diegetic",       .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_NON_DIEGETIC      },    .unit = "disposition" }, \
    
              { "captions",           .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS          },    .unit = "disposition" }, \
    
              { "descriptions",       .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS      },    .unit = "disposition" }, \
    
              { "metadata",           .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA          },    .unit = "disposition" }, \
    
              { "dependent",          .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEPENDENT         },    .unit = "disposition" }, \
    
              { "still_image",        .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_STILL_IMAGE       },    .unit = "disposition" }, \
    
              { "multilayer",         .type = AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_MULTILAYER        },    .unit = "disposition" }
    
      static const AVOption stream_options[] = {
    
          DISPOSITION_OPT(AVStream),
    
          { "discard", NULL, offsetof(AVStream, discard), AV_OPT_TYPE_INT, { .i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX,
    
              .flags = AV_OPT_FLAG_DECODING_PARAM, .unit = "avdiscard" },
    
              { "none",               .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONE     }, .unit = "avdiscard" },
    
              { "default",            .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_DEFAULT  }, .unit = "avdiscard" },
    
              { "noref",              .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONREF   }, .unit = "avdiscard" },
    
              { "bidir",              .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_BIDIR    }, .unit = "avdiscard" },
    
              { "nointra",            .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONINTRA }, .unit = "avdiscard" },
    
              { "nokey",              .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONKEY   }, .unit = "avdiscard" },
    
              { "all",                .type = AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL      }, .unit = "avdiscard" },
    
          { NULL }
    
      };
    
      static const AVClass stream_class = {
    
          .class_name     = "AVStream",
    
          .item_name      = av_default_item_name,
    
          .version        = LIBAVUTIL_VERSION_INT,
    
          .option         = stream_options,
    
      };
    
      1
      const AVClass *av_stream_get_class(void)
    
      {
    
      1
          return &stream_class;
    
      }
    
      17492
      AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
    
      {
    
          FFStream *sti;
    
          AVStream *st;
    
          AVStream **streams;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17492 times.

      17492
          if (s->nb_streams >= s->max_streams) {
    
      ✗
              av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter"
    
                     " (%d), see the documentation if you wish to increase it\n",
    
                     s->max_streams);
    
      ✗
              return NULL;
    
          }
    
      17492
          streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17492 times.

      17492
          if (!streams)
    
      ✗
              return NULL;
    
      17492
          s->streams = streams;
    
      17492
          sti = av_mallocz(sizeof(*sti));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17492 times.

      17492
          if (!sti)
    
      ✗
              return NULL;
    
      17492
          st = &sti->pub;
    
      17492
          st->av_class = &stream_class;
    
      17492
          st->codecpar = avcodec_parameters_alloc();
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17492 times.

      17492
          if (!st->codecpar)
    
      ✗
              goto fail;
    
      17492
          sti->fmtctx = s;
    
        2/2✓ Branch 0 taken 8539 times.
✓ Branch 1 taken 8953 times.

      17492
          if (s->iformat) {
    
      8539
              sti->avctx = avcodec_alloc_context3(NULL);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8539 times.

      8539
              if (!sti->avctx)
    
      ✗
                  goto fail;
    
      8539
              sti->info = av_mallocz(sizeof(*sti->info));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8539 times.

      8539
              if (!sti->info)
    
      ✗
                  goto fail;
    
      #if FF_API_R_FRAME_RATE
    
      8539
              sti->info->last_dts      = AV_NOPTS_VALUE;
    
      #endif
    
      8539
              sti->info->fps_first_dts = AV_NOPTS_VALUE;
    
      8539
              sti->info->fps_last_dts  = AV_NOPTS_VALUE;
    
              /* default pts setting is MPEG-like */
    
      8539
              avpriv_set_pts_info(st, 33, 1, 90000);
    
              /* we set the current DTS to 0 so that formats without any timestamps
    
               * but durations get some timestamps, formats with some unknown
    
               * timestamps have their first few packets buffered and the
    
               * timestamps corrected before they are returned to the user */
    
      8539
              sti->cur_dts = RELATIVE_TS_BASE;
    
          } else {
    
      8953
              sti->cur_dts = AV_NOPTS_VALUE;
    
          }
    
      17492
          st->index      = s->nb_streams;
    
      17492
          st->start_time = AV_NOPTS_VALUE;
    
      17492
          st->duration   = AV_NOPTS_VALUE;
    
      17492
          sti->first_dts     = AV_NOPTS_VALUE;
    
      17492
          sti->probe_packets = s->max_probe_packets;
    
      17492
          sti->pts_wrap_reference = AV_NOPTS_VALUE;
    
      17492
          sti->pts_wrap_behavior  = AV_PTS_WRAP_IGNORE;
    
      17492
          sti->last_IP_pts = AV_NOPTS_VALUE;
    
      17492
          sti->last_dts_for_order_check = AV_NOPTS_VALUE;
    
        2/2✓ Branch 0 taken 297364 times.
✓ Branch 1 taken 17492 times.

      314856
          for (int i = 0; i < MAX_REORDER_DELAY + 1; i++)
    
      297364
              sti->pts_buffer[i] = AV_NOPTS_VALUE;
    
      17492
          st->sample_aspect_ratio = (AVRational) { 0, 1 };
    
      #if FF_API_INTERNAL_TIMING
    
      17492
          sti->transferred_mux_tb = (AVRational) { 0, 1 };;
    
      #endif
    
      17492
          sti->need_context_update = 1;
    
      17492
          s->streams[s->nb_streams++] = st;
    
      17492
          return st;
    
      ✗
      fail:
    
      ✗
          ff_free_stream(&st);
    
      ✗
          return NULL;
    
      }
    
      #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
    
      #define OFFSET(x) offsetof(AVStreamGroupTileGrid, x)
    
      static const AVOption tile_grid_options[] = {
    
          { "grid_size", "size of the output canvas", OFFSET(coded_width),
    
              AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
    
          { "output_size", "size of valid pixels in output image meant for presentation", OFFSET(width),
    
              AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
    
          { "background_color", "set a background color for unused pixels",
    
              OFFSET(background), AV_OPT_TYPE_COLOR, { .str = "black"}, 0, 0, FLAGS },
    
          { "horizontal_offset", NULL, OFFSET(horizontal_offset), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
    
          { "vertical_offset",   NULL, OFFSET(vertical_offset),   AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
    
          { NULL },
    
      };
    
      #undef OFFSET
    
      static const AVClass tile_grid_class = {
    
          .class_name = "AVStreamGroupTileGrid",
    
          .version    = LIBAVUTIL_VERSION_INT,
    
          .option     = tile_grid_options,
    
      };
    
      #define OFFSET(x) offsetof(AVStreamGroupLCEVC, x)
    
      static const AVOption lcevc_options[] = {
    
          { "video_size", "size of video after LCEVC enhancement has been applied", OFFSET(width),
    
              AV_OPT_TYPE_IMAGE_SIZE, { .str = NULL }, 0, INT_MAX, FLAGS },
    
          { NULL },
    
      };
    
      #undef OFFSET
    
      static const AVClass lcevc_class = {
    
          .class_name = "AVStreamGroupLCEVC",
    
          .version    = LIBAVUTIL_VERSION_INT,
    
          .option     = lcevc_options,
    
      };
    
      168
      static void *stream_group_child_next(void *obj, void *prev)
    
      {
    
      168
          AVStreamGroup *stg = obj;
    
        2/2✓ Branch 0 taken 95 times.
✓ Branch 1 taken 73 times.

      168
          if (!prev) {
    
        2/5✓ Branch 0 taken 49 times.
✓ Branch 1 taken 46 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

      95
              switch(stg->type) {
    
      49
              case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
    
      49
                  return stg->params.iamf_audio_element;
    
      46
              case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
    
      46
                  return stg->params.iamf_mix_presentation;
    
      ✗
              case AV_STREAM_GROUP_PARAMS_TILE_GRID:
    
      ✗
                  return stg->params.tile_grid;
    
      ✗
              case AV_STREAM_GROUP_PARAMS_LCEVC:
    
      ✗
                  return stg->params.lcevc;
    
      ✗
              default:
    
      ✗
                  break;
    
              }
    
          }
    
      73
          return NULL;
    
      }
    
      #undef FLAGS
    
      ✗
      static const AVClass *stream_group_child_iterate(void **opaque)
    
      {
    
      ✗
          uintptr_t i = (uintptr_t)*opaque;
    
      ✗
          const AVClass *ret = NULL;
    
      ✗
          switch(i) {
    
      ✗
          case AV_STREAM_GROUP_PARAMS_NONE:
    
      ✗
              i++;
    
          // fall-through
    
      ✗
          case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
    
      ✗
              ret = av_iamf_audio_element_get_class();
    
      ✗
              break;
    
      ✗
          case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
    
      ✗
              ret = av_iamf_mix_presentation_get_class();
    
      ✗
              break;
    
      ✗
          case AV_STREAM_GROUP_PARAMS_TILE_GRID:
    
      ✗
              ret = &tile_grid_class;
    
      ✗
              break;
    
      ✗
          case AV_STREAM_GROUP_PARAMS_LCEVC:
    
      ✗
              ret = &lcevc_class;
    
      ✗
              break;
    
      ✗
          default:
    
      ✗
              break;
    
          }
    
      ✗
          if (ret)
    
      ✗
              *opaque = (void*)(i + 1);
    
      ✗
          return ret;
    
      }
    
      static const AVOption stream_group_options[] = {
    
          DISPOSITION_OPT(AVStreamGroup),
    
          {"id", "Set group id", offsetof(AVStreamGroup, id), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, AV_OPT_FLAG_ENCODING_PARAM },
    
          { NULL }
    
      };
    
      static const AVClass stream_group_class = {
    
          .class_name     = "AVStreamGroup",
    
          .item_name      = av_default_item_name,
    
          .version        = LIBAVUTIL_VERSION_INT,
    
          .option         = stream_group_options,
    
          .child_next     = stream_group_child_next,
    
          .child_class_iterate = stream_group_child_iterate,
    
      };
    
      ✗
      const AVClass *av_stream_group_get_class(void)
    
      {
    
      ✗
          return &stream_group_class;
    
      }
    
      85
      AVStreamGroup *avformat_stream_group_create(AVFormatContext *s,
    
                                                  enum AVStreamGroupParamsType type,
    
                                                  AVDictionary **options)
    
      {
    
          AVStreamGroup **stream_groups;
    
          AVStreamGroup *stg;
    
          FFStreamGroup *stgi;
    
      85
          stream_groups = av_realloc_array(s->stream_groups, s->nb_stream_groups + 1,
    
                                           sizeof(*stream_groups));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.

      85
          if (!stream_groups)
    
      ✗
              return NULL;
    
      85
          s->stream_groups = stream_groups;
    
      85
          stgi = av_mallocz(sizeof(*stgi));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.

      85
          if (!stgi)
    
      ✗
              return NULL;
    
      85
          stg = &stgi->pub;
    
      85
          stg->av_class = &stream_group_class;
    
      85
          av_opt_set_defaults(stg);
    
      85
          stg->type = type;
    
        3/5✓ Branch 0 taken 41 times.
✓ Branch 1 taken 38 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

      85
          switch (type) {
    
      41
          case AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT:
    
      41
              stg->params.iamf_audio_element = av_iamf_audio_element_alloc();
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.

      41
              if (!stg->params.iamf_audio_element)
    
      ✗
                  goto fail;
    
      41
              break;
    
      38
          case AV_STREAM_GROUP_PARAMS_IAMF_MIX_PRESENTATION:
    
      38
              stg->params.iamf_mix_presentation = av_iamf_mix_presentation_alloc();
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38 times.

      38
              if (!stg->params.iamf_mix_presentation)
    
      ✗
                  goto fail;
    
      38
              break;
    
      6
          case AV_STREAM_GROUP_PARAMS_TILE_GRID:
    
      6
              stg->params.tile_grid = av_mallocz(sizeof(*stg->params.tile_grid));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.

      6
              if (!stg->params.tile_grid)
    
      ✗
                  goto fail;
    
      6
              stg->params.tile_grid->av_class = &tile_grid_class;
    
      6
              av_opt_set_defaults(stg->params.tile_grid);
    
      6
              break;
    
      ✗
          case AV_STREAM_GROUP_PARAMS_LCEVC:
    
      ✗
              stg->params.lcevc = av_mallocz(sizeof(*stg->params.lcevc));
    
      ✗
              if (!stg->params.lcevc)
    
      ✗
                  goto fail;
    
      ✗
              stg->params.lcevc->av_class = &lcevc_class;
    
      ✗
              av_opt_set_defaults(stg->params.lcevc);
    
      ✗
              break;
    
      ✗
          default:
    
      ✗
              goto fail;
    
          }
    
        2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 62 times.

      85
          if (options) {
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.

      23
              if (av_opt_set_dict2(stg, options, AV_OPT_SEARCH_CHILDREN))
    
      ✗
                  goto fail;
    
          }
    
      85
          stgi->fmtctx = s;
    
      85
          stg->index   = s->nb_stream_groups;
    
      85
          s->stream_groups[s->nb_stream_groups++] = stg;
    
      85
          return stg;
    
      ✗
      fail:
    
      ✗
          ff_free_stream_group(&stg);
    
      ✗
          return NULL;
    
      }
    
      383
      static int stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
    
      {
    
      383
          AVStream **streams = av_realloc_array(stg->streams, stg->nb_streams + 1,
    
                                                sizeof(*stg->streams));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 383 times.

      383
          if (!streams)
    
      ✗
              return AVERROR(ENOMEM);
    
      383
          stg->streams = streams;
    
      383
          stg->streams[stg->nb_streams++] = st;
    
      383
          return 0;
    
      }
    
      389
      int avformat_stream_group_add_stream(AVStreamGroup *stg, AVStream *st)
    
      {
    
      389
          const FFStreamGroup *stgi = cffstreamgroup(stg);
    
      389
          const FFStream *sti = cffstream(st);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 389 times.

      389
          if (stgi->fmtctx != sti->fmtctx)
    
      ✗
              return AVERROR(EINVAL);
    
        2/2✓ Branch 0 taken 956 times.
✓ Branch 1 taken 383 times.

      1339
          for (int i = 0; i < stg->nb_streams; i++)
    
        2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 950 times.

      956
              if (stg->streams[i]->index == st->index)
    
      6
                  return AVERROR(EEXIST);
    
      383
          return stream_group_add_stream(stg, st);
    
      }
    
      144425
      static int option_is_disposition(const AVOption *opt)
    
      {
    
      277455
          return opt->type == AV_OPT_TYPE_CONST &&
    
        5/6✓ Branch 0 taken 133030 times.
✓ Branch 1 taken 11395 times.
✓ Branch 2 taken 133030 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 110770 times.
✓ Branch 5 taken 22260 times.

      144425
                 opt->unit && !strcmp(opt->unit, "disposition");
    
      }
    
      ✗
      int av_disposition_from_string(const char *disp)
    
      {
    
      ✗
          for (const AVOption *opt = stream_options; opt->name; opt++)
    
      ✗
              if (option_is_disposition(opt) && !strcmp(disp, opt->name))
    
      ✗
                  return opt->default_val.i64;
    
      ✗
          return AVERROR(EINVAL);
    
      }
    
      8480
      const char *av_disposition_to_string(int disposition)
    
      {
    
          int val;
    
        2/2✓ Branch 0 taken 265 times.
✓ Branch 1 taken 8215 times.

      8480
          if (disposition <= 0)
    
      265
              return NULL;
    
      8215
          val = 1 << ff_ctz(disposition);
    
        2/2✓ Branch 0 taken 144425 times.
✓ Branch 1 taken 3180 times.

      147605
          for (const AVOption *opt = stream_options; opt->name; opt++)
    
        4/4✓ Branch 1 taken 110770 times.
✓ Branch 2 taken 33655 times.
✓ Branch 3 taken 5035 times.
✓ Branch 4 taken 105735 times.

      144425
              if (option_is_disposition(opt) && opt->default_val.i64 == val)
    
      5035
                  return opt->name;
    
      3180
          return NULL;
    
      }
2026是什么年	猪血不能和什么一起吃	为什么一到晚上就咳嗽	晚生是什么意思	青睐什么意思
牙疼挂什么科	血小板低会引发什么病	明年是什么年啊	肺结核传染途径是什么	什么人不适合喝骆驼奶
奶酪和芝士有什么区别	六月二十五号是什么星座	左手小手指麻木是什么原因引起的	头皮痒用什么洗发水效果好	扁桃和芒果有什么区别
元字五行属什么	1959年属什么	一碗香是什么菜	女人喜欢什么礼物	彪马属于什么档次
唐氏筛查是检查什么hcv8jop7ns1r.cn	什么食物含锌最多inbungee.com	土字旁的字与什么有关hcv8jop4ns0r.cn	王妃是什么意思hcv9jop8ns0r.cn	糖类抗原125高是什么意思hcv9jop3ns6r.cn
双11是什么节日dajiketang.com	化疗和放疗什么区别fenrenren.com	堆肥是什么意思hcv8jop8ns7r.cn	唇炎涂什么药膏hcv8jop4ns3r.cn	母亲节送妈妈什么shenchushe.com
户名是什么意思cl108k.com	肝疼吃什么药好naasee.com	小米手机最新款是什么型号hcv8jop0ns1r.cn	喝什么茶可以降血脂hcv8jop8ns7r.cn	粒细胞低是什么原因hcv9jop7ns3r.cn
1952年属什么hcv9jop3ns7r.cn	什么是翘舌音hcv9jop8ns2r.cn	乙肝对身体有什么影响hcv9jop5ns6r.cn	饿了么什么时候成立的hcv9jop1ns2r.cn	重庆为什么叫雾都hcv8jop5ns4r.cn
Function (Line)	Call count	Block coverage
av_disposition_from_string (line 534)	not called	0.0%
av_disposition_to_string (line 542)	called 8480 times, returned 8480 times	100.0%
av_stream_get_class (line 239)	called 1 time, returned 1 time	100.0%
av_stream_group_get_class (line 428)	not called	0.0%
avformat_alloc_context (line 162)	called 16148 times, returned 16148 times	75.0%
avformat_get_class (line 190)	called 132269 times, returned 132269 times	100.0%
avformat_new_stream (line 244)	called 17492 times, returned 17492 times	70.0%
avformat_stream_group_add_stream (line 513)	called 389 times, returned 389 times	91.0%
avformat_stream_group_create (line 433)	called 85 times, returned 85 times	61.0%
format_child_class_iterate (line 75)	called 27791653 times, returned 27791653 times	88.0%
format_child_next (line 53)	called 56821 times, returned 56821 times	100.0%
format_to_name (line 45)	called 2606 times, returned 2606 times	83.0%
get_category (line 121)	called 2606 times, returned 2606 times	100.0%
io_close2_default (line 157)	called 108124 times, returned 108124 times	100.0%
io_open_default (line 139)	called 108125 times, returned 108125 times	100.0%
option_is_disposition (line 528)	called 144425 times, returned 144425 times	100.0%
stream_group_add_stream (line 500)	called 383 times, returned 383 times	80.0%
stream_group_child_iterate (line 383)	not called	0.0%
stream_group_child_next (line 361)	called 168 times, returned 168 times	67.0%