PageRenderTime 113ms CodeModel.GetById 18ms app.highlight 82ms RepoModel.GetById 1ms app.codeStats 1ms

/libavcodec/utils.c

http://github.com/FFmpeg/FFmpeg
C | 2232 lines | 1905 code | 263 blank | 64 comment | 541 complexity | 893341df1c0bea69e93f31cb293fae31 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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 "hwconfig.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"
  66const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
  67
  68static AVMutex codec_mutex = AV_MUTEX_INITIALIZER;
  69
  70void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
  71{
  72    uint8_t **p = ptr;
  73    if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
  74        av_freep(p);
  75        *size = 0;
  76        return;
  77    }
  78    if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
  79        memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  80}
  81
  82void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
  83{
  84    uint8_t **p = ptr;
  85    if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
  86        av_freep(p);
  87        *size = 0;
  88        return;
  89    }
  90    if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
  91        memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
  92}
  93
  94int av_codec_is_encoder(const AVCodec *codec)
  95{
  96    return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
  97}
  98
  99int av_codec_is_decoder(const AVCodec *codec)
 100{
 101    return codec && (codec->decode || codec->receive_frame);
 102}
 103
 104int ff_set_dimensions(AVCodecContext *s, int width, int height)
 105{
 106    int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
 107
 108    if (ret < 0)
 109        width = height = 0;
 110
 111    s->coded_width  = width;
 112    s->coded_height = height;
 113    s->width        = AV_CEIL_RSHIFT(width,  s->lowres);
 114    s->height       = AV_CEIL_RSHIFT(height, s->lowres);
 115
 116    return ret;
 117}
 118
 119int ff_set_sar(AVCodecContext *avctx, AVRational sar)
 120{
 121    int ret = av_image_check_sar(avctx->width, avctx->height, sar);
 122
 123    if (ret < 0) {
 124        av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
 125               sar.num, sar.den);
 126        avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
 127        return ret;
 128    } else {
 129        avctx->sample_aspect_ratio = sar;
 130    }
 131    return 0;
 132}
 133
 134int ff_side_data_update_matrix_encoding(AVFrame *frame,
 135                                        enum AVMatrixEncoding matrix_encoding)
 136{
 137    AVFrameSideData *side_data;
 138    enum AVMatrixEncoding *data;
 139
 140    side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
 141    if (!side_data)
 142        side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
 143                                           sizeof(enum AVMatrixEncoding));
 144
 145    if (!side_data)
 146        return AVERROR(ENOMEM);
 147
 148    data  = (enum AVMatrixEncoding*)side_data->data;
 149    *data = matrix_encoding;
 150
 151    return 0;
 152}
 153
 154void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
 155                               int linesize_align[AV_NUM_DATA_POINTERS])
 156{
 157    int i;
 158    int w_align = 1;
 159    int h_align = 1;
 160    AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
 161
 162    if (desc) {
 163        w_align = 1 << desc->log2_chroma_w;
 164        h_align = 1 << desc->log2_chroma_h;
 165    }
 166
 167    switch (s->pix_fmt) {
 168    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_YUVA422P12LE:
 218    case AV_PIX_FMT_YUVA422P12BE:
 219    case AV_PIX_FMT_YUVA422P16LE:
 220    case AV_PIX_FMT_YUVA422P16BE:
 221    case AV_PIX_FMT_YUV440P10LE:
 222    case AV_PIX_FMT_YUV440P10BE:
 223    case AV_PIX_FMT_YUV440P12LE:
 224    case AV_PIX_FMT_YUV440P12BE:
 225    case AV_PIX_FMT_YUV444P9LE:
 226    case AV_PIX_FMT_YUV444P9BE:
 227    case AV_PIX_FMT_YUV444P10LE:
 228    case AV_PIX_FMT_YUV444P10BE:
 229    case AV_PIX_FMT_YUV444P12LE:
 230    case AV_PIX_FMT_YUV444P12BE:
 231    case AV_PIX_FMT_YUV444P14LE:
 232    case AV_PIX_FMT_YUV444P14BE:
 233    case AV_PIX_FMT_YUV444P16LE:
 234    case AV_PIX_FMT_YUV444P16BE:
 235    case AV_PIX_FMT_YUVA444P9LE:
 236    case AV_PIX_FMT_YUVA444P9BE:
 237    case AV_PIX_FMT_YUVA444P10LE:
 238    case AV_PIX_FMT_YUVA444P10BE:
 239    case AV_PIX_FMT_YUVA444P12LE:
 240    case AV_PIX_FMT_YUVA444P12BE:
 241    case AV_PIX_FMT_YUVA444P16LE:
 242    case AV_PIX_FMT_YUVA444P16BE:
 243    case AV_PIX_FMT_GBRP9LE:
 244    case AV_PIX_FMT_GBRP9BE:
 245    case AV_PIX_FMT_GBRP10LE:
 246    case AV_PIX_FMT_GBRP10BE:
 247    case AV_PIX_FMT_GBRP12LE:
 248    case AV_PIX_FMT_GBRP12BE:
 249    case AV_PIX_FMT_GBRP14LE:
 250    case AV_PIX_FMT_GBRP14BE:
 251    case AV_PIX_FMT_GBRP16LE:
 252    case AV_PIX_FMT_GBRP16BE:
 253    case AV_PIX_FMT_GBRAP12LE:
 254    case AV_PIX_FMT_GBRAP12BE:
 255    case AV_PIX_FMT_GBRAP16LE:
 256    case AV_PIX_FMT_GBRAP16BE:
 257        w_align = 16; //FIXME assume 16 pixel per macroblock
 258        h_align = 16 * 2; // interlaced needs 2 macroblocks height
 259        break;
 260    case AV_PIX_FMT_YUV411P:
 261    case AV_PIX_FMT_YUVJ411P:
 262    case AV_PIX_FMT_UYYVYY411:
 263        w_align = 32;
 264        h_align = 16 * 2;
 265        break;
 266    case AV_PIX_FMT_YUV410P:
 267        if (s->codec_id == AV_CODEC_ID_SVQ1) {
 268            w_align = 64;
 269            h_align = 64;
 270        }
 271        break;
 272    case AV_PIX_FMT_RGB555:
 273        if (s->codec_id == AV_CODEC_ID_RPZA) {
 274            w_align = 4;
 275            h_align = 4;
 276        }
 277        if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
 278            w_align = 8;
 279            h_align = 8;
 280        }
 281        break;
 282    case AV_PIX_FMT_PAL8:
 283    case AV_PIX_FMT_BGR8:
 284    case AV_PIX_FMT_RGB8:
 285        if (s->codec_id == AV_CODEC_ID_SMC ||
 286            s->codec_id == AV_CODEC_ID_CINEPAK) {
 287            w_align = 4;
 288            h_align = 4;
 289        }
 290        if (s->codec_id == AV_CODEC_ID_JV ||
 291            s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
 292            w_align = 8;
 293            h_align = 8;
 294        }
 295        break;
 296    case AV_PIX_FMT_BGR24:
 297        if ((s->codec_id == AV_CODEC_ID_MSZH) ||
 298            (s->codec_id == AV_CODEC_ID_ZLIB)) {
 299            w_align = 4;
 300            h_align = 4;
 301        }
 302        break;
 303    case AV_PIX_FMT_RGB24:
 304        if (s->codec_id == AV_CODEC_ID_CINEPAK) {
 305            w_align = 4;
 306            h_align = 4;
 307        }
 308        break;
 309    default:
 310        break;
 311    }
 312
 313    if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
 314        w_align = FFMAX(w_align, 8);
 315    }
 316
 317    *width  = FFALIGN(*width, w_align);
 318    *height = FFALIGN(*height, h_align);
 319    if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
 320        s->codec_id == AV_CODEC_ID_VP5  || s->codec_id == AV_CODEC_ID_VP6 ||
 321        s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A
 322    ) {
 323        // some of the optimized chroma MC reads one line too much
 324        // which is also done in mpeg decoders with lowres > 0
 325        *height += 2;
 326
 327        // H.264 uses edge emulation for out of frame motion vectors, for this
 328        // it requires a temporary area large enough to hold a 21x21 block,
 329        // increasing witdth ensure that the temporary area is large enough,
 330        // the next rounded up width is 32
 331        *width = FFMAX(*width, 32);
 332    }
 333
 334    for (i = 0; i < 4; i++)
 335        linesize_align[i] = STRIDE_ALIGN;
 336}
 337
 338void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
 339{
 340    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
 341    int chroma_shift = desc->log2_chroma_w;
 342    int linesize_align[AV_NUM_DATA_POINTERS];
 343    int align;
 344
 345    avcodec_align_dimensions2(s, width, height, linesize_align);
 346    align               = FFMAX(linesize_align[0], linesize_align[3]);
 347    linesize_align[1] <<= chroma_shift;
 348    linesize_align[2] <<= chroma_shift;
 349    align               = FFMAX3(align, linesize_align[1], linesize_align[2]);
 350    *width              = FFALIGN(*width, align);
 351}
 352
 353int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
 354{
 355    if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
 356        return AVERROR(EINVAL);
 357    pos--;
 358
 359    *xpos = (pos&1) * 128;
 360    *ypos = ((pos>>1)^(pos<4)) * 128;
 361
 362    return 0;
 363}
 364
 365enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
 366{
 367    int pos, xout, yout;
 368
 369    for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
 370        if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
 371            return pos;
 372    }
 373    return AVCHROMA_LOC_UNSPECIFIED;
 374}
 375
 376int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
 377                             enum AVSampleFormat sample_fmt, const uint8_t *buf,
 378                             int buf_size, int align)
 379{
 380    int ch, planar, needed_size, ret = 0;
 381
 382    needed_size = av_samples_get_buffer_size(NULL, nb_channels,
 383                                             frame->nb_samples, sample_fmt,
 384                                             align);
 385    if (buf_size < needed_size)
 386        return AVERROR(EINVAL);
 387
 388    planar = av_sample_fmt_is_planar(sample_fmt);
 389    if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
 390        if (!(frame->extended_data = av_mallocz_array(nb_channels,
 391                                                sizeof(*frame->extended_data))))
 392            return AVERROR(ENOMEM);
 393    } else {
 394        frame->extended_data = frame->data;
 395    }
 396
 397    if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
 398                                      (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
 399                                      sample_fmt, align)) < 0) {
 400        if (frame->extended_data != frame->data)
 401            av_freep(&frame->extended_data);
 402        return ret;
 403    }
 404    if (frame->extended_data != frame->data) {
 405        for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
 406            frame->data[ch] = frame->extended_data[ch];
 407    }
 408
 409    return ret;
 410}
 411
 412void ff_color_frame(AVFrame *frame, const int c[4])
 413{
 414    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
 415    int p, y;
 416
 417    av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
 418
 419    for (p = 0; p<desc->nb_components; p++) {
 420        uint8_t *dst = frame->data[p];
 421        int is_chroma = p == 1 || p == 2;
 422        int bytes  = is_chroma ? AV_CEIL_RSHIFT(frame->width,  desc->log2_chroma_w) : frame->width;
 423        int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
 424        if (desc->comp[0].depth >= 9) {
 425            ((uint16_t*)dst)[0] = c[p];
 426            av_memcpy_backptr(dst + 2, 2, bytes - 2);
 427            dst += frame->linesize[p];
 428            for (y = 1; y < height; y++) {
 429                memcpy(dst, frame->data[p], 2*bytes);
 430                dst += frame->linesize[p];
 431            }
 432        } else {
 433            for (y = 0; y < height; y++) {
 434                memset(dst, c[p], bytes);
 435                dst += frame->linesize[p];
 436            }
 437        }
 438    }
 439}
 440
 441int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
 442{
 443    int i;
 444
 445    for (i = 0; i < count; i++) {
 446        int r = func(c, (char *)arg + i * size);
 447        if (ret)
 448            ret[i] = r;
 449    }
 450    emms_c();
 451    return 0;
 452}
 453
 454int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
 455{
 456    int i;
 457
 458    for (i = 0; i < count; i++) {
 459        int r = func(c, arg, i, 0);
 460        if (ret)
 461            ret[i] = r;
 462    }
 463    emms_c();
 464    return 0;
 465}
 466
 467enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
 468                                       unsigned int fourcc)
 469{
 470    while (tags->pix_fmt >= 0) {
 471        if (tags->fourcc == fourcc)
 472            return tags->pix_fmt;
 473        tags++;
 474    }
 475    return AV_PIX_FMT_NONE;
 476}
 477
 478#if FF_API_CODEC_GET_SET
 479MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
 480MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
 481MAKE_ACCESSORS(AVCodecContext, codec, int, lowres)
 482MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
 483MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
 484
 485unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
 486{
 487    return codec->properties;
 488}
 489
 490int av_codec_get_max_lowres(const AVCodec *codec)
 491{
 492    return codec->max_lowres;
 493}
 494#endif
 495
 496int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec){
 497    return !!(codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM);
 498}
 499
 500static int64_t get_bit_rate(AVCodecContext *ctx)
 501{
 502    int64_t bit_rate;
 503    int bits_per_sample;
 504
 505    switch (ctx->codec_type) {
 506    case AVMEDIA_TYPE_VIDEO:
 507    case AVMEDIA_TYPE_DATA:
 508    case AVMEDIA_TYPE_SUBTITLE:
 509    case AVMEDIA_TYPE_ATTACHMENT:
 510        bit_rate = ctx->bit_rate;
 511        break;
 512    case AVMEDIA_TYPE_AUDIO:
 513        bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
 514        bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
 515        break;
 516    default:
 517        bit_rate = 0;
 518        break;
 519    }
 520    return bit_rate;
 521}
 522
 523
 524static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
 525{
 526    if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
 527        ff_mutex_lock(&codec_mutex);
 528}
 529
 530static void ff_unlock_avcodec(const AVCodec *codec)
 531{
 532    if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
 533        ff_mutex_unlock(&codec_mutex);
 534}
 535
 536int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
 537{
 538    int ret = 0;
 539
 540    ff_unlock_avcodec(codec);
 541
 542    ret = avcodec_open2(avctx, codec, options);
 543
 544    ff_lock_avcodec(avctx, codec);
 545    return ret;
 546}
 547
 548int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
 549{
 550    int ret = 0;
 551    int codec_init_ok = 0;
 552    AVDictionary *tmp = NULL;
 553    const AVPixFmtDescriptor *pixdesc;
 554    AVCodecInternal *avci;
 555
 556    if (avcodec_is_open(avctx))
 557        return 0;
 558
 559    if (!codec && !avctx->codec) {
 560        av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
 561        return AVERROR(EINVAL);
 562    }
 563    if (codec && avctx->codec && codec != avctx->codec) {
 564        av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
 565                                    "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
 566        return AVERROR(EINVAL);
 567    }
 568    if (!codec)
 569        codec = avctx->codec;
 570
 571    if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
 572        return AVERROR(EINVAL);
 573
 574    if (options)
 575        av_dict_copy(&tmp, *options, 0);
 576
 577    ff_lock_avcodec(avctx, codec);
 578
 579    avci = av_mallocz(sizeof(*avci));
 580    if (!avci) {
 581        ret = AVERROR(ENOMEM);
 582        goto end;
 583    }
 584    avctx->internal = avci;
 585
 586    avci->to_free = av_frame_alloc();
 587    avci->compat_decode_frame = av_frame_alloc();
 588    avci->buffer_frame = av_frame_alloc();
 589    avci->buffer_pkt = av_packet_alloc();
 590    avci->ds.in_pkt = av_packet_alloc();
 591    avci->last_pkt_props = av_packet_alloc();
 592    if (!avci->to_free      || !avci->compat_decode_frame ||
 593        !avci->buffer_frame || !avci->buffer_pkt          ||
 594        !avci->ds.in_pkt    || !avci->last_pkt_props) {
 595        ret = AVERROR(ENOMEM);
 596        goto free_and_end;
 597    }
 598
 599    avci->skip_samples_multiplier = 1;
 600
 601    if (codec->priv_data_size > 0) {
 602        if (!avctx->priv_data) {
 603            avctx->priv_data = av_mallocz(codec->priv_data_size);
 604            if (!avctx->priv_data) {
 605                ret = AVERROR(ENOMEM);
 606                goto end;
 607            }
 608            if (codec->priv_class) {
 609                *(const AVClass **)avctx->priv_data = codec->priv_class;
 610                av_opt_set_defaults(avctx->priv_data);
 611            }
 612        }
 613        if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
 614            goto free_and_end;
 615    } else {
 616        avctx->priv_data = NULL;
 617    }
 618    if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
 619        goto free_and_end;
 620
 621    if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
 622        av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
 623        ret = AVERROR(EINVAL);
 624        goto free_and_end;
 625    }
 626
 627    // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
 628    if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
 629          (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
 630        if (avctx->coded_width && avctx->coded_height)
 631            ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
 632        else if (avctx->width && avctx->height)
 633            ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
 634        if (ret < 0)
 635            goto free_and_end;
 636    }
 637
 638    if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
 639        && (  av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
 640           || av_image_check_size2(avctx->width,       avctx->height,       avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
 641        av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
 642        ff_set_dimensions(avctx, 0, 0);
 643    }
 644
 645    if (avctx->width > 0 && avctx->height > 0) {
 646        if (av_image_check_sar(avctx->width, avctx->height,
 647                               avctx->sample_aspect_ratio) < 0) {
 648            av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
 649                   avctx->sample_aspect_ratio.num,
 650                   avctx->sample_aspect_ratio.den);
 651            avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
 652        }
 653    }
 654
 655    /* if the decoder init function was already called previously,
 656     * free the already allocated subtitle_header before overwriting it */
 657    if (av_codec_is_decoder(codec))
 658        av_freep(&avctx->subtitle_header);
 659
 660    if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
 661        av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
 662        ret = AVERROR(EINVAL);
 663        goto free_and_end;
 664    }
 665    if (avctx->sample_rate < 0) {
 666        av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
 667        ret = AVERROR(EINVAL);
 668        goto free_and_end;
 669    }
 670    if (avctx->block_align < 0) {
 671        av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
 672        ret = AVERROR(EINVAL);
 673        goto free_and_end;
 674    }
 675
 676    avctx->codec = codec;
 677    if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
 678        avctx->codec_id == AV_CODEC_ID_NONE) {
 679        avctx->codec_type = codec->type;
 680        avctx->codec_id   = codec->id;
 681    }
 682    if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
 683                                         && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
 684        av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
 685        ret = AVERROR(EINVAL);
 686        goto free_and_end;
 687    }
 688    avctx->frame_number = 0;
 689    avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
 690
 691    if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
 692        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 693        const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
 694        AVCodec *codec2;
 695        av_log(avctx, AV_LOG_ERROR,
 696               "The %s '%s' is experimental but experimental codecs are not enabled, "
 697               "add '-strict %d' if you want to use it.\n",
 698               codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
 699        codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
 700        if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
 701            av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
 702                codec_string, codec2->name);
 703        ret = AVERROR_EXPERIMENTAL;
 704        goto free_and_end;
 705    }
 706
 707    if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
 708        (!avctx->time_base.num || !avctx->time_base.den)) {
 709        avctx->time_base.num = 1;
 710        avctx->time_base.den = avctx->sample_rate;
 711    }
 712
 713    if (!HAVE_THREADS)
 714        av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
 715
 716    if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
 717        ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
 718        ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
 719        ff_lock_avcodec(avctx, codec);
 720        if (ret < 0)
 721            goto free_and_end;
 722    }
 723
 724    if (av_codec_is_decoder(avctx->codec)) {
 725        ret = ff_decode_bsfs_init(avctx);
 726        if (ret < 0)
 727            goto free_and_end;
 728    }
 729
 730    if (HAVE_THREADS
 731        && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
 732        ret = ff_thread_init(avctx);
 733        if (ret < 0) {
 734            goto free_and_end;
 735        }
 736    }
 737    if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
 738        avctx->thread_count = 1;
 739
 740    if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
 741        av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
 742               avctx->codec->max_lowres);
 743        avctx->lowres = avctx->codec->max_lowres;
 744    }
 745
 746    if (av_codec_is_encoder(avctx->codec)) {
 747        int i;
 748#if FF_API_CODED_FRAME
 749FF_DISABLE_DEPRECATION_WARNINGS
 750        avctx->coded_frame = av_frame_alloc();
 751        if (!avctx->coded_frame) {
 752            ret = AVERROR(ENOMEM);
 753            goto free_and_end;
 754        }
 755FF_ENABLE_DEPRECATION_WARNINGS
 756#endif
 757
 758        if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
 759            av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
 760            ret = AVERROR(EINVAL);
 761            goto free_and_end;
 762        }
 763
 764        if (avctx->codec->sample_fmts) {
 765            for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
 766                if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
 767                    break;
 768                if (avctx->channels == 1 &&
 769                    av_get_planar_sample_fmt(avctx->sample_fmt) ==
 770                    av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
 771                    avctx->sample_fmt = avctx->codec->sample_fmts[i];
 772                    break;
 773                }
 774            }
 775            if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
 776                char buf[128];
 777                snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
 778                av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
 779                       (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
 780                ret = AVERROR(EINVAL);
 781                goto free_and_end;
 782            }
 783        }
 784        if (avctx->codec->pix_fmts) {
 785            for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
 786                if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
 787                    break;
 788            if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
 789                && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
 790                     && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
 791                char buf[128];
 792                snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
 793                av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
 794                       (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
 795                ret = AVERROR(EINVAL);
 796                goto free_and_end;
 797            }
 798            if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
 799                avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
 800                avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
 801                avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
 802                avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
 803                avctx->color_range = AVCOL_RANGE_JPEG;
 804        }
 805        if (avctx->codec->supported_samplerates) {
 806            for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
 807                if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
 808                    break;
 809            if (avctx->codec->supported_samplerates[i] == 0) {
 810                av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 811                       avctx->sample_rate);
 812                ret = AVERROR(EINVAL);
 813                goto free_and_end;
 814            }
 815        }
 816        if (avctx->sample_rate < 0) {
 817            av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 818                    avctx->sample_rate);
 819            ret = AVERROR(EINVAL);
 820            goto free_and_end;
 821        }
 822        if (avctx->codec->channel_layouts) {
 823            if (!avctx->channel_layout) {
 824                av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
 825            } else {
 826                for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
 827                    if (avctx->channel_layout == avctx->codec->channel_layouts[i])
 828                        break;
 829                if (avctx->codec->channel_layouts[i] == 0) {
 830                    char buf[512];
 831                    av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 832                    av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
 833                    ret = AVERROR(EINVAL);
 834                    goto free_and_end;
 835                }
 836            }
 837        }
 838        if (avctx->channel_layout && avctx->channels) {
 839            int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 840            if (channels != avctx->channels) {
 841                char buf[512];
 842                av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 843                av_log(avctx, AV_LOG_ERROR,
 844                       "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
 845                       buf, channels, avctx->channels);
 846                ret = AVERROR(EINVAL);
 847                goto free_and_end;
 848            }
 849        } else if (avctx->channel_layout) {
 850            avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 851        }
 852        if (avctx->channels < 0) {
 853            av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
 854                    avctx->channels);
 855            ret = AVERROR(EINVAL);
 856            goto free_and_end;
 857        }
 858        if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 859            pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
 860            if (    avctx->bits_per_raw_sample < 0
 861                || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
 862                av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
 863                    avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
 864                avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
 865            }
 866            if (avctx->width <= 0 || avctx->height <= 0) {
 867                av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
 868                ret = AVERROR(EINVAL);
 869                goto free_and_end;
 870            }
 871        }
 872        if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
 873            && avctx->bit_rate>0 && avctx->bit_rate<1000) {
 874            av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
 875        }
 876
 877        if (!avctx->rc_initial_buffer_occupancy)
 878            avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
 879
 880        if (avctx->ticks_per_frame && avctx->time_base.num &&
 881            avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
 882            av_log(avctx, AV_LOG_ERROR,
 883                   "ticks_per_frame %d too large for the timebase %d/%d.",
 884                   avctx->ticks_per_frame,
 885                   avctx->time_base.num,
 886                   avctx->time_base.den);
 887            goto free_and_end;
 888        }
 889
 890        if (avctx->hw_frames_ctx) {
 891            AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
 892            if (frames_ctx->format != avctx->pix_fmt) {
 893                av_log(avctx, AV_LOG_ERROR,
 894                       "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
 895                ret = AVERROR(EINVAL);
 896                goto free_and_end;
 897            }
 898            if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
 899                avctx->sw_pix_fmt != frames_ctx->sw_format) {
 900                av_log(avctx, AV_LOG_ERROR,
 901                       "Mismatching AVCodecContext.sw_pix_fmt (%s) "
 902                       "and AVHWFramesContext.sw_format (%s)\n",
 903                       av_get_pix_fmt_name(avctx->sw_pix_fmt),
 904                       av_get_pix_fmt_name(frames_ctx->sw_format));
 905                ret = AVERROR(EINVAL);
 906                goto free_and_end;
 907            }
 908            avctx->sw_pix_fmt = frames_ctx->sw_format;
 909        }
 910    }
 911
 912    avctx->pts_correction_num_faulty_pts =
 913    avctx->pts_correction_num_faulty_dts = 0;
 914    avctx->pts_correction_last_pts =
 915    avctx->pts_correction_last_dts = INT64_MIN;
 916
 917    if (   !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
 918        && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
 919        av_log(avctx, AV_LOG_WARNING,
 920               "gray decoding requested but not enabled at configuration time\n");
 921    if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
 922        avctx->export_side_data |= AV_CODEC_EXPORT_DATA_MVS;
 923    }
 924
 925    if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
 926        || avci->frame_thread_encoder)) {
 927        ret = avctx->codec->init(avctx);
 928        if (ret < 0) {
 929            goto free_and_end;
 930        }
 931        codec_init_ok = 1;
 932    }
 933
 934    ret=0;
 935
 936    if (av_codec_is_decoder(avctx->codec)) {
 937        if (!avctx->bit_rate)
 938            avctx->bit_rate = get_bit_rate(avctx);
 939        /* validate channel layout from the decoder */
 940        if (avctx->channel_layout) {
 941            int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 942            if (!avctx->channels)
 943                avctx->channels = channels;
 944            else if (channels != avctx->channels) {
 945                char buf[512];
 946                av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 947                av_log(avctx, AV_LOG_WARNING,
 948                       "Channel layout '%s' with %d channels does not match specified number of channels %d: "
 949                       "ignoring specified channel layout\n",
 950                       buf, channels, avctx->channels);
 951                avctx->channel_layout = 0;
 952            }
 953        }
 954        if (avctx->channels && avctx->channels < 0 ||
 955            avctx->channels > FF_SANE_NB_CHANNELS) {
 956            ret = AVERROR(EINVAL);
 957            goto free_and_end;
 958        }
 959        if (avctx->bits_per_coded_sample < 0) {
 960            ret = AVERROR(EINVAL);
 961            goto free_and_end;
 962        }
 963        if (avctx->sub_charenc) {
 964            if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
 965                av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
 966                       "supported with subtitles codecs\n");
 967                ret = AVERROR(EINVAL);
 968                goto free_and_end;
 969            } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
 970                av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
 971                       "subtitles character encoding will be ignored\n",
 972                       avctx->codec_descriptor->name);
 973                avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
 974            } else {
 975                /* input character encoding is set for a text based subtitle
 976                 * codec at this point */
 977                if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
 978                    avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
 979
 980                if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
 981#if CONFIG_ICONV
 982                    iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
 983                    if (cd == (iconv_t)-1) {
 984                        ret = AVERROR(errno);
 985                        av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
 986                               "with input character encoding \"%s\"\n", avctx->sub_charenc);
 987                        goto free_and_end;
 988                    }
 989                    iconv_close(cd);
 990#else
 991                    av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
 992                           "conversion needs a libavcodec built with iconv support "
 993                           "for this codec\n");
 994                    ret = AVERROR(ENOSYS);
 995                    goto free_and_end;
 996#endif
 997                }
 998            }
 999        }
