LCOV - code coverage report
Current view: top level - libavcodec - utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 962 1320 72.9 %
Date: 2017-12-16 13:57:32 Functions: 60 83 72.3 %

          Line data    Source code
       1             : /*
       2             :  * utils for libavcodec
       3             :  * Copyright (c) 2001 Fabrice Bellard
       4             :  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * utils.
      26             :  */
      27             : 
      28             : #include "config.h"
      29             : #include "libavutil/atomic.h"
      30             : #include "libavutil/attributes.h"
      31             : #include "libavutil/avassert.h"
      32             : #include "libavutil/avstring.h"
      33             : #include "libavutil/bprint.h"
      34             : #include "libavutil/channel_layout.h"
      35             : #include "libavutil/crc.h"
      36             : #include "libavutil/frame.h"
      37             : #include "libavutil/hwcontext.h"
      38             : #include "libavutil/internal.h"
      39             : #include "libavutil/mathematics.h"
      40             : #include "libavutil/mem_internal.h"
      41             : #include "libavutil/pixdesc.h"
      42             : #include "libavutil/imgutils.h"
      43             : #include "libavutil/samplefmt.h"
      44             : #include "libavutil/dict.h"
      45             : #include "libavutil/thread.h"
      46             : #include "avcodec.h"
      47             : #include "decode.h"
      48             : #include "hwaccel.h"
      49             : #include "libavutil/opt.h"
      50             : #include "me_cmp.h"
      51             : #include "mpegvideo.h"
      52             : #include "thread.h"
      53             : #include "frame_thread_encoder.h"
      54             : #include "internal.h"
      55             : #include "raw.h"
      56             : #include "bytestream.h"
      57             : #include "version.h"
      58             : #include <stdlib.h>
      59             : #include <stdarg.h>
      60             : #include <stdatomic.h>
      61             : #include <limits.h>
      62             : #include <float.h>
      63             : #if CONFIG_ICONV
      64             : # include <iconv.h>
      65             : #endif
      66             : 
      67             : #include "libavutil/ffversion.h"
      68             : const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
      69             : 
      70             : #if HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS2THREADS
      71       32570 : static int default_lockmgr_cb(void **arg, enum AVLockOp op)
      72             : {
      73       32570 :     void * volatile * mutex = arg;
      74             :     int err;
      75             : 
      76       32570 :     switch (op) {
      77           0 :     case AV_LOCK_CREATE:
      78           0 :         return 0;
      79       16285 :     case AV_LOCK_OBTAIN:
      80       16285 :         if (!*mutex) {
      81        5450 :             pthread_mutex_t *tmp = av_malloc(sizeof(pthread_mutex_t));
      82        5450 :             if (!tmp)
      83           0 :                 return AVERROR(ENOMEM);
      84        5450 :             if ((err = pthread_mutex_init(tmp, NULL))) {
      85           0 :                 av_free(tmp);
      86           0 :                 return AVERROR(err);
      87             :             }
      88        5450 :             if (avpriv_atomic_ptr_cas(mutex, NULL, tmp)) {
      89           0 :                 pthread_mutex_destroy(tmp);
      90           0 :                 av_free(tmp);
      91             :             }
      92             :         }
      93             : 
      94       16285 :         if ((err = pthread_mutex_lock(*mutex)))
      95           0 :             return AVERROR(err);
      96             : 
      97       16285 :         return 0;
      98       16285 :     case AV_LOCK_RELEASE:
      99       16285 :         if ((err = pthread_mutex_unlock(*mutex)))
     100           0 :             return AVERROR(err);
     101             : 
     102       16285 :         return 0;
     103           0 :     case AV_LOCK_DESTROY:
     104           0 :         if (*mutex)
     105           0 :             pthread_mutex_destroy(*mutex);
     106           0 :         av_free(*mutex);
     107           0 :         avpriv_atomic_ptr_cas(mutex, *mutex, NULL);
     108           0 :         return 0;
     109             :     }
     110           0 :     return 1;
     111             : }
     112             : static int (*lockmgr_cb)(void **mutex, enum AVLockOp op) = default_lockmgr_cb;
     113             : #else
     114             : static int (*lockmgr_cb)(void **mutex, enum AVLockOp op) = NULL;
     115             : #endif
     116             : 
     117             : 
     118             : volatile int ff_avcodec_locked;
     119             : static atomic_int entangled_thread_counter = ATOMIC_VAR_INIT(0);
     120             : static void *codec_mutex;
     121             : static void *avformat_mutex;
     122             : 
     123      198985 : void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
     124             : {
     125      198985 :     uint8_t **p = ptr;
     126      198985 :     if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
     127           0 :         av_freep(p);
     128           0 :         *size = 0;
     129           0 :         return;
     130             :     }
     131      198985 :     if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
     132      141545 :         memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
     133             : }
     134             : 
     135         485 : void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
     136             : {
     137         485 :     uint8_t **p = ptr;
     138         485 :     if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
     139           0 :         av_freep(p);
     140           0 :         *size = 0;
     141           0 :         return;
     142             :     }
     143         485 :     if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
     144         374 :         memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
     145             : }
     146             : 
     147             : /* encoder management */
     148             : static AVCodec *first_avcodec = NULL;
     149             : static AVCodec **last_avcodec = &first_avcodec;
     150             : 
     151  1947429281 : AVCodec *av_codec_next(const AVCodec *c)
     152             : {
     153  1947429281 :     if (c)
     154  1941068709 :         return c->next;
     155             :     else
     156     6360572 :         return first_avcodec;
     157             : }
     158             : 
     159     3340816 : static av_cold void avcodec_init(void)
     160             : {
     161             :     static int initialized = 0;
     162             : 
     163     3340816 :     if (initialized != 0)
     164     3335219 :         return;
     165        5597 :     initialized = 1;
     166             : 
     167             :     if (CONFIG_ME_CMP)
     168        5597 :         ff_me_cmp_init_static();
     169             : }
     170             : 
     171     6055485 : int av_codec_is_encoder(const AVCodec *codec)
     172             : {
     173     6055485 :     return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
     174             : }
     175             : 
     176     7034700 : int av_codec_is_decoder(const AVCodec *codec)
     177             : {
     178     7034700 :     return codec && (codec->decode || codec->receive_frame);
     179             : }
     180             : 
     181     3340816 : av_cold void avcodec_register(AVCodec *codec)
     182             : {
     183             :     AVCodec **p;
     184     3340816 :     avcodec_init();
     185     3340816 :     p = last_avcodec;
     186     3340816 :     codec->next = NULL;
     187             : 
     188     6681632 :     while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, codec))
     189           0 :         p = &(*p)->next;
     190     3340816 :     last_avcodec = &codec->next;
     191             : 
     192     3340816 :     if (codec->init_static_data)
     193       16788 :         codec->init_static_data(codec);
     194     3340816 : }
     195             : 
     196       31551 : int ff_set_dimensions(AVCodecContext *s, int width, int height)
     197             : {
     198       31551 :     int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
     199             : 
     200       31551 :     if (ret < 0)
     201           0 :         width = height = 0;
     202             : 
     203       31551 :     s->coded_width  = width;
     204       31551 :     s->coded_height = height;
     205       31551 :     s->width        = AV_CEIL_RSHIFT(width,  s->lowres);
     206       31551 :     s->height       = AV_CEIL_RSHIFT(height, s->lowres);
     207             : 
     208       31551 :     return ret;
     209             : }
     210             : 
     211        1979 : int ff_set_sar(AVCodecContext *avctx, AVRational sar)
     212             : {
     213        1979 :     int ret = av_image_check_sar(avctx->width, avctx->height, sar);
     214             : 
     215        1979 :     if (ret < 0) {
     216          14 :         av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
     217             :                sar.num, sar.den);
     218          14 :         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
     219          14 :         return ret;
     220             :     } else {
     221        1965 :         avctx->sample_aspect_ratio = sar;
     222             :     }
     223        1965 :     return 0;
     224             : }
     225             : 
     226       20369 : int ff_side_data_update_matrix_encoding(AVFrame *frame,
     227             :                                         enum AVMatrixEncoding matrix_encoding)
     228             : {
     229             :     AVFrameSideData *side_data;
     230             :     enum AVMatrixEncoding *data;
     231             : 
     232       20369 :     side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
     233       20369 :     if (!side_data)
     234       20369 :         side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
     235             :                                            sizeof(enum AVMatrixEncoding));
     236             : 
     237       20369 :     if (!side_data)
     238           0 :         return AVERROR(ENOMEM);
     239             : 
     240       20369 :     data  = (enum AVMatrixEncoding*)side_data->data;
     241       20369 :     *data = matrix_encoding;
     242             : 
     243       20369 :     return 0;
     244             : }
     245             : 
     246        7642 : void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
     247             :                                int linesize_align[AV_NUM_DATA_POINTERS])
     248             : {
     249             :     int i;
     250        7642 :     int w_align = 1;
     251        7642 :     int h_align = 1;
     252        7642 :     AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
     253             : 
     254        7642 :     if (desc) {
     255        7642 :         w_align = 1 << desc->log2_chroma_w;
     256        7642 :         h_align = 1 << desc->log2_chroma_h;
     257             :     }
     258             : 
     259        7642 :     switch (s->pix_fmt) {
     260        6739 :     case AV_PIX_FMT_YUV420P:
     261             :     case AV_PIX_FMT_YUYV422:
     262             :     case AV_PIX_FMT_YVYU422:
     263             :     case AV_PIX_FMT_UYVY422:
     264             :     case AV_PIX_FMT_YUV422P:
     265             :     case AV_PIX_FMT_YUV440P:
     266             :     case AV_PIX_FMT_YUV444P:
     267             :     case AV_PIX_FMT_GBRP:
     268             :     case AV_PIX_FMT_GBRAP:
     269             :     case AV_PIX_FMT_GRAY8:
     270             :     case AV_PIX_FMT_GRAY16BE:
     271             :     case AV_PIX_FMT_GRAY16LE:
     272             :     case AV_PIX_FMT_YUVJ420P:
     273             :     case AV_PIX_FMT_YUVJ422P:
     274             :     case AV_PIX_FMT_YUVJ440P:
     275             :     case AV_PIX_FMT_YUVJ444P:
     276             :     case AV_PIX_FMT_YUVA420P:
     277             :     case AV_PIX_FMT_YUVA422P:
     278             :     case AV_PIX_FMT_YUVA444P:
     279             :     case AV_PIX_FMT_YUV420P9LE:
     280             :     case AV_PIX_FMT_YUV420P9BE:
     281             :     case AV_PIX_FMT_YUV420P10LE:
     282             :     case AV_PIX_FMT_YUV420P10BE:
     283             :     case AV_PIX_FMT_YUV420P12LE:
     284             :     case AV_PIX_FMT_YUV420P12BE:
     285             :     case AV_PIX_FMT_YUV420P14LE:
     286             :     case AV_PIX_FMT_YUV420P14BE:
     287             :     case AV_PIX_FMT_YUV420P16LE:
     288             :     case AV_PIX_FMT_YUV420P16BE:
     289             :     case AV_PIX_FMT_YUVA420P9LE:
     290             :     case AV_PIX_FMT_YUVA420P9BE:
     291             :     case AV_PIX_FMT_YUVA420P10LE:
     292             :     case AV_PIX_FMT_YUVA420P10BE:
     293             :     case AV_PIX_FMT_YUVA420P16LE:
     294             :     case AV_PIX_FMT_YUVA420P16BE:
     295             :     case AV_PIX_FMT_YUV422P9LE:
     296             :     case AV_PIX_FMT_YUV422P9BE:
     297             :     case AV_PIX_FMT_YUV422P10LE:
     298             :     case AV_PIX_FMT_YUV422P10BE:
     299             :     case AV_PIX_FMT_YUV422P12LE:
     300             :     case AV_PIX_FMT_YUV422P12BE:
     301             :     case AV_PIX_FMT_YUV422P14LE:
     302             :     case AV_PIX_FMT_YUV422P14BE:
     303             :     case AV_PIX_FMT_YUV422P16LE:
     304             :     case AV_PIX_FMT_YUV422P16BE:
     305             :     case AV_PIX_FMT_YUVA422P9LE:
     306             :     case AV_PIX_FMT_YUVA422P9BE:
     307             :     case AV_PIX_FMT_YUVA422P10LE:
     308             :     case AV_PIX_FMT_YUVA422P10BE:
     309             :     case AV_PIX_FMT_YUVA422P16LE:
     310             :     case AV_PIX_FMT_YUVA422P16BE:
     311             :     case AV_PIX_FMT_YUV440P10LE:
     312             :     case AV_PIX_FMT_YUV440P10BE:
     313             :     case AV_PIX_FMT_YUV440P12LE:
     314             :     case AV_PIX_FMT_YUV440P12BE:
     315             :     case AV_PIX_FMT_YUV444P9LE:
     316             :     case AV_PIX_FMT_YUV444P9BE:
     317             :     case AV_PIX_FMT_YUV444P10LE:
     318             :     case AV_PIX_FMT_YUV444P10BE:
     319             :     case AV_PIX_FMT_YUV444P12LE:
     320             :     case AV_PIX_FMT_YUV444P12BE:
     321             :     case AV_PIX_FMT_YUV444P14LE:
     322             :     case AV_PIX_FMT_YUV444P14BE:
     323             :     case AV_PIX_FMT_YUV444P16LE:
     324             :     case AV_PIX_FMT_YUV444P16BE:
     325             :     case AV_PIX_FMT_YUVA444P9LE:
     326             :     case AV_PIX_FMT_YUVA444P9BE:
     327             :     case AV_PIX_FMT_YUVA444P10LE:
     328             :     case AV_PIX_FMT_YUVA444P10BE:
     329             :     case AV_PIX_FMT_YUVA444P16LE:
     330             :     case AV_PIX_FMT_YUVA444P16BE:
     331             :     case AV_PIX_FMT_GBRP9LE:
     332             :     case AV_PIX_FMT_GBRP9BE:
     333             :     case AV_PIX_FMT_GBRP10LE:
     334             :     case AV_PIX_FMT_GBRP10BE:
     335             :     case AV_PIX_FMT_GBRP12LE:
     336             :     case AV_PIX_FMT_GBRP12BE:
     337             :     case AV_PIX_FMT_GBRP14LE:
     338             :     case AV_PIX_FMT_GBRP14BE:
     339             :     case AV_PIX_FMT_GBRP16LE:
     340             :     case AV_PIX_FMT_GBRP16BE:
     341             :     case AV_PIX_FMT_GBRAP12LE:
     342             :     case AV_PIX_FMT_GBRAP12BE:
     343             :     case AV_PIX_FMT_GBRAP16LE:
     344             :     case AV_PIX_FMT_GBRAP16BE:
     345        6739 :         w_align = 16; //FIXME assume 16 pixel per macroblock
     346        6739 :         h_align = 16 * 2; // interlaced needs 2 macroblocks height
     347        6739 :         break;
     348          26 :     case AV_PIX_FMT_YUV411P:
     349             :     case AV_PIX_FMT_YUVJ411P:
     350             :     case AV_PIX_FMT_UYYVYY411:
     351          26 :         w_align = 32;
     352          26 :         h_align = 16 * 2;
     353          26 :         break;
     354          21 :     case AV_PIX_FMT_YUV410P:
     355          21 :         if (s->codec_id == AV_CODEC_ID_SVQ1) {
     356          10 :             w_align = 64;
     357          10 :             h_align = 64;
     358             :         }
     359          21 :         break;
     360          35 :     case AV_PIX_FMT_RGB555:
     361          35 :         if (s->codec_id == AV_CODEC_ID_RPZA) {
     362           1 :             w_align = 4;
     363           1 :             h_align = 4;
     364             :         }
     365          35 :         if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
     366           2 :             w_align = 8;
     367           2 :             h_align = 8;
     368             :         }
     369          35 :         break;
     370         123 :     case AV_PIX_FMT_PAL8:
     371             :     case AV_PIX_FMT_BGR8:
     372             :     case AV_PIX_FMT_RGB8:
     373         245 :         if (s->codec_id == AV_CODEC_ID_SMC ||
     374         122 :             s->codec_id == AV_CODEC_ID_CINEPAK) {
     375           2 :             w_align = 4;
     376           2 :             h_align = 4;
     377             :         }
     378         245 :         if (s->codec_id == AV_CODEC_ID_JV ||
     379         122 :             s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
     380           4 :             w_align = 8;
     381           4 :             h_align = 8;
     382             :         }
     383         123 :         break;
     384          73 :     case AV_PIX_FMT_BGR24:
     385         145 :         if ((s->codec_id == AV_CODEC_ID_MSZH) ||
     386          72 :             (s->codec_id == AV_CODEC_ID_ZLIB)) {
     387           6 :             w_align = 4;
     388           6 :             h_align = 4;
     389             :         }
     390          73 :         break;
     391         207 :     case AV_PIX_FMT_RGB24:
     392         207 :         if (s->codec_id == AV_CODEC_ID_CINEPAK) {
     393           6 :             w_align = 4;
     394           6 :             h_align = 4;
     395             :         }
     396         207 :         break;
     397         418 :     default:
     398         418 :         break;
     399             :     }
     400             : 
     401        7642 :     if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
     402           2 :         w_align = FFMAX(w_align, 8);
     403             :     }
     404             : 
     405        7642 :     *width  = FFALIGN(*width, w_align);
     406        7642 :     *height = FFALIGN(*height, h_align);
     407        7642 :     if (s->codec_id == AV_CODEC_ID_H264 || s->lowres) {
     408             :         // some of the optimized chroma MC reads one line too much
     409             :         // which is also done in mpeg decoders with lowres > 0
     410         503 :         *height += 2;
     411             : 
     412             :         // H.264 uses edge emulation for out of frame motion vectors, for this
     413             :         // it requires a temporary area large enough to hold a 21x21 block,
     414             :         // increasing witdth ensure that the temporary area is large enough,
     415             :         // the next rounded up width is 32
     416         503 :         *width = FFMAX(*width, 32);
     417             :     }
     418             : 
     419       38210 :     for (i = 0; i < 4; i++)
     420       30568 :         linesize_align[i] = STRIDE_ALIGN;
     421        7642 : }
     422             : 
     423           0 : void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
     424             : {
     425           0 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
     426           0 :     int chroma_shift = desc->log2_chroma_w;
     427             :     int linesize_align[AV_NUM_DATA_POINTERS];
     428             :     int align;
     429             : 
     430           0 :     avcodec_align_dimensions2(s, width, height, linesize_align);
     431           0 :     align               = FFMAX(linesize_align[0], linesize_align[3]);
     432           0 :     linesize_align[1] <<= chroma_shift;
     433           0 :     linesize_align[2] <<= chroma_shift;
     434           0 :     align               = FFMAX3(align, linesize_align[1], linesize_align[2]);
     435           0 :     *width              = FFALIGN(*width, align);
     436           0 : }
     437             : 
     438           1 : int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
     439             : {
     440           1 :     if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
     441           0 :         return AVERROR(EINVAL);
     442           1 :     pos--;
     443             : 
     444           1 :     *xpos = (pos&1) * 128;
     445           1 :     *ypos = ((pos>>1)^(pos<4)) * 128;
     446             : 
     447           1 :     return 0;
     448             : }
     449             : 
     450           1 : enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
     451             : {
     452             :     int pos, xout, yout;
     453             : 
     454           1 :     for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
     455           1 :         if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
     456           1 :             return pos;
     457             :     }
     458           0 :     return AVCHROMA_LOC_UNSPECIFIED;
     459             : }
     460             : 
     461           0 : int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
     462             :                              enum AVSampleFormat sample_fmt, const uint8_t *buf,
     463             :                              int buf_size, int align)
     464             : {
     465           0 :     int ch, planar, needed_size, ret = 0;
     466             : 
     467           0 :     needed_size = av_samples_get_buffer_size(NULL, nb_channels,
     468             :                                              frame->nb_samples, sample_fmt,
     469             :                                              align);
     470           0 :     if (buf_size < needed_size)
     471           0 :         return AVERROR(EINVAL);
     472             : 
     473           0 :     planar = av_sample_fmt_is_planar(sample_fmt);
     474           0 :     if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
     475           0 :         if (!(frame->extended_data = av_mallocz_array(nb_channels,
     476             :                                                 sizeof(*frame->extended_data))))
     477           0 :             return AVERROR(ENOMEM);
     478             :     } else {
     479           0 :         frame->extended_data = frame->data;
     480             :     }
     481             : 
     482           0 :     if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
     483             :                                       (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
     484             :                                       sample_fmt, align)) < 0) {
     485           0 :         if (frame->extended_data != frame->data)
     486           0 :             av_freep(&frame->extended_data);
     487           0 :         return ret;
     488             :     }
     489           0 :     if (frame->extended_data != frame->data) {
     490           0 :         for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
     491           0 :             frame->data[ch] = frame->extended_data[ch];
     492             :     }
     493             : 
     494           0 :     return ret;
     495             : }
     496             : 
     497         605 : void ff_color_frame(AVFrame *frame, const int c[4])
     498             : {
     499         605 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
     500             :     int p, y, x;
     501             : 
     502         605 :     av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
     503             : 
     504        2420 :     for (p = 0; p<desc->nb_components; p++) {
     505        1815 :         uint8_t *dst = frame->data[p];
     506        1815 :         int is_chroma = p == 1 || p == 2;
     507        1815 :         int bytes  = is_chroma ? AV_CEIL_RSHIFT(frame->width,  desc->log2_chroma_w) : frame->width;
     508        1815 :         int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
     509      505303 :         for (y = 0; y < height; y++) {
     510      503488 :             if (desc->comp[0].depth >= 9) {
     511    94089472 :                 for (x = 0; x<bytes; x++)
     512    94006656 :                     ((uint16_t*)dst)[x] = c[p];
     513             :             }else
     514      420672 :                 memset(dst, c[p], bytes);
     515      503488 :             dst += frame->linesize[p];
     516             :         }
     517             :     }
     518         605 : }
     519             : 
     520       46044 : int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
     521             : {
     522             :     int i;
     523             : 
     524      658208 :     for (i = 0; i < count; i++) {
     525      612164 :         int r = func(c, (char *)arg + i * size);
     526      612164 :         if (ret)
     527       27420 :             ret[i] = r;
     528             :     }
     529       46044 :     emms_c();
     530       46044 :     return 0;
     531             : }
     532             : 
     533        5359 : int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
     534             : {
     535             :     int i;
     536             : 
     537      169251 :     for (i = 0; i < count; i++) {
     538      163892 :         int r = func(c, arg, i, 0);
     539      163892 :         if (ret)
     540          50 :             ret[i] = r;
     541             :     }
     542        5359 :     emms_c();
     543        5359 :     return 0;
     544             : }
     545             : 
     546        1302 : enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
     547             :                                        unsigned int fourcc)
     548             : {
     549       13612 :     while (tags->pix_fmt >= 0) {
     550       12112 :         if (tags->fourcc == fourcc)
     551        1104 :             return tags->pix_fmt;
     552       11008 :         tags++;
     553             :     }
     554         198 :     return AV_PIX_FMT_NONE;
     555             : }
     556             : 
     557             : #if FF_API_CODEC_GET_SET
     558           0 : MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
     559           0 : MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
     560           0 : MAKE_ACCESSORS(AVCodecContext, codec, int, lowres)
     561           0 : MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
     562           0 : MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
     563             : 
     564           0 : unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
     565             : {
     566           0 :     return codec->properties;
     567             : }
     568             : 
     569           0 : int av_codec_get_max_lowres(const AVCodec *codec)
     570             : {
     571           0 :     return codec->max_lowres;
     572             : }
     573             : #endif
     574             : 
     575      149012 : int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec){
     576      149012 :     return !!(codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM);
     577             : }
     578             : 
     579       19068 : static int64_t get_bit_rate(AVCodecContext *ctx)
     580             : {
     581             :     int64_t bit_rate;
     582             :     int bits_per_sample;
     583             : 
     584       19068 :     switch (ctx->codec_type) {
     585       15823 :     case AVMEDIA_TYPE_VIDEO:
     586             :     case AVMEDIA_TYPE_DATA:
     587             :     case AVMEDIA_TYPE_SUBTITLE:
     588             :     case AVMEDIA_TYPE_ATTACHMENT:
     589       15823 :         bit_rate = ctx->bit_rate;
     590       15823 :         break;
     591        3245 :     case AVMEDIA_TYPE_AUDIO:
     592        3245 :         bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
     593        3245 :         bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
     594        3245 :         break;
     595           0 :     default:
     596           0 :         bit_rate = 0;
     597           0 :         break;
     598             :     }
     599       19068 :     return bit_rate;
     600             : }
     601             : 
     602           4 : int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
     603             : {
     604           4 :     int ret = 0;
     605             : 
     606           4 :     ff_unlock_avcodec(codec);
     607             : 
     608           4 :     ret = avcodec_open2(avctx, codec, options);
     609             : 
     610           4 :     ff_lock_avcodec(avctx, codec);
     611           4 :     return ret;
     612             : }
     613             : 
     614       17045 : int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
     615             : {
     616       17045 :     int ret = 0;
     617       17045 :     AVDictionary *tmp = NULL;
     618             :     const AVPixFmtDescriptor *pixdesc;
     619             : 
     620       17045 :     if (avcodec_is_open(avctx))
     621           0 :         return 0;
     622             : 
     623       17045 :     if ((!codec && !avctx->codec)) {
     624           0 :         av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
     625           0 :         return AVERROR(EINVAL);
     626             :     }
     627       17045 :     if ((codec && avctx->codec && codec != avctx->codec)) {
     628           0 :         av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
     629           0 :                                     "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
     630           0 :         return AVERROR(EINVAL);
     631             :     }
     632       17045 :     if (!codec)
     633           0 :         codec = avctx->codec;
     634             : 
     635       17045 :     if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
     636           0 :         return AVERROR(EINVAL);
     637             : 
     638       17045 :     if (options)
     639       16974 :         av_dict_copy(&tmp, *options, 0);
     640             : 
     641       17045 :     ret = ff_lock_avcodec(avctx, codec);
     642       17045 :     if (ret < 0)
     643           0 :         return ret;
     644             : 
     645       17045 :     avctx->internal = av_mallocz(sizeof(AVCodecInternal));
     646       17045 :     if (!avctx->internal) {
     647           0 :         ret = AVERROR(ENOMEM);
     648           0 :         goto end;
     649             :     }
     650             : 
     651       17045 :     avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
     652       17045 :     if (!avctx->internal->pool) {
     653           0 :         ret = AVERROR(ENOMEM);
     654           0 :         goto free_and_end;
     655             :     }
     656             : 
     657       17045 :     avctx->internal->to_free = av_frame_alloc();
     658       17045 :     if (!avctx->internal->to_free) {
     659           0 :         ret = AVERROR(ENOMEM);
     660           0 :         goto free_and_end;
     661             :     }
     662             : 
     663       17045 :     avctx->internal->compat_decode_frame = av_frame_alloc();
     664       17045 :     if (!avctx->internal->compat_decode_frame) {
     665           0 :         ret = AVERROR(ENOMEM);
     666           0 :         goto free_and_end;
     667             :     }
     668             : 
     669       17045 :     avctx->internal->buffer_frame = av_frame_alloc();
     670       17045 :     if (!avctx->internal->buffer_frame) {
     671           0 :         ret = AVERROR(ENOMEM);
     672           0 :         goto free_and_end;
     673             :     }
     674             : 
     675       17045 :     avctx->internal->buffer_pkt = av_packet_alloc();
     676       17045 :     if (!avctx->internal->buffer_pkt) {
     677           0 :         ret = AVERROR(ENOMEM);
     678           0 :         goto free_and_end;
     679             :     }
     680             : 
     681       17045 :     avctx->internal->ds.in_pkt = av_packet_alloc();
     682       17045 :     if (!avctx->internal->ds.in_pkt) {
     683           0 :         ret = AVERROR(ENOMEM);
     684           0 :         goto free_and_end;
     685             :     }
     686             : 
     687       17045 :     avctx->internal->last_pkt_props = av_packet_alloc();
     688       17045 :     if (!avctx->internal->last_pkt_props) {
     689           0 :         ret = AVERROR(ENOMEM);
     690           0 :         goto free_and_end;
     691             :     }
     692             : 
     693       17045 :     avctx->internal->skip_samples_multiplier = 1;
     694             : 
     695       17045 :     if (codec->priv_data_size > 0) {
     696       12102 :         if (!avctx->priv_data) {
     697        5999 :             avctx->priv_data = av_mallocz(codec->priv_data_size);
     698        5999 :             if (!avctx->priv_data) {
     699           0 :                 ret = AVERROR(ENOMEM);
     700           0 :                 goto end;
     701             :             }
     702        5999 :             if (codec->priv_class) {
     703        1572 :                 *(const AVClass **)avctx->priv_data = codec->priv_class;
     704        1572 :                 av_opt_set_defaults(avctx->priv_data);
     705             :             }
     706             :         }
     707       12102 :         if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
     708           0 :             goto free_and_end;
     709             :     } else {
     710        4943 :         avctx->priv_data = NULL;
     711             :     }
     712       17045 :     if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
     713           0 :         goto free_and_end;
     714             : 
     715       17045 :     if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
     716           0 :         av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
     717           0 :         ret = AVERROR(EINVAL);
     718           0 :         goto free_and_end;
     719             :     }
     720             : 
     721             :     // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
     722       17184 :     if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
     723         278 :           (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
     724       17045 :     if (avctx->coded_width && avctx->coded_height)
     725         149 :         ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
     726       16896 :     else if (avctx->width && avctx->height)
     727       10193 :         ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
     728       17045 :     if (ret < 0)
     729           0 :         goto free_and_end;
     730             :     }
     731             : 
     732       17045 :     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
     733       10342 :         && (  av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
     734       10342 :            || av_image_check_size2(avctx->width,       avctx->height,       avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
     735           0 :         av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
     736           0 :         ff_set_dimensions(avctx, 0, 0);
     737             :     }
     738             : 
     739       17045 :     if (avctx->width > 0 && avctx->height > 0) {
     740       10342 :         if (av_image_check_sar(avctx->width, avctx->height,
     741             :                                avctx->sample_aspect_ratio) < 0) {
     742           0 :             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
     743             :                    avctx->sample_aspect_ratio.num,
     744             :                    avctx->sample_aspect_ratio.den);
     745           0 :             avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
     746             :         }
     747             :     }
     748             : 
     749             :     /* if the decoder init function was already called previously,
     750             :      * free the already allocated subtitle_header before overwriting it */
     751       17045 :     if (av_codec_is_decoder(codec))
     752       11546 :         av_freep(&avctx->subtitle_header);
     753             : 
     754       17045 :     if (avctx->channels > FF_SANE_NB_CHANNELS) {
     755           0 :         ret = AVERROR(EINVAL);
     756           0 :         goto free_and_end;
     757             :     }
     758             : 
     759       17045 :     avctx->codec = codec;
     760       34090 :     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
     761       17045 :         avctx->codec_id == AV_CODEC_ID_NONE) {
     762           0 :         avctx->codec_type = codec->type;
     763           0 :         avctx->codec_id   = codec->id;
     764             :     }
     765       17045 :     if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
     766           0 :                                          && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
     767           0 :         av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
     768           0 :         ret = AVERROR(EINVAL);
     769           0 :         goto free_and_end;
     770             :     }
     771       17045 :     avctx->frame_number = 0;
     772       17045 :     avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
     773             : 
     774       17052 :     if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
     775           7 :         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
     776           0 :         const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
     777             :         AVCodec *codec2;
     778           0 :         av_log(avctx, AV_LOG_ERROR,
     779             :                "The %s '%s' is experimental but experimental codecs are not enabled, "
     780             :                "add '-strict %d' if you want to use it.\n",
     781             :                codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
     782           0 :         codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
     783           0 :         if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
     784           0 :             av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
     785             :                 codec_string, codec2->name);
     786           0 :         ret = AVERROR_EXPERIMENTAL;
     787           0 :         goto free_and_end;
     788             :     }
     789             : 
     790       20716 :     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
     791        4739 :         (!avctx->time_base.num || !avctx->time_base.den)) {
     792        2606 :         avctx->time_base.num = 1;
     793        2606 :         avctx->time_base.den = avctx->sample_rate;
     794             :     }
     795             : 
     796             :     if (!HAVE_THREADS)
     797             :         av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
     798             : 
     799       17045 :     if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
     800        5499 :         ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
     801        5499 :         ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
     802        5499 :         ff_lock_avcodec(avctx, codec);
     803        5499 :         if (ret < 0)
     804           0 :             goto free_and_end;
     805             :     }
     806             : 
     807       17045 :     if (HAVE_THREADS
     808       17063 :         && !(avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
     809       17027 :         ret = ff_thread_init(avctx);
     810       17027 :         if (ret < 0) {
     811           0 :             goto free_and_end;
     812             :         }
     813             :     }
     814             :     if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
     815             :         avctx->thread_count = 1;
     816             : 
     817       17045 :     if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
     818           0 :         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
     819           0 :                avctx->codec->max_lowres);
     820           0 :         avctx->lowres = avctx->codec->max_lowres;
     821             :     }
     822             : 
     823       17045 :     if (av_codec_is_encoder(avctx->codec)) {
     824             :         int i;
     825             : #if FF_API_CODED_FRAME
     826             : FF_DISABLE_DEPRECATION_WARNINGS
     827        5499 :         avctx->coded_frame = av_frame_alloc();
     828        5499 :         if (!avctx->coded_frame) {
     829           0 :             ret = AVERROR(ENOMEM);
     830           0 :             goto free_and_end;
     831             :         }
     832             : FF_ENABLE_DEPRECATION_WARNINGS
     833             : #endif
     834             : 
     835        5499 :         if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
     836           0 :             av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
     837           0 :             ret = AVERROR(EINVAL);
     838           0 :             goto free_and_end;
     839             :         }
     840             : 
     841        5499 :         if (avctx->codec->sample_fmts) {
     842        1093 :             for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
     843        1093 :                 if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
     844        1081 :                     break;
     845          15 :                 if (avctx->channels == 1 &&
     846           3 :                     av_get_planar_sample_fmt(avctx->sample_fmt) ==
     847           3 :                     av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
     848           0 :                     avctx->sample_fmt = avctx->codec->sample_fmts[i];
     849           0 :                     break;
     850             :                 }
     851             :             }
     852        1081 :             if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
     853             :                 char buf[128];
     854           0 :                 snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
     855           0 :                 av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
     856           0 :                        (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
     857           0 :                 ret = AVERROR(EINVAL);
     858           0 :                 goto free_and_end;
     859             :             }
     860             :         }
     861        5499 :         if (avctx->codec->pix_fmts) {
     862        2003 :             for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
     863        2003 :                 if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
     864         672 :                     break;
     865         672 :             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
     866           0 :                 && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
     867           0 :                      && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
     868             :                 char buf[128];
     869           0 :                 snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
     870           0 :                 av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
     871           0 :                        (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
     872           0 :                 ret = AVERROR(EINVAL);
     873           0 :                 goto free_and_end;
     874             :             }
     875        1322 :             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
     876        1300 :                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
     877        1296 :                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
     878        1292 :                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
     879         646 :                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
     880          34 :                 avctx->color_range = AVCOL_RANGE_JPEG;
     881             :         }
     882        5499 :         if (avctx->codec->supported_samplerates) {
     883          89 :             for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
     884          89 :                 if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
     885          32 :                     break;
     886          32 :             if (avctx->codec->supported_samplerates[i] == 0) {
     887           0 :                 av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
     888             :                        avctx->sample_rate);
     889           0 :                 ret = AVERROR(EINVAL);
     890           0 :                 goto free_and_end;
     891             :             }
     892             :         }
     893        5499 :         if (avctx->sample_rate < 0) {
     894           0 :             av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
     895             :                     avctx->sample_rate);
     896           0 :             ret = AVERROR(EINVAL);
     897           0 :             goto free_and_end;
     898             :         }
     899        5499 :         if (avctx->codec->channel_layouts) {
     900          35 :             if (!avctx->channel_layout) {
     901           0 :                 av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
     902             :             } else {
     903          51 :                 for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
     904          51 :                     if (avctx->channel_layout == avctx->codec->channel_layouts[i])
     905          35 :                         break;
     906          35 :                 if (avctx->codec->channel_layouts[i] == 0) {
     907             :                     char buf[512];
     908           0 :                     av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
     909           0 :                     av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
     910           0 :                     ret = AVERROR(EINVAL);
     911           0 :                     goto free_and_end;
     912             :                 }
     913             :             }
     914             :         }
     915        6562 :         if (avctx->channel_layout && avctx->channels) {
     916        1063 :             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
     917        1063 :             if (channels != avctx->channels) {
     918             :                 char buf[512];
     919           0 :                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
     920           0 :                 av_log(avctx, AV_LOG_ERROR,
     921             :                        "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
     922             :                        buf, channels, avctx->channels);
     923           0 :                 ret = AVERROR(EINVAL);
     924           0 :                 goto free_and_end;
     925             :             }
     926        4436 :         } else if (avctx->channel_layout) {
     927          16 :             avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
     928             :         }
     929        5499 :         if (avctx->channels < 0) {
     930           0 :             av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
     931             :                     avctx->channels);
     932           0 :             ret = AVERROR(EINVAL);
     933           0 :             goto free_and_end;
     934             :         }
     935        5499 :         if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
     936        4388 :             pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
     937        4388 :             if (    avctx->bits_per_raw_sample < 0
     938        4388 :                 || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
     939           0 :                 av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
     940             :                     avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
     941           0 :                 avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
     942             :             }
     943        4388 :             if (avctx->width <= 0 || avctx->height <= 0) {
     944           0 :                 av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
     945           0 :                 ret = AVERROR(EINVAL);
     946           0 :                 goto free_and_end;
     947             :             }
     948             :         }
     949        5499 :         if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
     950        5469 :             && avctx->bit_rate>0 && avctx->bit_rate<1000) {
     951           0 :             av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
     952             :         }
     953             : 
     954        5499 :         if (!avctx->rc_initial_buffer_occupancy)
     955        5498 :             avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
     956             : 
     957       10968 :         if (avctx->ticks_per_frame && avctx->time_base.num &&
     958        5469 :             avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
     959           0 :             av_log(avctx, AV_LOG_ERROR,
     960             :                    "ticks_per_frame %d too large for the timebase %d/%d.",
     961             :                    avctx->ticks_per_frame,
     962             :                    avctx->time_base.num,
     963             :                    avctx->time_base.den);
     964           0 :             goto free_and_end;
     965             :         }
     966             : 
     967        5499 :         if (avctx->hw_frames_ctx) {
     968           0 :             AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
     969           0 :             if (frames_ctx->format != avctx->pix_fmt) {
     970           0 :                 av_log(avctx, AV_LOG_ERROR,
     971             :                        "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
     972           0 :                 ret = AVERROR(EINVAL);
     973           0 :                 goto free_and_end;
     974             :             }
     975           0 :             if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
     976           0 :                 avctx->sw_pix_fmt != frames_ctx->sw_format) {
     977           0 :                 av_log(avctx, AV_LOG_ERROR,
     978             :                        "Mismatching AVCodecContext.sw_pix_fmt (%s) "
     979             :                        "and AVHWFramesContext.sw_format (%s)\n",
     980             :                        av_get_pix_fmt_name(avctx->sw_pix_fmt),
     981             :                        av_get_pix_fmt_name(frames_ctx->sw_format));
     982           0 :                 ret = AVERROR(EINVAL);
     983           0 :                 goto free_and_end;
     984             :             }
     985           0 :             avctx->sw_pix_fmt = frames_ctx->sw_format;
     986             :         }
     987             :     }
     988             : 
     989       17045 :     avctx->pts_correction_num_faulty_pts =
     990       17045 :     avctx->pts_correction_num_faulty_dts = 0;
     991       17045 :     avctx->pts_correction_last_pts =
     992       17045 :     avctx->pts_correction_last_dts = INT64_MIN;
     993             : 
     994       17045 :     if (   !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
     995           0 :         && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
     996           0 :         av_log(avctx, AV_LOG_WARNING,
     997             :                "gray decoding requested but not enabled at configuration time\n");
     998             : 
     999       17045 :     if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
    1000          23 :         || avctx->internal->frame_thread_encoder)) {
    1001       12670 :         ret = avctx->codec->init(avctx);
    1002       12670 :         if (ret < 0) {
    1003           8 :             goto free_and_end;
    1004             :         }
    1005             :     }
    1006             : 
    1007       17037 :     ret=0;
    1008             : 
    1009       17037 :     if (av_codec_is_decoder(avctx->codec)) {
    1010       11538 :         if (!avctx->bit_rate)
    1011        7659 :             avctx->bit_rate = get_bit_rate(avctx);
    1012             :         /* validate channel layout from the decoder */
    1013       11538 :         if (avctx->channel_layout) {
    1014        1567 :             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
    1015        1567 :             if (!avctx->channels)
    1016          16 :                 avctx->channels = channels;
    1017        1551 :             else if (channels != avctx->channels) {
    1018             :                 char buf[512];
    1019           0 :                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
    1020           0 :                 av_log(avctx, AV_LOG_WARNING,
    1021             :                        "Channel layout '%s' with %d channels does not match specified number of channels %d: "
    1022             :                        "ignoring specified channel layout\n",
    1023             :                        buf, channels, avctx->channels);
    1024           0 :                 avctx->channel_layout = 0;
    1025             :             }
    1026             :         }
    1027       23076 :         if (avctx->channels && avctx->channels < 0 ||
    1028       11538 :             avctx->channels > FF_SANE_NB_CHANNELS) {
    1029           0 :             ret = AVERROR(EINVAL);
    1030           0 :             goto free_and_end;
    1031             :         }
    1032       11538 :         if (avctx->sub_charenc) {
    1033           6 :             if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
    1034           0 :                 av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
    1035             :                        "supported with subtitles codecs\n");
    1036           0 :                 ret = AVERROR(EINVAL);
    1037           0 :                 goto free_and_end;
    1038           6 :             } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
    1039           0 :                 av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
    1040             :                        "subtitles character encoding will be ignored\n",
    1041           0 :                        avctx->codec_descriptor->name);
    1042           0 :                 avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
    1043             :             } else {
    1044             :                 /* input character encoding is set for a text based subtitle
    1045             :                  * codec at this point */
    1046           6 :                 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
    1047           6 :                     avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
    1048             : 
    1049           6 :                 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
    1050             : #if CONFIG_ICONV
    1051           6 :                     iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
    1052           6 :                     if (cd == (iconv_t)-1) {
    1053           0 :                         ret = AVERROR(errno);
    1054           0 :                         av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
    1055             :                                "with input character encoding \"%s\"\n", avctx->sub_charenc);
    1056           0 :                         goto free_and_end;
    1057             :                     }
    1058           6 :                     iconv_close(cd);
    1059             : #else
    1060             :                     av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
    1061             :                            "conversion needs a libavcodec built with iconv support "
    1062             :                            "for this codec\n");
    1063             :                     ret = AVERROR(ENOSYS);
    1064             :                     goto free_and_end;
    1065             : #endif
    1066             :                 }
    1067             :             }
    1068             :         }
    1069             : 
    1070             : #if FF_API_AVCTX_TIMEBASE
    1071       11538 :         if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
    1072        3990 :             avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
    1073             : #endif
    1074             :     }
    1075       29131 :     if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
    1076        3622 :         av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
    1077             :     }
    1078             : 
    1079       17037 : end:
    1080       17045 :     ff_unlock_avcodec(codec);
    1081       17045 :     if (options) {
    1082       16974 :         av_dict_free(options);
    1083       16974 :         *options = tmp;
    1084             :     }
    1085             : 
    1086       17045 :     return ret;
    1087           8 : free_and_end:
    1088          16 :     if (avctx->codec &&
    1089           8 :         (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))
    1090           0 :         avctx->codec->close(avctx);
    1091             : 
    1092           8 :     if (codec->priv_class && codec->priv_data_size)
    1093           0 :         av_opt_free(avctx->priv_data);
    1094           8 :     av_opt_free(avctx);
    1095             : 
    1096             : #if FF_API_CODED_FRAME
    1097             : FF_DISABLE_DEPRECATION_WARNINGS
    1098           8 :     av_frame_free(&avctx->coded_frame);
    1099             : FF_ENABLE_DEPRECATION_WARNINGS
    1100             : #endif
    1101             : 
    1102           8 :     av_dict_free(&tmp);
    1103           8 :     av_freep(&avctx->priv_data);
    1104           8 :     if (avctx->internal) {
    1105           8 :         av_frame_free(&avctx->internal->to_free);
    1106           8 :         av_frame_free(&avctx->internal->compat_decode_frame);
    1107           8 :         av_frame_free(&avctx->internal->buffer_frame);
    1108           8 :         av_packet_free(&avctx->internal->buffer_pkt);
    1109           8 :         av_packet_free(&avctx->internal->last_pkt_props);
    1110             : 
    1111           8 :         av_packet_free(&avctx->internal->ds.in_pkt);
    1112             : 
    1113           8 :         av_freep(&avctx->internal->pool);
    1114             :     }
    1115           8 :     av_freep(&avctx->internal);
    1116           8 :     avctx->codec = NULL;
    1117           8 :     goto end;
    1118             : }
    1119             : 
    1120        6363 : void avsubtitle_free(AVSubtitle *sub)
    1121             : {
    1122             :     int i;
    1123             : 
    1124        6959 :     for (i = 0; i < sub->num_rects; i++) {
    1125         596 :         av_freep(&sub->rects[i]->data[0]);
    1126         596 :         av_freep(&sub->rects[i]->data[1]);
    1127         596 :         av_freep(&sub->rects[i]->data[2]);
    1128         596 :         av_freep(&sub->rects[i]->data[3]);
    1129         596 :         av_freep(&sub->rects[i]->text);
    1130         596 :         av_freep(&sub->rects[i]->ass);
    1131         596 :         av_freep(&sub->rects[i]);
    1132             :     }
    1133             : 
    1134        6363 :     av_freep(&sub->rects);
    1135             : 
    1136        6363 :     memset(sub, 0, sizeof(AVSubtitle));
    1137        6363 : }
    1138             : 
    1139       58360 : av_cold int avcodec_close(AVCodecContext *avctx)
    1140             : {
    1141             :     int i;
    1142             : 
    1143       58360 :     if (!avctx)
    1144           0 :         return 0;
    1145             : 
    1146       58360 :     if (avcodec_is_open(avctx)) {
    1147       17037 :         FramePool *pool = avctx->internal->pool;
    1148       17037 :         if (CONFIG_FRAME_THREAD_ENCODER &&
    1149       17187 :             avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
    1150          18 :             ff_frame_thread_encoder_free(avctx);
    1151             :         }
    1152       17037 :         if (HAVE_THREADS && avctx->internal->thread_ctx)
    1153          17 :             ff_thread_free(avctx);
    1154       17037 :         if (avctx->codec && avctx->codec->close)
    1155        7248 :             avctx->codec->close(avctx);
    1156       17037 :         avctx->internal->byte_buffer_size = 0;
    1157       17037 :         av_freep(&avctx->internal->byte_buffer);
    1158       17037 :         av_frame_free(&avctx->internal->to_free);
    1159       17037 :         av_frame_free(&avctx->internal->compat_decode_frame);
    1160       17037 :         av_frame_free(&avctx->internal->buffer_frame);
    1161       17037 :         av_packet_free(&avctx->internal->buffer_pkt);
    1162       17037 :         av_packet_free(&avctx->internal->last_pkt_props);
    1163             : 
    1164       17037 :         av_packet_free(&avctx->internal->ds.in_pkt);
    1165             : 
    1166       85185 :         for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
    1167       68148 :             av_buffer_pool_uninit(&pool->pools[i]);
    1168       17037 :         av_freep(&avctx->internal->pool);
    1169             : 
    1170       17037 :         if (avctx->hwaccel && avctx->hwaccel->uninit)
    1171           0 :             avctx->hwaccel->uninit(avctx);
    1172       17037 :         av_freep(&avctx->internal->hwaccel_priv_data);
    1173             : 
    1174       17037 :         ff_decode_bsfs_uninit(avctx);
    1175             : 
    1176       17037 :         av_freep(&avctx->internal);
    1177             :     }
    1178             : 
    1179       58543 :     for (i = 0; i < avctx->nb_coded_side_data; i++)
    1180         183 :         av_freep(&avctx->coded_side_data[i].data);
    1181       58360 :     av_freep(&avctx->coded_side_data);
    1182       58360 :     avctx->nb_coded_side_data = 0;
    1183             : 
    1184       58360 :     av_buffer_unref(&avctx->hw_frames_ctx);
    1185       58360 :     av_buffer_unref(&avctx->hw_device_ctx);
    1186             : 
    1187       58360 :     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
    1188        3761 :         av_opt_free(avctx->priv_data);
    1189       58360 :     av_opt_free(avctx);
    1190       58360 :     av_freep(&avctx->priv_data);
    1191       58360 :     if (av_codec_is_encoder(avctx->codec)) {
    1192       16177 :         av_freep(&avctx->extradata);
    1193             : #if FF_API_CODED_FRAME
    1194             : FF_DISABLE_DEPRECATION_WARNINGS
    1195       16177 :         av_frame_free(&avctx->coded_frame);
    1196             : FF_ENABLE_DEPRECATION_WARNINGS
    1197             : #endif
    1198             :     }
    1199       58360 :     avctx->codec = NULL;
    1200       58360 :     avctx->active_thread_type = 0;
    1201             : 
    1202       58360 :     return 0;
    1203             : }
    1204             : 
    1205       26452 : static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
    1206             : {
    1207             :     switch(id){
    1208             :         //This is for future deprecatec codec ids, its empty since
    1209             :         //last major bump but will fill up again over time, please don't remove it
    1210       26452 :         default                                         : return id;
    1211             :     }
    1212             : }
    1213             : 
    1214       26452 : static AVCodec *find_encdec(enum AVCodecID id, int encoder)
    1215             : {
    1216       26452 :     AVCodec *p, *experimental = NULL;
    1217       26452 :     p = first_avcodec;
    1218       26452 :     id= remap_deprecated_codec_id(id);
    1219     8772335 :     while (p) {
    1220    13344043 :         if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
    1221     4604087 :             p->id == id) {
    1222       20525 :             if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
    1223           0 :                 experimental = p;
    1224             :             } else
    1225       20525 :                 return p;
    1226             :         }
    1227     8719431 :         p = p->next;
    1228             :     }
    1229        5927 :     return experimental;
    1230             : }
    1231             : 
    1232        8174 : AVCodec *avcodec_find_encoder(enum AVCodecID id)
    1233             : {
    1234        8174 :     return find_encdec(id, 1);
    1235             : }
    1236             : 
    1237        2797 : AVCodec *avcodec_find_encoder_by_name(const char *name)
    1238             : {
    1239             :     AVCodec *p;
    1240        2797 :     if (!name)
    1241           0 :         return NULL;
    1242        2797 :     p = first_avcodec;
    1243      670829 :     while (p) {
    1244      668031 :         if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
    1245        2796 :             return p;
    1246      665235 :         p = p->next;
    1247             :     }
    1248           1 :     return NULL;
    1249             : }
    1250             : 
    1251       18278 : AVCodec *avcodec_find_decoder(enum AVCodecID id)
    1252             : {
    1253       18278 :     return find_encdec(id, 0);
    1254             : }
    1255             : 
    1256        6328 : AVCodec *avcodec_find_decoder_by_name(const char *name)
    1257             : {
    1258             :     AVCodec *p;
    1259        6328 :     if (!name)
    1260           0 :         return NULL;
    1261        6328 :     p = first_avcodec;
    1262     1126762 :     while (p) {
    1263     1120434 :         if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
    1264        6328 :             return p;
    1265     1114106 :         p = p->next;
    1266             :     }
    1267           0 :     return NULL;
    1268             : }
    1269             : 
    1270       14817 : const char *avcodec_get_name(enum AVCodecID id)
    1271             : {
    1272             :     const AVCodecDescriptor *cd;
    1273             :     AVCodec *codec;
    1274             : 
    1275       14817 :     if (id == AV_CODEC_ID_NONE)
    1276         150 :         return "none";
    1277       14667 :     cd = avcodec_descriptor_get(id);
    1278       14667 :     if (cd)
    1279       14665 :         return cd->name;
    1280           2 :     av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
    1281           2 :     codec = avcodec_find_decoder(id);
    1282           2 :     if (codec)
    1283           0 :         return codec->name;
    1284           2 :     codec = avcodec_find_encoder(id);
    1285           2 :     if (codec)
    1286           0 :         return codec->name;
    1287           2 :     return "unknown_codec";
    1288             : }
    1289             : 
    1290           0 : size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
    1291             : {
    1292           0 :     int i, len, ret = 0;
    1293             : 
    1294             : #define TAG_PRINT(x)                                              \
    1295             :     (((x) >= '0' && (x) <= '9') ||                                \
    1296             :      ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') ||  \
    1297             :      ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
    1298             : 
    1299           0 :     for (i = 0; i < 4; i++) {
    1300           0 :         len = snprintf(buf, buf_size,
    1301           0 :                        TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
    1302           0 :         buf        += len;
    1303           0 :         buf_size    = buf_size > len ? buf_size - len : 0;
    1304           0 :         ret        += len;
    1305           0 :         codec_tag >>= 8;
    1306             :     }
    1307           0 :     return ret;
    1308             : }
    1309             : 
    1310       11412 : void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
    1311             : {
    1312             :     const char *codec_type;
    1313             :     const char *codec_name;
    1314       11412 :     const char *profile = NULL;
    1315             :     int64_t bitrate;
    1316       11412 :     int new_line = 0;
    1317             :     AVRational display_aspect_ratio;
    1318       11412 :     const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
    1319             : 
    1320       11412 :     if (!buf || buf_size <= 0)
    1321           3 :         return;
    1322       11412 :     codec_type = av_get_media_type_string(enc->codec_type);
    1323       11412 :     codec_name = avcodec_get_name(enc->codec_id);
    1324       11412 :     profile = avcodec_profile_name(enc->codec_id, enc->profile);
    1325             : 
    1326       11412 :     snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
    1327             :              codec_name);
    1328       11412 :     buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
    1329             : 
    1330       11412 :     if (enc->codec && strcmp(enc->codec->name, codec_name))
    1331          89 :         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
    1332             : 
    1333       11412 :     if (profile)
    1334        1297 :         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
    1335       11412 :     if (   enc->codec_type == AVMEDIA_TYPE_VIDEO
    1336        8785 :         && av_log_get_level() >= AV_LOG_VERBOSE
    1337           0 :         && enc->refs)
    1338           0 :         snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1339             :                  ", %d reference frame%s",
    1340           0 :                  enc->refs, enc->refs > 1 ? "s" : "");
    1341             : 
    1342       11412 :     if (enc->codec_tag)
    1343       13428 :         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
    1344        6714 :                  av_fourcc2str(enc->codec_tag), enc->codec_tag);
    1345             : 
    1346       11412 :     switch (enc->codec_type) {
    1347        8785 :     case AVMEDIA_TYPE_VIDEO:
    1348             :         {
    1349        8785 :             char detail[256] = "(";
    1350             : 
    1351        8785 :             av_strlcat(buf, separator, buf_size);
    1352             : 
    1353       17562 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1354        8785 :                  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
    1355        8777 :                      av_get_pix_fmt_name(enc->pix_fmt));
    1356       11796 :             if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
    1357        3011 :                 enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
    1358          17 :                 av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
    1359        8785 :             if (enc->color_range != AVCOL_RANGE_UNSPECIFIED)
    1360         794 :                 av_strlcatf(detail, sizeof(detail), "%s, ",
    1361             :                             av_color_range_name(enc->color_range));
    1362             : 
    1363       17329 :             if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
    1364       17088 :                 enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
    1365        8544 :                 enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
    1366         313 :                 if (enc->colorspace != (int)enc->color_primaries ||
    1367          71 :                     enc->colorspace != (int)enc->color_trc) {
    1368         179 :                     new_line = 1;
    1369         179 :                     av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
    1370             :                                 av_color_space_name(enc->colorspace),
    1371             :                                 av_color_primaries_name(enc->color_primaries),
    1372             :                                 av_color_transfer_name(enc->color_trc));
    1373             :                 } else
    1374          63 :                     av_strlcatf(detail, sizeof(detail), "%s, ",
    1375             :                                 av_get_colorspace_name(enc->colorspace));
    1376             :             }
    1377             : 
    1378        8785 :             if (enc->field_order != AV_FIELD_UNKNOWN) {
    1379         533 :                 const char *field_order = "progressive";
    1380         533 :                 if (enc->field_order == AV_FIELD_TT)
    1381          93 :                     field_order = "top first";
    1382         440 :                 else if (enc->field_order == AV_FIELD_BB)
    1383          34 :                     field_order = "bottom first";
    1384         406 :                 else if (enc->field_order == AV_FIELD_TB)
    1385           2 :                     field_order = "top coded first (swapped)";
    1386         404 :                 else if (enc->field_order == AV_FIELD_BT)
    1387          16 :                     field_order = "bottom coded first (swapped)";
    1388             : 
    1389         533 :                 av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
    1390             :             }
    1391             : 
    1392        8785 :             if (av_log_get_level() >= AV_LOG_VERBOSE &&
    1393           0 :                 enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
    1394           0 :                 av_strlcatf(detail, sizeof(detail), "%s, ",
    1395             :                             av_chroma_location_name(enc->chroma_sample_location));
    1396             : 
    1397        8785 :             if (strlen(detail) > 1) {
    1398        1269 :                 detail[strlen(detail) - 2] = 0;
    1399        1269 :                 av_strlcatf(buf, buf_size, "%s)", detail);
    1400             :             }
    1401             :         }
    1402             : 
    1403        8785 :         if (enc->width) {
    1404        8783 :             av_strlcat(buf, new_line ? separator : ", ", buf_size);
    1405             : 
    1406        8783 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1407             :                      "%dx%d",
    1408             :                      enc->width, enc->height);
    1409             : 
    1410        8783 :             if (av_log_get_level() >= AV_LOG_VERBOSE &&
    1411           0 :                 (enc->width != enc->coded_width ||
    1412           0 :                  enc->height != enc->coded_height))
    1413           0 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1414             :                          " (%dx%d)", enc->coded_width, enc->coded_height);
    1415             : 
    1416        8783 :             if (enc->sample_aspect_ratio.num) {
    1417        2078 :                 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
    1418        1039 :                           enc->width * (int64_t)enc->sample_aspect_ratio.num,
    1419        1039 :                           enc->height * (int64_t)enc->sample_aspect_ratio.den,
    1420             :                           1024 * 1024);
    1421        1039 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1422             :                          " [SAR %d:%d DAR %d:%d]",
    1423             :                          enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
    1424             :                          display_aspect_ratio.num, display_aspect_ratio.den);
    1425             :             }
    1426        8783 :             if (av_log_get_level() >= AV_LOG_DEBUG) {
    1427           0 :                 int g = av_gcd(enc->time_base.num, enc->time_base.den);
    1428           0 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1429             :                          ", %d/%d",
    1430           0 :                          enc->time_base.num / g, enc->time_base.den / g);
    1431             :             }
    1432             :         }
    1433        8785 :         if (encode) {
    1434        4351 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1435             :                      ", q=%d-%d", enc->qmin, enc->qmax);
    1436             :         } else {
    1437        4434 :             if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
    1438           1 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1439             :                          ", Closed Captions");
    1440        4434 :             if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
    1441          19 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1442             :                          ", lossless");
    1443             :         }
    1444        8785 :         break;
    1445        2486 :     case AVMEDIA_TYPE_AUDIO:
    1446        2486 :         av_strlcat(buf, separator, buf_size);
    1447             : 
    1448        2486 :         if (enc->sample_rate) {
    1449        2486 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1450             :                      "%d Hz, ", enc->sample_rate);
    1451             :         }
    1452        2486 :         av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
    1453        2486 :         if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
    1454        2485 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1455             :                      ", %s", av_get_sample_fmt_name(enc->sample_fmt));
    1456             :         }
    1457        2486 :         if (   enc->bits_per_raw_sample > 0
    1458         237 :             && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
    1459         105 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1460             :                      " (%d bit)", enc->bits_per_raw_sample);
    1461        2486 :         if (av_log_get_level() >= AV_LOG_VERBOSE) {
    1462           0 :             if (enc->initial_padding)
    1463           0 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1464             :                          ", delay %d", enc->initial_padding);
    1465           0 :             if (enc->trailing_padding)
    1466           0 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1467             :                          ", padding %d", enc->trailing_padding);
    1468             :         }
    1469        2486 :         break;
    1470          58 :     case AVMEDIA_TYPE_DATA:
    1471          58 :         if (av_log_get_level() >= AV_LOG_DEBUG) {
    1472           0 :             int g = av_gcd(enc->time_base.num, enc->time_base.den);
    1473           0 :             if (g)
    1474           0 :                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1475             :                          ", %d/%d",
    1476           0 :                          enc->time_base.num / g, enc->time_base.den / g);
    1477             :         }
    1478          58 :         break;
    1479          80 :     case AVMEDIA_TYPE_SUBTITLE:
    1480          80 :         if (enc->width)
    1481          13 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1482             :                      ", %dx%d", enc->width, enc->height);
    1483          80 :         break;
    1484           3 :     default:
    1485           3 :         return;
    1486             :     }
    1487       11409 :     if (encode) {
    1488        5551 :         if (enc->flags & AV_CODEC_FLAG_PASS1)
    1489           0 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1490             :                      ", pass 1");
    1491        5551 :         if (enc->flags & AV_CODEC_FLAG_PASS2)
    1492           0 :             snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1493             :                      ", pass 2");
    1494             :     }
    1495       11409 :     bitrate = get_bit_rate(enc);
    1496       11409 :     if (bitrate != 0) {
    1497        7545 :         snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1498             :                  ", %"PRId64" kb/s", bitrate / 1000);
    1499        3864 :     } else if (enc->rc_max_rate > 0) {
    1500           0 :         snprintf(buf + strlen(buf), buf_size - strlen(buf),
    1501           0 :                  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
    1502             :     }
    1503             : }
    1504             : 
    1505           0 : const char *av_get_profile_name(const AVCodec *codec, int profile)
    1506             : {
    1507             :     const AVProfile *p;
    1508           0 :     if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
    1509           0 :         return NULL;
    1510             : 
    1511           0 :     for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
    1512           0 :         if (p->profile == profile)
    1513           0 :             return p->name;
    1514             : 
    1515           0 :     return NULL;
    1516             : }
    1517             : 
    1518       11415 : const char *avcodec_profile_name(enum AVCodecID codec_id, int profile)
    1519             : {
    1520       11415 :     const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
    1521             :     const AVProfile *p;
    1522             : 
    1523       11415 :     if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
    1524       10103 :         return NULL;
    1525             : 
    1526        3601 :     for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
    1527        3589 :         if (p->profile == profile)
    1528        1300 :             return p->name;
    1529             : 
    1530          12 :     return NULL;
    1531             : }
    1532             : 
    1533        5466 : unsigned avcodec_version(void)
    1534             : {
    1535             : //    av_assert0(AV_CODEC_ID_V410==164);
    1536             :     av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
    1537             :     av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
    1538             : //     av_assert0(AV_CODEC_ID_BMV_AUDIO==86071);
    1539             :     av_assert0(AV_CODEC_ID_SRT==94216);
    1540             :     av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
    1541             : 
    1542        5466 :     return LIBAVCODEC_VERSION_INT;
    1543             : }
    1544             : 
    1545        5466 : const char *avcodec_configuration(void)
    1546             : {
    1547        5466 :     return FFMPEG_CONFIGURATION;
    1548             : }
    1549             : 
    1550           0 : const char *avcodec_license(void)
    1551             : {
    1552             : #define LICENSE_PREFIX "libavcodec license: "
    1553           0 :     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
    1554             : }
    1555             : 
    1556      789593 : int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
    1557             : {
    1558      789593 :     switch (codec_id) {
    1559        1677 :     case AV_CODEC_ID_8SVX_EXP:
    1560             :     case AV_CODEC_ID_8SVX_FIB:
    1561             :     case AV_CODEC_ID_ADPCM_CT:
    1562             :     case AV_CODEC_ID_ADPCM_IMA_APC:
    1563             :     case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
    1564             :     case AV_CODEC_ID_ADPCM_IMA_OKI:
    1565             :     case AV_CODEC_ID_ADPCM_IMA_WS:
    1566             :     case AV_CODEC_ID_ADPCM_G722:
    1567             :     case AV_CODEC_ID_ADPCM_YAMAHA:
    1568             :     case AV_CODEC_ID_ADPCM_AICA:
    1569        1677 :         return 4;
    1570       11412 :     case AV_CODEC_ID_DSD_LSBF:
    1571             :     case AV_CODEC_ID_DSD_MSBF:
    1572             :     case AV_CODEC_ID_DSD_LSBF_PLANAR:
    1573             :     case AV_CODEC_ID_DSD_MSBF_PLANAR:
    1574             :     case AV_CODEC_ID_PCM_ALAW:
    1575             :     case AV_CODEC_ID_PCM_MULAW:
    1576             :     case AV_CODEC_ID_PCM_S8:
    1577             :     case AV_CODEC_ID_PCM_S8_PLANAR:
    1578             :     case AV_CODEC_ID_PCM_U8:
    1579             :     case AV_CODEC_ID_PCM_ZORK:
    1580             :     case AV_CODEC_ID_SDX2_DPCM:
    1581       11412 :         return 8;
    1582      565596 :     case AV_CODEC_ID_PCM_S16BE:
    1583             :     case AV_CODEC_ID_PCM_S16BE_PLANAR:
    1584             :     case AV_CODEC_ID_PCM_S16LE:
    1585             :     case AV_CODEC_ID_PCM_S16LE_PLANAR:
    1586             :     case AV_CODEC_ID_PCM_U16BE:
    1587             :     case AV_CODEC_ID_PCM_U16LE:
    1588      565596 :         return 16;
    1589       42539 :     case AV_CODEC_ID_PCM_S24DAUD:
    1590             :     case AV_CODEC_ID_PCM_S24BE:
    1591             :     case AV_CODEC_ID_PCM_S24LE:
    1592             :     case AV_CODEC_ID_PCM_S24LE_PLANAR:
    1593             :     case AV_CODEC_ID_PCM_U24BE:
    1594             :     case AV_CODEC_ID_PCM_U24LE:
    1595       42539 :         return 24;
    1596       28152 :     case AV_CODEC_ID_PCM_S32BE:
    1597             :     case AV_CODEC_ID_PCM_S32LE:
    1598             :     case AV_CODEC_ID_PCM_S32LE_PLANAR:
    1599             :     case AV_CODEC_ID_PCM_U32BE:
    1600             :     case AV_CODEC_ID_PCM_U32LE:
    1601             :     case AV_CODEC_ID_PCM_F32BE:
    1602             :     case AV_CODEC_ID_PCM_F32LE:
    1603             :     case AV_CODEC_ID_PCM_F24LE:
    1604             :     case AV_CODEC_ID_PCM_F16LE:
    1605       28152 :         return 32;
    1606        9552 :     case AV_CODEC_ID_PCM_F64BE:
    1607             :     case AV_CODEC_ID_PCM_F64LE:
    1608             :     case AV_CODEC_ID_PCM_S64BE:
    1609             :     case AV_CODEC_ID_PCM_S64LE:
    1610        9552 :         return 64;
    1611      130665 :     default:
    1612      130665 :         return 0;
    1613             :     }
    1614             : }
    1615             : 
    1616           8 : enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
    1617             : {
    1618             :     static const enum AVCodecID map[AV_SAMPLE_FMT_NB][2] = {
    1619             :         [AV_SAMPLE_FMT_U8  ] = { AV_CODEC_ID_PCM_U8,    AV_CODEC_ID_PCM_U8    },
    1620             :         [AV_SAMPLE_FMT_S16 ] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
    1621             :         [AV_SAMPLE_FMT_S32 ] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
    1622             :         [AV_SAMPLE_FMT_FLT ] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
    1623             :         [AV_SAMPLE_FMT_DBL ] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
    1624             :         [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8,    AV_CODEC_ID_PCM_U8    },
    1625             :         [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
    1626             :         [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
    1627             :         [AV_SAMPLE_FMT_S64P] = { AV_CODEC_ID_PCM_S64LE, AV_CODEC_ID_PCM_S64BE },
    1628             :         [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
    1629             :         [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
    1630             :     };
    1631           8 :     if (fmt < 0 || fmt >= AV_SAMPLE_FMT_NB)
    1632           0 :         return AV_CODEC_ID_NONE;
    1633           8 :     if (be < 0 || be > 1)
    1634           8 :         be = AV_NE(1, 0);
    1635           8 :     return map[fmt][be];
    1636             : }
    1637             : 
    1638      327765 : int av_get_bits_per_sample(enum AVCodecID codec_id)
    1639             : {
    1640      327765 :     switch (codec_id) {
    1641           3 :     case AV_CODEC_ID_ADPCM_SBPRO_2:
    1642           3 :         return 2;
    1643           3 :     case AV_CODEC_ID_ADPCM_SBPRO_3:
    1644           3 :         return 3;
    1645          59 :     case AV_CODEC_ID_ADPCM_SBPRO_4:
    1646             :     case AV_CODEC_ID_ADPCM_IMA_WAV:
    1647             :     case AV_CODEC_ID_ADPCM_IMA_QT:
    1648             :     case AV_CODEC_ID_ADPCM_SWF:
    1649             :     case AV_CODEC_ID_ADPCM_MS:
    1650          59 :         return 4;
    1651      327700 :     default:
    1652      327700 :         return av_get_exact_bits_per_sample(codec_id);
    1653             :     }
    1654             : }
    1655             : 
    1656      456529 : static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
    1657             :                                     uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
    1658             :                                     uint8_t * extradata, int frame_size, int frame_bytes)
    1659             : {
    1660      456529 :     int bps = av_get_exact_bits_per_sample(id);
    1661      456529 :     int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
    1662             : 
    1663             :     /* codecs with an exact constant bits per sample */
    1664      456529 :     if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
    1665      332255 :         return (frame_bytes * 8LL) / (bps * ch);
    1666      124274 :     bps = bits_per_coded_sample;
    1667             : 
    1668             :     /* codecs with a fixed packet duration */
    1669      124274 :     switch (id) {
    1670       16538 :     case AV_CODEC_ID_ADPCM_ADX:    return   32;
    1671        8274 :     case AV_CODEC_ID_ADPCM_IMA_QT: return   64;
    1672         600 :     case AV_CODEC_ID_ADPCM_EA_XAS: return  128;
    1673        3933 :     case AV_CODEC_ID_AMR_NB:
    1674             :     case AV_CODEC_ID_EVRC:
    1675             :     case AV_CODEC_ID_GSM:
    1676             :     case AV_CODEC_ID_QCELP:
    1677        3933 :     case AV_CODEC_ID_RA_288:       return  160;
    1678           0 :     case AV_CODEC_ID_AMR_WB:
    1679           0 :     case AV_CODEC_ID_GSM_MS:       return  320;
    1680           0 :     case AV_CODEC_ID_MP1:          return  384;
    1681        3274 :     case AV_CODEC_ID_ATRAC1:       return  512;
    1682        2756 :     case AV_CODEC_ID_ATRAC3:       return 1024 * framecount;
    1683         813 :     case AV_CODEC_ID_ATRAC3P:      return 2048;
    1684        5022 :     case AV_CODEC_ID_MP2:
    1685        5022 :     case AV_CODEC_ID_MUSEPACK7:    return 1152;
    1686        1407 :     case AV_CODEC_ID_AC3:          return 1536;
    1687             :     }
    1688             : 
    1689       81657 :     if (sr > 0) {
    1690             :         /* calc from sample rate */
    1691       55664 :         if (id == AV_CODEC_ID_TTA)
    1692           9 :             return 256 * sr / 245;
    1693       55655 :         else if (id == AV_CODEC_ID_DST)
    1694           0 :             return 588 * sr / 44100;
    1695             : 
    1696       55655 :         if (ch > 0) {
    1697             :             /* calc from sample rate and channels */
    1698       55655 :             if (id == AV_CODEC_ID_BINKAUDIO_DCT)
    1699          65 :                 return (480 << (sr / 22050)) / ch;
    1700             :         }
    1701             : 
    1702       55590 :         if (id == AV_CODEC_ID_MP3)
    1703        2690 :             return sr <= 24000 ? 576 : 1152;
    1704             :     }
    1705             : 
    1706       78893 :     if (ba > 0) {
    1707             :         /* calc from block_align */
    1708       18296 :         if (id == AV_CODEC_ID_SIPR) {
    1709        6418 :             switch (ba) {
    1710        3250 :             case 20: return 160;
    1711        1152 :             case 19: return 144;
    1712        1680 :             case 29: return 288;
    1713         336 :             case 37: return 480;
    1714             :             }
    1715       11878 :         } else if (id == AV_CODEC_ID_ILBC) {
    1716           0 :             switch (ba) {
    1717           0 :             case 38: return 160;
    1718           0 :             case 50: return 240;
    1719             :             }
    1720             :         }
    1721             :     }
    1722             : 
    1723       72475 :     if (frame_bytes > 0) {
    1724             :         /* calc from frame_bytes only */
    1725       70134 :         if (id == AV_CODEC_ID_TRUESPEECH)
    1726          12 :             return 240 * (frame_bytes / 32);
    1727       70122 :         if (id == AV_CODEC_ID_NELLYMOSER)
    1728        2074 :             return 256 * (frame_bytes / 64);
    1729       68048 :         if (id == AV_CODEC_ID_RA_144)
    1730        1057 :             return 160 * (frame_bytes / 20);
    1731       66991 :         if (id == AV_CODEC_ID_G723_1)
    1732         200 :             return 240 * (frame_bytes / 24);
    1733             : 
    1734       66791 :         if (bps > 0) {
    1735             :             /* calc from frame_bytes and bits_per_coded_sample */
    1736       14855 :             if (id == AV_CODEC_ID_ADPCM_G726 || id == AV_CODEC_ID_ADPCM_G726LE)
    1737         106 :                 return frame_bytes * 8 / bps;
    1738             :         }
    1739             : 
    1740       66685 :         if (ch > 0 && ch < INT_MAX/16) {
    1741             :             /* calc from frame_bytes and channels */
    1742       42973 :             switch (id) {
    1743          36 :             case AV_CODEC_ID_ADPCM_AFC:
    1744          36 :                 return frame_bytes / (9 * ch) * 16;
    1745          33 :             case AV_CODEC_ID_ADPCM_PSX:
    1746             :             case AV_CODEC_ID_ADPCM_DTK:
    1747          33 :                 return frame_bytes / (16 * ch) * 28;
    1748         452 :             case AV_CODEC_ID_ADPCM_4XM:
    1749             :             case AV_CODEC_ID_ADPCM_IMA_DAT4:
    1750             :             case AV_CODEC_ID_ADPCM_IMA_ISS:
    1751         452 :                 return (frame_bytes - 4 * ch) * 2 / ch;
    1752        1601 :             case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
    1753        1601 :                 return (frame_bytes - 4) * 2 / ch;
    1754         162 :             case AV_CODEC_ID_ADPCM_IMA_AMV:
    1755         162 :                 return (frame_bytes - 8) * 2 / ch;
    1756        1792 :             case AV_CODEC_ID_ADPCM_THP:
    1757             :             case AV_CODEC_ID_ADPCM_THP_LE:
    1758        1792 :                 if (extradata)
    1759        1767 :                     return frame_bytes * 14 / (8 * ch);
    1760          25 :                 break;
    1761         111 :             case AV_CODEC_ID_ADPCM_XA:
    1762         111 :                 return (frame_bytes / 128) * 224 / ch;
    1763         327 :             case AV_CODEC_ID_INTERPLAY_DPCM:
    1764         327 :                 return (frame_bytes - 6 - ch) / ch;
    1765         680 :             case AV_CODEC_ID_ROQ_DPCM:
    1766         680 :                 return (frame_bytes - 8) / ch;
    1767         112 :             case AV_CODEC_ID_XAN_DPCM:
    1768         112 :                 return (frame_bytes - 2 * ch) / ch;
    1769           0 :             case AV_CODEC_ID_MACE3:
    1770           0 :                 return 3 * frame_bytes / ch;
    1771          69 :             case AV_CODEC_ID_MACE6:
    1772          69 :                 return 6 * frame_bytes / ch;
    1773           0 :             case AV_CODEC_ID_PCM_LXF:
    1774           0 :                 return 2 * (frame_bytes / (5 * ch));
    1775        1311 :             case AV_CODEC_ID_IAC:
    1776             :             case AV_CODEC_ID_IMC:
    1777        1311 :                 return 4 * frame_bytes / ch;
    1778             :             }
    1779             : 
    1780       36312 :             if (tag) {
    1781             :                 /* calc from frame_bytes, channels, and codec_tag */
    1782        9302 :                 if (id == AV_CODEC_ID_SOL_DPCM) {
    1783          74 :                     if (tag == 3)
    1784          74 :                         return frame_bytes / ch;
    1785             :                     else
    1786           0 :                         return frame_bytes * 2 / ch;
    1787             :                 }
    1788             :             }
    1789             : 
    1790       36238 :             if (ba > 0) {
    1791             :                 /* calc from frame_bytes, channels, and block_align */
    1792        8767 :                 int blocks = frame_bytes / ba;
    1793        8767 :                 switch (id) {
    1794         916 :                 case AV_CODEC_ID_ADPCM_IMA_WAV:
    1795         916 :                     if (bps < 2 || bps > 5)
    1796           0 :                         return 0;
    1797         916 :                     return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
    1798         669 :                 case AV_CODEC_ID_ADPCM_IMA_DK3:
    1799         669 :                     return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
    1800         649 :                 case AV_CODEC_ID_ADPCM_IMA_DK4:
    1801         649 :                     return blocks * (1 + (ba - 4 * ch) * 2 / ch);
    1802        1001 :                 case AV_CODEC_ID_ADPCM_IMA_RAD:
    1803        1001 :                     return blocks * ((ba - 4 * ch) * 2 / ch);
    1804         890 :                 case AV_CODEC_ID_ADPCM_MS:
    1805         890 :                     return blocks * (2 + (ba - 7 * ch) * 2 / ch);
    1806           0 :                 case AV_CODEC_ID_ADPCM_MTAF:
    1807           0 :                     return blocks * (ba - 16) * 2 / ch;
    1808             :                 }
    1809             :             }
    1810             : 
    1811       32113 :             if (bps > 0) {
    1812             :                 /* calc from frame_bytes, channels, and bits_per_coded_sample */
    1813        7084 :                 switch (id) {
    1814         304 :                 case AV_CODEC_ID_PCM_DVD:
    1815         304 :                     if(bps<4 || frame_bytes<3)
    1816           0 :                         return 0;
    1817         304 :                     return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
    1818           0 :                 case AV_CODEC_ID_PCM_BLURAY:
    1819           0 :                     if(bps<4 || frame_bytes<4)
    1820           0 :                         return 0;
    1821           0 :                     return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
    1822           0 :                 case AV_CODEC_ID_S302M:
    1823           0 :                     return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
    1824             :                 }
    1825             :             }
    1826             :         }
    1827             :     }
    1828             : 
    1829             :     /* Fall back on using frame_size */
    1830       57862 :     if (frame_size > 1 && frame_bytes)
    1831       20529 :         return frame_size;
    1832             : 
    1833             :     //For WMA we currently have no other means to calculate duration thus we
    1834             :     //do it here by assuming CBR, which is true for all known cases.
    1835       37333 :     if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
    1836        4188 :         if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
    1837         770 :             return  (frame_bytes * 8LL * sr) / bitrate;
    1838             :     }
    1839             : 
    1840       36563 :     return 0;
    1841             : }
    1842             : 
    1843      366449 : int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
    1844             : {
    1845      366449 :     return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
    1846             :                                     avctx->channels, avctx->block_align,
    1847             :                                     avctx->codec_tag, avctx->bits_per_coded_sample,
    1848             :                                     avctx->bit_rate, avctx->extradata, avctx->frame_size,
    1849             :                                     frame_bytes);
    1850             : }
    1851             : 
    1852       90080 : int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
    1853             : {
    1854       90080 :     return get_audio_frame_duration(par->codec_id, par->sample_rate,
    1855             :                                     par->channels, par->block_align,
    1856             :                                     par->codec_tag, par->bits_per_coded_sample,
    1857             :                                     par->bit_rate, par->extradata, par->frame_size,
    1858             :                                     frame_bytes);
    1859             : }
    1860             : 
    1861             : #if !HAVE_THREADS
    1862             : int ff_thread_init(AVCodecContext *s)
    1863             : {
    1864             :     return -1;
    1865             : }
    1866             : 
    1867             : #endif
    1868             : 
    1869          52 : unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
    1870             : {
    1871          52 :     unsigned int n = 0;
    1872             : 
    1873         104 :     while (v >= 0xff) {
    1874           0 :         *s++ = 0xff;
    1875           0 :         v -= 0xff;
    1876           0 :         n++;
    1877             :     }
    1878          52 :     *s = v;
    1879          52 :     n++;
    1880          52 :     return n;
    1881             : }
    1882             : 
    1883         476 : int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
    1884             : {
    1885             :     int i;
    1886         476 :     for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
    1887         476 :     return i;
    1888             : }
    1889             : 
    1890       11430 : const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index)
    1891             : {
    1892             :     int i;
    1893       11430 :     if (!codec->hw_configs || index < 0)
    1894        9874 :         return NULL;
    1895        3112 :     for (i = 0; i <= index; i++)
    1896        2334 :         if (!codec->hw_configs[i])
    1897         778 :             return NULL;
    1898         778 :     return &codec->hw_configs[index]->public;
    1899             : }
    1900             : 
    1901             : #if FF_API_USER_VISIBLE_AVHWACCEL
    1902           0 : AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel)
    1903             : {
    1904           0 :     return NULL;
    1905             : }
    1906             : 
    1907           0 : void av_register_hwaccel(AVHWAccel *hwaccel)
    1908             : {
    1909           0 : }
    1910             : #endif
    1911             : 
    1912           0 : int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
    1913             : {
    1914           0 :     if (lockmgr_cb) {
    1915             :         // There is no good way to rollback a failure to destroy the
    1916             :         // mutex, so we ignore failures.
    1917           0 :         lockmgr_cb(&codec_mutex,    AV_LOCK_DESTROY);
    1918           0 :         lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY);
    1919           0 :         lockmgr_cb     = NULL;
    1920           0 :         codec_mutex    = NULL;
    1921           0 :         avformat_mutex = NULL;
    1922             :     }
    1923             : 
    1924           0 :     if (cb) {
    1925           0 :         void *new_codec_mutex    = NULL;
    1926           0 :         void *new_avformat_mutex = NULL;
    1927             :         int err;
    1928           0 :         if (err = cb(&new_codec_mutex, AV_LOCK_CREATE)) {
    1929           0 :             return err > 0 ? AVERROR_UNKNOWN : err;
    1930             :         }
    1931           0 :         if (err = cb(&new_avformat_mutex, AV_LOCK_CREATE)) {
    1932             :             // Ignore failures to destroy the newly created mutex.
    1933           0 :             cb(&new_codec_mutex, AV_LOCK_DESTROY);
    1934           0 :             return err > 0 ? AVERROR_UNKNOWN : err;
    1935             :         }
    1936           0 :         lockmgr_cb     = cb;
    1937           0 :         codec_mutex    = new_codec_mutex;
    1938           0 :         avformat_mutex = new_avformat_mutex;
    1939             :     }
    1940             : 
    1941           0 :     return 0;
    1942             : }
    1943             : 
    1944       22548 : int ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
    1945             : {
    1946       22548 :     if (codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE || !codec->init)
    1947        6263 :         return 0;
    1948             : 
    1949       16285 :     if (lockmgr_cb) {
    1950       16285 :         if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
    1951           0 :             return -1;
    1952             :     }
    1953             : 
    1954       16285 :     if (atomic_fetch_add(&entangled_thread_counter, 1)) {
    1955           0 :         av_log(log_ctx, AV_LOG_ERROR,
    1956             :                "Insufficient thread locking. At least %d threads are "
    1957             :                "calling avcodec_open2() at the same time right now.\n",
    1958           0 :                atomic_load(&entangled_thread_counter));
    1959           0 :         if (!lockmgr_cb)
    1960           0 :             av_log(log_ctx, AV_LOG_ERROR, "No lock manager is set, please see av_lockmgr_register()\n");
    1961           0 :         ff_avcodec_locked = 1;
    1962           0 :         ff_unlock_avcodec(codec);
    1963           0 :         return AVERROR(EINVAL);
    1964             :     }
    1965       16285 :     av_assert0(!ff_avcodec_locked);
    1966       16285 :     ff_avcodec_locked = 1;
    1967       16285 :     return 0;
    1968             : }
    1969             : 
    1970       22548 : int ff_unlock_avcodec(const AVCodec *codec)
    1971             : {
    1972       22548 :     if (codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE || !codec->init)
    1973        6263 :         return 0;
    1974             : 
    1975       16285 :     av_assert0(ff_avcodec_locked);
    1976       16285 :     ff_avcodec_locked = 0;
    1977       16285 :     atomic_fetch_add(&entangled_thread_counter, -1);
    1978       16285 :     if (lockmgr_cb) {
    1979       16285 :         if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE))
    1980           0 :             return -1;
    1981             :     }
    1982             : 
    1983       16285 :     return 0;
    1984             : }
    1985             : 
    1986           0 : int avpriv_lock_avformat(void)
    1987             : {
    1988           0 :     if (lockmgr_cb) {
    1989           0 :         if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
    1990           0 :             return -1;
    1991             :     }
    1992           0 :     return 0;
    1993             : }
    1994             : 
    1995           0 : int avpriv_unlock_avformat(void)
    1996             : {
    1997           0 :     if (lockmgr_cb) {
    1998           0 :         if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
    1999           0 :             return -1;
    2000             :     }
    2001           0 :     return 0;
    2002             : }
    2003             : 
    2004      541987 : unsigned int avpriv_toupper4(unsigned int x)
    2005             : {
    2006     1083974 :     return av_toupper(x & 0xFF) +
    2007     1083974 :           (av_toupper((x >>  8) & 0xFF) << 8)  +
    2008     1083974 :           (av_toupper((x >> 16) & 0xFF) << 16) +
    2009      541987 : ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
    2010             : }
    2011             : 
    2012      135518 : int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
    2013             : {
    2014             :     int ret;
    2015             : 
    2016      135518 :     dst->owner[0] = src->owner[0];
    2017      135518 :     dst->owner[1] = src->owner[1];
    2018             : 
    2019      135518 :     ret = av_frame_ref(dst->f, src->f);
    2020      135518 :     if (ret < 0)
    2021           0 :         return ret;
    2022             : 
    2023      135518 :     av_assert0(!dst->progress);
    2024             : 
    2025      135518 :     if (src->progress &&
    2026           0 :         !(dst->progress = av_buffer_ref(src->progress))) {
    2027           0 :         ff_thread_release_buffer(dst->owner[0], dst);
    2028           0 :         return AVERROR(ENOMEM);
    2029             :     }
    2030             : 
    2031      135518 :     return 0;
    2032             : }
    2033             : 
    2034             : #if !HAVE_THREADS
    2035             : 
    2036             : enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
    2037             : {
    2038             :     return ff_get_format(avctx, fmt);
    2039             : }
    2040             : 
    2041             : int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
    2042             : {
    2043             :     f->owner[0] = f->owner[1] = avctx;
    2044             :     return ff_get_buffer(avctx, f->f, flags);
    2045             : }
    2046             : 
    2047             : void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
    2048             : {
    2049             :     if (f->f)
    2050             :         av_frame_unref(f->f);
    2051             : }
    2052             : 
    2053             : void ff_thread_finish_setup(AVCodecContext *avctx)
    2054             : {
    2055             : }
    2056             : 
    2057             : void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
    2058             : {
    2059             : }
    2060             : 
    2061             : void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
    2062             : {
    2063             : }
    2064             : 
    2065             : int ff_thread_can_start_frame(AVCodecContext *avctx)
    2066             : {
    2067             :     return 1;
    2068             : }
    2069             : 
    2070             : int ff_alloc_entries(AVCodecContext *avctx, int count)
    2071             : {
    2072             :     return 0;
    2073             : }
    2074             : 
    2075             : void ff_reset_entries(AVCodecContext *avctx)
    2076             : {
    2077             : }
    2078             : 
    2079             : void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
    2080             : {
    2081             : }
    2082             : 
    2083             : void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
    2084             : {
    2085             : }
    2086             : 
    2087             : #endif
    2088             : 
    2089     2567126 : int avcodec_is_open(AVCodecContext *s)
    2090             : {
    2091     2567126 :     return !!s->internal;
    2092             : }
    2093             : 
    2094           1 : int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
    2095             : {
    2096             :     int ret;
    2097             :     char *str;
    2098             : 
    2099           1 :     ret = av_bprint_finalize(buf, &str);
    2100           1 :     if (ret < 0)
    2101           0 :         return ret;
    2102           1 :     if (!av_bprint_is_complete(buf)) {
    2103           0 :         av_free(str);
    2104           0 :         return AVERROR(ENOMEM);
    2105             :     }
    2106             : 
    2107           1 :     avctx->extradata = str;
    2108             :     /* Note: the string is NUL terminated (so extradata can be read as a
    2109             :      * string), but the ending character is not accounted in the size (in
    2110             :      * binary formats you are likely not supposed to mux that character). When
    2111             :      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
    2112             :      * zeros. */
    2113           1 :     avctx->extradata_size = buf->len;
    2114           1 :     return 0;
    2115             : }
    2116             : 
    2117      531576 : const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
    2118             :                                       const uint8_t *end,
    2119             :                                       uint32_t *av_restrict state)
    2120             : {
    2121             :     int i;
    2122             : 
    2123      531576 :     av_assert0(p <= end);
    2124      531576 :     if (p >= end)
    2125         550 :         return end;
    2126             : 
    2127     2114869 :     for (i = 0; i < 3; i++) {
    2128     1587634 :         uint32_t tmp = *state << 8;
    2129     1587634 :         *state = tmp + *(p++);
    2130     1587634 :         if (tmp == 0x100 || p == end)
    2131        3791 :             return p;
    2132             :     }
    2133             : 
    2134   113933546 :     while (p < end) {
    2135   113355047 :         if      (p[-1] > 1      ) p += 3;
    2136    14578115 :         else if (p[-2]          ) p += 2;
    2137     9025662 :         else if (p[-3]|(p[-1]-1)) p++;
    2138             :         else {
    2139      475971 :             p++;
    2140      475971 :             break;
    2141             :         }
    2142             :     }
    2143             : 
    2144      527235 :     p = FFMIN(p, end) - 4;
    2145      527235 :     *state = AV_RB32(p);
    2146             : 
    2147      527235 :     return p + 4;
    2148             : }
    2149             : 
    2150         208 : AVCPBProperties *av_cpb_properties_alloc(size_t *size)
    2151             : {
    2152         208 :     AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
    2153         208 :     if (!props)
    2154           0 :         return NULL;
    2155             : 
    2156         208 :     if (size)
    2157         208 :         *size = sizeof(*props);
    2158             : 
    2159         208 :     props->vbv_delay = UINT64_MAX;
    2160             : 
    2161         208 :     return props;
    2162             : }
    2163             : 
    2164         183 : AVCPBProperties *ff_add_cpb_side_data(AVCodecContext *avctx)
    2165             : {
    2166             :     AVPacketSideData *tmp;
    2167             :     AVCPBProperties  *props;
    2168             :     size_t size;
    2169             : 
    2170         183 :     props = av_cpb_properties_alloc(&size);
    2171         183 :     if (!props)
    2172           0 :         return NULL;
    2173             : 
    2174         183 :     tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
    2175         183 :     if (!tmp) {
    2176           0 :         av_freep(&props);
    2177           0 :         return NULL;
    2178             :     }
    2179             : 
    2180         183 :     avctx->coded_side_data = tmp;
    2181         183 :     avctx->nb_coded_side_data++;
    2182             : 
    2183         183 :     avctx->coded_side_data[avctx->nb_coded_side_data - 1].type = AV_PKT_DATA_CPB_PROPERTIES;
    2184         183 :     avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
    2185         183 :     avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
    2186             : 
    2187         183 :     return props;
    2188             : }
    2189             : 
    2190      117415 : static void codec_parameters_reset(AVCodecParameters *par)
    2191             : {
    2192      117415 :     av_freep(&par->extradata);
    2193             : 
    2194      117415 :     memset(par, 0, sizeof(*par));
    2195             : 
    2196      117415 :     par->codec_type          = AVMEDIA_TYPE_UNKNOWN;
    2197      117415 :     par->codec_id            = AV_CODEC_ID_NONE;
    2198      117415 :     par->format              = -1;
    2199      117415 :     par->field_order         = AV_FIELD_UNKNOWN;
    2200      117415 :     par->color_range         = AVCOL_RANGE_UNSPECIFIED;
    2201      117415 :     par->color_primaries     = AVCOL_PRI_UNSPECIFIED;
    2202      117415 :     par->color_trc           = AVCOL_TRC_UNSPECIFIED;
    2203      117415 :     par->color_space         = AVCOL_SPC_UNSPECIFIED;
    2204      117415 :     par->chroma_location     = AVCHROMA_LOC_UNSPECIFIED;
    2205      117415 :     par->sample_aspect_ratio = (AVRational){ 0, 1 };
    2206      117415 :     par->profile             = FF_PROFILE_UNKNOWN;
    2207      117415 :     par->level               = FF_LEVEL_UNKNOWN;
    2208      117415 : }
    2209             : 
    2210       39823 : AVCodecParameters *avcodec_parameters_alloc(void)
    2211             : {
    2212       39823 :     AVCodecParameters *par = av_mallocz(sizeof(*par));
    2213             : 
    2214       39823 :     if (!par)
    2215           0 :         return NULL;
    2216       39823 :     codec_parameters_reset(par);
    2217       39823 :     return par;
    2218             : }
    2219             : 
    2220       39819 : void avcodec_parameters_free(AVCodecParameters **ppar)
    2221             : {
    2222       39819 :     AVCodecParameters *par = *ppar;
    2223             : 
    2224       39819 :     if (!par)
    2225           0 :         return;
    2226       39819 :     codec_parameters_reset(par);
    2227             : 
    2228       39819 :     av_freep(ppar);
    2229             : }
    2230             : 
    2231       10998 : int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
    2232             : {
    2233       10998 :     codec_parameters_reset(dst);
    2234       10998 :     memcpy(dst, src, sizeof(*dst));
    2235             : 
    2236       10998 :     dst->extradata      = NULL;
    2237       10998 :     dst->extradata_size = 0;
    2238       10998 :     if (src->extradata) {
    2239        2162 :         dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
    2240        2162 :         if (!dst->extradata)
    2241           0 :             return AVERROR(ENOMEM);
    2242        2162 :         memcpy(dst->extradata, src->extradata, src->extradata_size);
    2243        2162 :         dst->extradata_size = src->extradata_size;
    2244             :     }
    2245             : 
    2246       10998 :     return 0;
    2247             : }
    2248             : 
    2249       26775 : int avcodec_parameters_from_context(AVCodecParameters *par,
    2250             :                                     const AVCodecContext *codec)
    2251             : {
    2252       26775 :     codec_parameters_reset(par);
    2253             : 
    2254       26775 :     par->codec_type = codec->codec_type;
    2255       26775 :     par->codec_id   = codec->codec_id;
    2256       26775 :     par->codec_tag  = codec->codec_tag;
    2257             : 
    2258       26775 :     par->bit_rate              = codec->bit_rate;
    2259       26775 :     par->bits_per_coded_sample = codec->bits_per_coded_sample;
    2260       26775 :     par->bits_per_raw_sample   = codec->bits_per_raw_sample;
    2261       26775 :     par->profile               = codec->profile;
    2262       26775 :     par->level                 = codec->level;
    2263             : 
    2264       26775 :     switch (par->codec_type) {
    2265       21231 :     case AVMEDIA_TYPE_VIDEO:
    2266       21231 :         par->format              = codec->pix_fmt;
    2267       21231 :         par->width               = codec->width;
    2268       21231 :         par->height              = codec->height;
    2269       21231 :         par->field_order         = codec->field_order;
    2270       21231 :         par->color_range         = codec->color_range;
    2271       21231 :         par->color_primaries     = codec->color_primaries;
    2272       21231 :         par->color_trc           = codec->color_trc;
    2273       21231 :         par->color_space         = codec->colorspace;
    2274       21231 :         par->chroma_location     = codec->chroma_sample_location;
    2275       21231 :         par->sample_aspect_ratio = codec->sample_aspect_ratio;
    2276       21231 :         par->video_delay         = codec->has_b_frames;
    2277       21231 :         break;
    2278        5318 :     case AVMEDIA_TYPE_AUDIO:
    2279        5318 :         par->format           = codec->sample_fmt;
    2280        5318 :         par->channel_layout   = codec->channel_layout;
    2281        5318 :         par->channels         = codec->channels;
    2282        5318 :         par->sample_rate      = codec->sample_rate;
    2283        5318 :         par->block_align      = codec->block_align;
    2284        5318 :         par->frame_size       = codec->frame_size;
    2285        5318 :         par->initial_padding  = codec->initial_padding;
    2286        5318 :         par->trailing_padding = codec->trailing_padding;
    2287        5318 :         par->seek_preroll     = codec->seek_preroll;
    2288        5318 :         break;
    2289         122 :     case AVMEDIA_TYPE_SUBTITLE:
    2290         122 :         par->width  = codec->width;
    2291         122 :         par->height = codec->height;
    2292         122 :         break;
    2293             :     }
    2294             : 
    2295       26775 :     if (codec->extradata) {
    2296        4719 :         par->extradata = av_mallocz(codec->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
    2297        4719 :         if (!par->extradata)
    2298           0 :             return AVERROR(ENOMEM);
    2299        4719 :         memcpy(par->extradata, codec->extradata, codec->extradata_size);
    2300        4719 :         par->extradata_size = codec->extradata_size;
    2301             :     }
    2302             : 
    2303       26775 :     return 0;
    2304             : }
    2305             : 
    2306       42797 : int avcodec_parameters_to_context(AVCodecContext *codec,
    2307             :                                   const AVCodecParameters *par)
    2308             : {
    2309       42797 :     codec->codec_type = par->codec_type;
    2310       42797 :     codec->codec_id   = par->codec_id;
    2311       42797 :     codec->codec_tag  = par->codec_tag;
    2312             : 
    2313       42797 :     codec->bit_rate              = par->bit_rate;
    2314       42797 :     codec->bits_per_coded_sample = par->bits_per_coded_sample;
    2315       42797 :     codec->bits_per_raw_sample   = par->bits_per_raw_sample;
    2316       42797 :     codec->profile               = par->profile;
    2317       42797 :     codec->level                 = par->level;
    2318             : 
    2319       42797 :     switch (par->codec_type) {
    2320       31837 :     case AVMEDIA_TYPE_VIDEO:
    2321       31837 :         codec->pix_fmt                = par->format;
    2322       31837 :         codec->width                  = par->width;
    2323       31837 :         codec->height                 = par->height;
    2324       31837 :         codec->field_order            = par->field_order;
    2325       31837 :         codec->color_range            = par->color_range;
    2326       31837 :         codec->color_primaries        = par->color_primaries;
    2327       31837 :         codec->color_trc              = par->color_trc;
    2328       31837 :         codec->colorspace             = par->color_space;
    2329       31837 :         codec->chroma_sample_location = par->chroma_location;
    2330       31837 :         codec->sample_aspect_ratio    = par->sample_aspect_ratio;
    2331       31837 :         codec->has_b_frames           = par->video_delay;
    2332       31837 :         break;
    2333       10319 :     case AVMEDIA_TYPE_AUDIO:
    2334       10319 :         codec->sample_fmt       = par->format;
    2335       10319 :         codec->channel_layout   = par->channel_layout;
    2336       10319 :         codec->channels         = par->channels;
    2337       10319 :         codec->sample_rate      = par->sample_rate;
    2338       10319 :         codec->block_align      = par->block_align;
    2339       10319 :         codec->frame_size       = par->frame_size;
    2340       10319 :         codec->delay            =
    2341       10319 :         codec->initial_padding  = par->initial_padding;
    2342       10319 :         codec->trailing_padding = par->trailing_padding;
    2343       10319 :         codec->seek_preroll     = par->seek_preroll;
    2344       10319 :         break;
    2345         306 :     case AVMEDIA_TYPE_SUBTITLE:
    2346         306 :         codec->width  = par->width;
    2347         306 :         codec->height = par->height;
    2348         306 :         break;
    2349             :     }
    2350             : 
    2351       42797 :     if (par->extradata) {
    2352        6447 :         av_freep(&codec->extradata);
    2353        6447 :         codec->extradata = av_mallocz(par->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
    2354        6447 :         if (!codec->extradata)
    2355           0 :             return AVERROR(ENOMEM);
    2356        6447 :         memcpy(codec->extradata, par->extradata, par->extradata_size);
    2357        6447 :         codec->extradata_size = par->extradata_size;
    2358             :     }
    2359             : 
    2360       42797 :     return 0;
    2361             : }
    2362             : 
    2363           0 : int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
    2364             :                      void **data, size_t *sei_size)
    2365             : {
    2366           0 :     AVFrameSideData *side_data = NULL;
    2367             :     uint8_t *sei_data;
    2368             : 
    2369           0 :     if (frame)
    2370           0 :         side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC);
    2371             : 
    2372           0 :     if (!side_data) {
    2373           0 :         *data = NULL;
    2374           0 :         return 0;
    2375             :     }
    2376             : 
    2377           0 :     *sei_size = side_data->size + 11;
    2378           0 :     *data = av_mallocz(*sei_size + prefix_len);
    2379           0 :     if (!*data)
    2380           0 :         return AVERROR(ENOMEM);
    2381           0 :     sei_data = (uint8_t*)*data + prefix_len;
    2382             : 
    2383             :     // country code
    2384           0 :     sei_data[0] = 181;
    2385           0 :     sei_data[1] = 0;
    2386           0 :     sei_data[2] = 49;
    2387             : 
    2388             :     /**
    2389             :      * 'GA94' is standard in North America for ATSC, but hard coding
    2390             :      * this style may not be the right thing to do -- other formats
    2391             :      * do exist. This information is not available in the side_data
    2392             :      * so we are going with this right now.
    2393             :      */
    2394           0 :     AV_WL32(sei_data + 3, MKTAG('G', 'A', '9', '4'));
    2395           0 :     sei_data[7] = 3;
    2396           0 :     sei_data[8] = ((side_data->size/3) & 0x1f) | 0x40;
    2397           0 :     sei_data[9] = 0;
    2398             : 
    2399           0 :     memcpy(sei_data + 10, side_data->data, side_data->size);
    2400             : 
    2401           0 :     sei_data[side_data->size+10] = 255;
    2402             : 
    2403           0 :     return 0;
    2404             : }
    2405             : 
    2406        3715 : int64_t ff_guess_coded_bitrate(AVCodecContext *avctx)
    2407             : {
    2408        3715 :     AVRational framerate = avctx->framerate;
    2409        3715 :     int bits_per_coded_sample = avctx->bits_per_coded_sample;
    2410             :     int64_t bitrate;
    2411             : 
    2412        3715 :     if (!(framerate.num && framerate.den))
    2413           0 :         framerate = av_inv_q(avctx->time_base);
    2414        3715 :     if (!(framerate.num && framerate.den))
    2415           0 :         return 0;
    2416             : 
    2417        3715 :     if (!bits_per_coded_sample) {
    2418           0 :         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
    2419           0 :         bits_per_coded_sample = av_get_bits_per_pixel(desc);
    2420             :     }
    2421       11145 :     bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
    2422        7430 :               framerate.num / framerate.den;
    2423             : 
    2424        3715 :     return bitrate;
    2425             : }

Generated by: LCOV version 1.13