/libavcodec/utils.c
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