1000
1001#if FF_API_AVCTX_TIMEBASE
1002        if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1003            avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1004#endif
1005    }
1006    if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1007        av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1008    }
1009
1010end:
1011    ff_unlock_avcodec(codec);
1012    if (options) {
1013        av_dict_free(options);
1014        *options = tmp;
1015    }
1016
1017    return ret;
1018free_and_end:
1019    if (avctx->codec && avctx->codec->close &&
1020        (codec_init_ok ||
1021         (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)))
1022        avctx->codec->close(avctx);
1023
1024    if (HAVE_THREADS && avci->thread_ctx)
1025        ff_thread_free(avctx);
1026
1027    if (codec->priv_class && codec->priv_data_size)
1028        av_opt_free(avctx->priv_data);
1029    av_opt_free(avctx);
1030
1031#if FF_API_CODED_FRAME
1032FF_DISABLE_DEPRECATION_WARNINGS
1033    av_frame_free(&avctx->coded_frame);
1034FF_ENABLE_DEPRECATION_WARNINGS
1035#endif
1036
1037    av_dict_free(&tmp);
1038    av_freep(&avctx->priv_data);
1039    av_freep(&avctx->subtitle_header);
1040    if (avci) {
1041        av_frame_free(&avci->to_free);
1042        av_frame_free(&avci->compat_decode_frame);
1043        av_frame_free(&avci->buffer_frame);
1044        av_packet_free(&avci->buffer_pkt);
1045        av_packet_free(&avci->last_pkt_props);
1046
1047        av_packet_free(&avci->ds.in_pkt);
1048        ff_decode_bsfs_uninit(avctx);
1049
1050        av_buffer_unref(&avci->pool);
1051    }
1052    av_freep(&avci);
1053    avctx->internal = NULL;
1054    avctx->codec = NULL;
1055    goto end;
1056}
1057
1058void avsubtitle_free(AVSubtitle *sub)
1059{
1060    int i;
1061
1062    for (i = 0; i < sub->num_rects; i++) {
1063        av_freep(&sub->rects[i]->data[0]);
1064        av_freep(&sub->rects[i]->data[1]);
1065        av_freep(&sub->rects[i]->data[2]);
1066        av_freep(&sub->rects[i]->data[3]);
1067        av_freep(&sub->rects[i]->text);
1068        av_freep(&sub->rects[i]->ass);
1069        av_freep(&sub->rects[i]);
1070    }
1071
1072    av_freep(&sub->rects);
1073
1074    memset(sub, 0, sizeof(*sub));
1075}
1076
1077av_cold int avcodec_close(AVCodecContext *avctx)
1078{
1079    int i;
1080
1081    if (!avctx)
1082        return 0;
1083
1084    if (avcodec_is_open(avctx)) {
1085        if (CONFIG_FRAME_THREAD_ENCODER &&
1086            avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1087            ff_frame_thread_encoder_free(avctx);
1088        }
1089        if (HAVE_THREADS && avctx->internal->thread_ctx)
1090            ff_thread_free(avctx);
1091        if (avctx->codec && avctx->codec->close)
1092            avctx->codec->close(avctx);
1093        avctx->internal->byte_buffer_size = 0;
1094        av_freep(&avctx->internal->byte_buffer);
1095        av_frame_free(&avctx->internal->to_free);
1096        av_frame_free(&avctx->internal->compat_decode_frame);
1097        av_frame_free(&avctx->internal->buffer_frame);
1098        av_packet_free(&avctx->internal->buffer_pkt);
1099        av_packet_free(&avctx->internal->last_pkt_props);
1100
1101        av_packet_free(&avctx->internal->ds.in_pkt);
1102
1103        av_buffer_unref(&avctx->internal->pool);
1104
1105        if (avctx->hwaccel && avctx->hwaccel->uninit)
1106            avctx->hwaccel->uninit(avctx);
1107        av_freep(&avctx->internal->hwaccel_priv_data);
1108
1109        ff_decode_bsfs_uninit(avctx);
1110
1111        av_freep(&avctx->internal);
1112    }
1113
1114    for (i = 0; i < avctx->nb_coded_side_data; i++)
1115        av_freep(&avctx->coded_side_data[i].data);
1116    av_freep(&avctx->coded_side_data);
1117    avctx->nb_coded_side_data = 0;
1118
1119    av_buffer_unref(&avctx->hw_frames_ctx);
1120    av_buffer_unref(&avctx->hw_device_ctx);
1121
1122    if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1123        av_opt_free(avctx->priv_data);
1124    av_opt_free(avctx);
1125    av_freep(&avctx->priv_data);
1126    if (av_codec_is_encoder(avctx->codec)) {
1127        av_freep(&avctx->extradata);
1128#if FF_API_CODED_FRAME
1129FF_DISABLE_DEPRECATION_WARNINGS
1130        av_frame_free(&avctx->coded_frame);
1131FF_ENABLE_DEPRECATION_WARNINGS
1132#endif
1133    }
1134    avctx->codec = NULL;
1135    avctx->active_thread_type = 0;
1136
1137    return 0;
1138}
1139
1140const char *avcodec_get_name(enum AVCodecID id)
1141{
1142    const AVCodecDescriptor *cd;
1143    AVCodec *codec;
1144
1145    if (id == AV_CODEC_ID_NONE)
1146        return "none";
1147    cd = avcodec_descriptor_get(id);
1148    if (cd)
1149        return cd->name;
1150    av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1151    codec = avcodec_find_decoder(id);
1152    if (codec)
1153        return codec->name;
1154    codec = avcodec_find_encoder(id);
1155    if (codec)
1156        return codec->name;
1157    return "unknown_codec";
1158}
1159
1160size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1161{
1162    int i, len, ret = 0;
1163
1164#define TAG_PRINT(x)                                              \
1165    (((x) >= '0' && (x) <= '9') ||                                \
1166     ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') ||  \
1167     ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1168
1169    for (i = 0; i < 4; i++) {
1170        len = snprintf(buf, buf_size,
1171                       TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1172        buf        += len;
1173        buf_size    = buf_size > len ? buf_size - len : 0;
1174        ret        += len;
1175        codec_tag >>= 8;
1176    }
1177    return ret;
1178}
1179
1180void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1181{
1182    const char *codec_type;
1183    const char *codec_name;
1184    const char *profile = NULL;
1185    int64_t bitrate;
1186    int new_line = 0;
1187    AVRational display_aspect_ratio;
1188    const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1189
1190    if (!buf || buf_size <= 0)
1191        return;
1192    codec_type = av_get_media_type_string(enc->codec_type);
1193    codec_name = avcodec_get_name(enc->codec_id);
1194    profile = avcodec_profile_name(enc->codec_id, enc->profile);
1195
1196    snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1197             codec_name);
1198    buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1199
1200    if (enc->codec && strcmp(enc->codec->name, codec_name))
1201        snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1202
1203    if (profile)
1204        snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1205    if (   enc->codec_type == AVMEDIA_TYPE_VIDEO
1206        && av_log_get_level() >= AV_LOG_VERBOSE
1207        && enc->refs)
1208        snprintf(buf + strlen(buf), buf_size - strlen(buf),
1209                 ", %d reference frame%s",
1210                 enc->refs, enc->refs > 1 ? "s" : "");
1211
1212    if (enc->codec_tag)
1213        snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1214                 av_fourcc2str(enc->codec_tag), enc->codec_tag);
1215
1216    switch (enc->codec_type) {
1217    case AVMEDIA_TYPE_VIDEO:
1218        {
1219            char detail[256] = "(";
1220
1221            av_strlcat(buf, separator, buf_size);
1222
1223            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1224                 "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1225                     av_get_pix_fmt_name(enc->pix_fmt));
1226            if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1227                enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
1228                av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1229            if (enc->color_range != AVCOL_RANGE_UNSPECIFIED)
1230                av_strlcatf(detail, sizeof(detail), "%s, ",
1231                            av_color_range_name(enc->color_range));
1232
1233            if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1234                enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
1235                enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1236                if (enc->colorspace != (int)enc->color_primaries ||
1237                    enc->colorspace != (int)enc->color_trc) {
1238                    new_line = 1;
1239                    av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1240                                av_color_space_name(enc->colorspace),
1241                                av_color_primaries_name(enc->color_primaries),
1242                                av_color_transfer_name(enc->color_trc));
1243                } else
1244                    av_strlcatf(detail, sizeof(detail), "%s, ",
1245                                av_get_colorspace_name(enc->colorspace));
1246            }
1247
1248            if (enc->field_order != AV_FIELD_UNKNOWN) {
1249                const char *field_order = "progressive";
1250                if (enc->field_order == AV_FIELD_TT)
1251                    field_order = "top first";
1252                else if (enc->field_order == AV_FIELD_BB)
1253                    field_order = "bottom first";
1254                else if (enc->field_order == AV_FIELD_TB)
1255                    field_order = "top coded first (swapped)";
1256                else if (enc->field_order == AV_FIELD_BT)
1257                    field_order = "bottom coded first (swapped)";
1258
1259                av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1260            }
1261
1262            if (av_log_get_level() >= AV_LOG_VERBOSE &&
1263                enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
1264                av_strlcatf(detail, sizeof(detail), "%s, ",
1265                            av_chroma_location_name(enc->chroma_sample_location));
1266
1267            if (strlen(detail) > 1) {
1268                detail[strlen(detail) - 2] = 0;
1269                av_strlcatf(buf, buf_size, "%s)", detail);
1270            }
1271        }
1272
1273        if (enc->width) {
1274            av_strlcat(buf, new_line ? separator : ", ", buf_size);
1275
1276            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1277                     "%dx%d",
1278                     enc->width, enc->height);
1279
1280            if (av_log_get_level() >= AV_LOG_VERBOSE &&
1281                (enc->width != enc->coded_width ||
1282                 enc->height != enc->coded_height))
1283                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1284                         " (%dx%d)", enc->coded_width, enc->coded_height);
1285
1286            if (enc->sample_aspect_ratio.num) {
1287                av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1288                          enc->width * (int64_t)enc->sample_aspect_ratio.num,
1289                          enc->height * (int64_t)enc->sample_aspect_ratio.den,
1290                          1024 * 1024);
1291                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1292                         " [SAR %d:%d DAR %d:%d]",
1293                         enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
1294                         display_aspect_ratio.num, display_aspect_ratio.den);
1295            }
1296            if (av_log_get_level() >= AV_LOG_DEBUG) {
1297                int g = av_gcd(enc->time_base.num, enc->time_base.den);
1298                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1299                         ", %d/%d",
1300                         enc->time_base.num / g, enc->time_base.den / g);
1301            }
1302        }
1303        if (encode) {
1304            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1305                     ", q=%d-%d", enc->qmin, enc->qmax);
1306        } else {
1307            if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
1308                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1309                         ", Closed Captions");
1310            if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
1311                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1312                         ", lossless");
1313        }
1314        break;
1315    case AVMEDIA_TYPE_AUDIO:
1316        av_strlcat(buf, separator, buf_size);
1317
1318        if (enc->sample_rate) {
1319            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1320                     "%d Hz, ", enc->sample_rate);
1321        }
1322        av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1323        if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1324            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1325                     ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1326        }
1327        if (   enc->bits_per_raw_sample > 0
1328            && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
1329            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1330                     " (%d bit)", enc->bits_per_raw_sample);
1331        if (av_log_get_level() >= AV_LOG_VERBOSE) {
1332            if (enc->initial_padding)
1333                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1334                         ", delay %d", enc->initial_padding);
1335            if (enc->trailing_padding)
1336                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1337                         ", padding %d", enc->trailing_padding);
1338        }
1339        break;
1340    case AVMEDIA_TYPE_DATA:
1341        if (av_log_get_level() >= AV_LOG_DEBUG) {
1342            int g = av_gcd(enc->time_base.num, enc->time_base.den);
1343            if (g)
1344                snprintf(buf + strlen(buf), buf_size - strlen(buf),
1345                         ", %d/%d",
1346                         enc->time_base.num / g, enc->time_base.den / g);
1347        }
1348        break;
1349    case AVMEDIA_TYPE_SUBTITLE:
1350        if (enc->width)
1351            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1352                     ", %dx%d", enc->width, enc->height);
1353        break;
1354    default:
1355        return;
1356    }
1357    if (encode) {
1358        if (enc->flags & AV_CODEC_FLAG_PASS1)
1359            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1360                     ", pass 1");
1361        if (enc->flags & AV_CODEC_FLAG_PASS2)
1362            snprintf(buf + strlen(buf), buf_size - strlen(buf),
1363                     ", pass 2");
1364    }
1365    bitrate = get_bit_rate(enc);
1366    if (bitrate != 0) {
1367        snprintf(buf + st

Large files files are truncated, but you can click here to view the full file