LCOV - code coverage report
Current view: top level - libavcodec - utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 891 1189 74.9 %
Date: 2018-05-20 11:54:08 Functions: 50 71 70.4 %

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

Generated by: LCOV version 1.13