avcodec.c (29509B)
1 /* 2 * AVCodecContext functions for libavcodec 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21 /** 22 * @file 23 * AVCodecContext functions for libavcodec 24 */ 25 26 #include "config.h" 27 #include "libavutil/avassert.h" 28 #include "libavutil/avstring.h" 29 #include "libavutil/bprint.h" 30 #include "libavutil/channel_layout.h" 31 #include "libavutil/common.h" 32 #include "libavutil/emms.h" 33 #include "libavutil/fifo.h" 34 #include "libavutil/imgutils.h" 35 #include "libavutil/mem.h" 36 #include "libavutil/opt.h" 37 #include "libavutil/thread.h" 38 #include "avcodec.h" 39 #include "avcodec_internal.h" 40 #include "bsf.h" 41 #include "codec_desc.h" 42 #include "codec_internal.h" 43 #include "decode.h" 44 #include "encode.h" 45 #include "frame_thread_encoder.h" 46 #include "hwconfig.h" 47 #include "internal.h" 48 #include "libavutil/refstruct.h" 49 #include "thread.h" 50 51 /** 52 * Maximum size in bytes of extradata. 53 * This value was chosen such that every bit of the buffer is 54 * addressable by a 32-bit signed integer as used by get_bits. 55 */ 56 #define FF_MAX_EXTRADATA_SIZE ((1 << 28) - AV_INPUT_BUFFER_PADDING_SIZE) 57 58 const SideDataMap ff_sd_global_map[] = { 59 { AV_PKT_DATA_REPLAYGAIN , AV_FRAME_DATA_REPLAYGAIN }, 60 { AV_PKT_DATA_DISPLAYMATRIX, AV_FRAME_DATA_DISPLAYMATRIX }, 61 { AV_PKT_DATA_SPHERICAL, AV_FRAME_DATA_SPHERICAL }, 62 { AV_PKT_DATA_STEREO3D, AV_FRAME_DATA_STEREO3D }, 63 { AV_PKT_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_AUDIO_SERVICE_TYPE }, 64 { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA }, 65 { AV_PKT_DATA_CONTENT_LIGHT_LEVEL, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL }, 66 { AV_PKT_DATA_ICC_PROFILE, AV_FRAME_DATA_ICC_PROFILE }, 67 { AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT }, 68 { AV_PKT_DATA_NB }, 69 }; 70 71 72 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size) 73 { 74 size_t i; 75 76 for (i = 0; i < count; i++) { 77 size_t offset = i * size; 78 int r = func(c, FF_PTR_ADD((char *)arg, offset)); 79 if (ret) 80 ret[i] = r; 81 } 82 emms_c(); 83 return 0; 84 } 85 86 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count) 87 { 88 int i; 89 90 for (i = 0; i < count; i++) { 91 int r = func(c, arg, i, 0); 92 if (ret) 93 ret[i] = r; 94 } 95 emms_c(); 96 return 0; 97 } 98 99 static AVMutex codec_mutex = AV_MUTEX_INITIALIZER; 100 101 static void lock_avcodec(const FFCodec *codec) 102 { 103 if (codec->caps_internal & FF_CODEC_CAP_NOT_INIT_THREADSAFE && codec->init) 104 ff_mutex_lock(&codec_mutex); 105 } 106 107 static void unlock_avcodec(const FFCodec *codec) 108 { 109 if (codec->caps_internal & FF_CODEC_CAP_NOT_INIT_THREADSAFE && codec->init) 110 ff_mutex_unlock(&codec_mutex); 111 } 112 113 static int64_t get_bit_rate(AVCodecContext *ctx) 114 { 115 int64_t bit_rate; 116 int bits_per_sample; 117 118 switch (ctx->codec_type) { 119 case AVMEDIA_TYPE_VIDEO: 120 case AVMEDIA_TYPE_DATA: 121 case AVMEDIA_TYPE_SUBTITLE: 122 case AVMEDIA_TYPE_ATTACHMENT: 123 bit_rate = ctx->bit_rate; 124 break; 125 case AVMEDIA_TYPE_AUDIO: 126 bits_per_sample = av_get_bits_per_sample(ctx->codec_id); 127 if (bits_per_sample) { 128 bit_rate = ctx->sample_rate * (int64_t)ctx->ch_layout.nb_channels; 129 if (bit_rate > INT64_MAX / bits_per_sample) { 130 bit_rate = 0; 131 } else 132 bit_rate *= bits_per_sample; 133 } else 134 bit_rate = ctx->bit_rate; 135 break; 136 default: 137 bit_rate = 0; 138 break; 139 } 140 return bit_rate; 141 } 142 143 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options) 144 { 145 int ret = 0; 146 AVCodecInternal *avci; 147 const FFCodec *codec2; 148 const AVDictionaryEntry *e; 149 150 if (avcodec_is_open(avctx)) 151 return 0; 152 153 if (!codec && !avctx->codec) { 154 av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n"); 155 return AVERROR(EINVAL); 156 } 157 if (codec && avctx->codec && codec != avctx->codec) { 158 av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, " 159 "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name); 160 return AVERROR(EINVAL); 161 } 162 if (!codec) 163 codec = avctx->codec; 164 codec2 = ffcodec(codec); 165 166 if ((avctx->codec_type != AVMEDIA_TYPE_UNKNOWN && avctx->codec_type != codec->type) || 167 (avctx->codec_id != AV_CODEC_ID_NONE && avctx->codec_id != codec->id)) { 168 av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n"); 169 return AVERROR(EINVAL); 170 } 171 172 avctx->codec_type = codec->type; 173 avctx->codec_id = codec->id; 174 avctx->codec = codec; 175 176 if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE) 177 return AVERROR(EINVAL); 178 179 // set the whitelist from provided options dict, 180 // so we can check it immediately 181 e = options ? av_dict_get(*options, "codec_whitelist", NULL, 0) : NULL; 182 if (e) { 183 ret = av_opt_set(avctx, e->key, e->value, 0); 184 if (ret < 0) 185 return ret; 186 } 187 188 if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) { 189 av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist); 190 return AVERROR(EINVAL); 191 } 192 193 avci = av_codec_is_decoder(codec) ? 194 ff_decode_internal_alloc() : 195 ff_encode_internal_alloc(); 196 if (!avci) { 197 ret = AVERROR(ENOMEM); 198 goto end; 199 } 200 avctx->internal = avci; 201 202 avci->buffer_frame = av_frame_alloc(); 203 avci->buffer_pkt = av_packet_alloc(); 204 if (!avci->buffer_frame || !avci->buffer_pkt) { 205 ret = AVERROR(ENOMEM); 206 goto free_and_end; 207 } 208 209 if (codec2->priv_data_size > 0) { 210 if (!avctx->priv_data) { 211 avctx->priv_data = av_mallocz(codec2->priv_data_size); 212 if (!avctx->priv_data) { 213 ret = AVERROR(ENOMEM); 214 goto free_and_end; 215 } 216 if (codec->priv_class) { 217 *(const AVClass **)avctx->priv_data = codec->priv_class; 218 av_opt_set_defaults(avctx->priv_data); 219 } 220 } 221 } else { 222 avctx->priv_data = NULL; 223 } 224 225 ret = av_opt_set_dict2(avctx, options, AV_OPT_SEARCH_CHILDREN); 226 if (ret < 0) 227 goto free_and_end; 228 229 // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions 230 if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && 231 (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) { 232 if (avctx->coded_width && avctx->coded_height) 233 ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height); 234 else if (avctx->width && avctx->height) 235 ret = ff_set_dimensions(avctx, avctx->width, avctx->height); 236 if (ret < 0) 237 goto free_and_end; 238 } 239 240 if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height) 241 && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0 242 || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) { 243 av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n"); 244 ff_set_dimensions(avctx, 0, 0); 245 } 246 247 if (avctx->width > 0 && avctx->height > 0) { 248 if (av_image_check_sar(avctx->width, avctx->height, 249 avctx->sample_aspect_ratio) < 0) { 250 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n", 251 avctx->sample_aspect_ratio.num, 252 avctx->sample_aspect_ratio.den); 253 avctx->sample_aspect_ratio = (AVRational){ 0, 1 }; 254 } 255 } 256 257 if (avctx->sample_rate < 0) { 258 av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate); 259 ret = AVERROR(EINVAL); 260 goto free_and_end; 261 } 262 if (avctx->block_align < 0) { 263 av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align); 264 ret = AVERROR(EINVAL); 265 goto free_and_end; 266 } 267 268 /* AV_CODEC_CAP_CHANNEL_CONF is a decoder-only flag; so the code below 269 * in particular checks that nb_channels is set for all audio encoders. */ 270 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && !avctx->ch_layout.nb_channels 271 && !(codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)) { 272 av_log(avctx, AV_LOG_ERROR, "%s requires channel layout to be set\n", 273 av_codec_is_decoder(codec) ? "Decoder" : "Encoder"); 274 ret = AVERROR(EINVAL); 275 goto free_and_end; 276 } 277 if (avctx->ch_layout.nb_channels && !av_channel_layout_check(&avctx->ch_layout)) { 278 av_log(avctx, AV_LOG_ERROR, "Invalid channel layout\n"); 279 ret = AVERROR(EINVAL); 280 goto free_and_end; 281 } 282 if (avctx->ch_layout.nb_channels > FF_SANE_NB_CHANNELS) { 283 av_log(avctx, AV_LOG_ERROR, "Too many channels: %d\n", avctx->ch_layout.nb_channels); 284 ret = AVERROR(EINVAL); 285 goto free_and_end; 286 } 287 288 avctx->frame_num = 0; 289 avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id); 290 291 if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) && 292 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { 293 const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder"; 294 const AVCodec *codec2; 295 av_log(avctx, AV_LOG_ERROR, 296 "The %s '%s' is experimental but experimental codecs are not enabled, " 297 "add '-strict %d' if you want to use it.\n", 298 codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL); 299 codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id); 300 if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL)) 301 av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n", 302 codec_string, codec2->name); 303 ret = AVERROR_EXPERIMENTAL; 304 goto free_and_end; 305 } 306 307 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && 308 (!avctx->time_base.num || !avctx->time_base.den)) { 309 avctx->time_base.num = 1; 310 avctx->time_base.den = avctx->sample_rate; 311 } 312 313 if (av_codec_is_encoder(avctx->codec)) 314 ret = ff_encode_preinit(avctx); 315 else 316 ret = ff_decode_preinit(avctx); 317 if (ret < 0) 318 goto free_and_end; 319 320 if (HAVE_THREADS && !avci->frame_thread_encoder) { 321 /* Frame-threaded decoders call FFCodec.init for their child contexts. */ 322 lock_avcodec(codec2); 323 ret = ff_thread_init(avctx); 324 unlock_avcodec(codec2); 325 if (ret < 0) { 326 goto free_and_end; 327 } 328 } 329 if (!HAVE_THREADS && !(codec2->caps_internal & FF_CODEC_CAP_AUTO_THREADS)) 330 avctx->thread_count = 1; 331 332 if (!(avctx->active_thread_type & FF_THREAD_FRAME) || 333 avci->frame_thread_encoder) { 334 if (codec2->init) { 335 lock_avcodec(codec2); 336 ret = codec2->init(avctx); 337 unlock_avcodec(codec2); 338 if (ret < 0) { 339 avci->needs_close = codec2->caps_internal & FF_CODEC_CAP_INIT_CLEANUP; 340 goto free_and_end; 341 } 342 } 343 avci->needs_close = 1; 344 } 345 346 ret=0; 347 348 if (av_codec_is_decoder(avctx->codec)) { 349 if (!avctx->bit_rate) 350 avctx->bit_rate = get_bit_rate(avctx); 351 352 /* validate channel layout from the decoder */ 353 if ((avctx->ch_layout.nb_channels && !av_channel_layout_check(&avctx->ch_layout)) || 354 avctx->ch_layout.nb_channels > FF_SANE_NB_CHANNELS) { 355 ret = AVERROR(EINVAL); 356 goto free_and_end; 357 } 358 if (avctx->bits_per_coded_sample < 0) { 359 ret = AVERROR(EINVAL); 360 goto free_and_end; 361 } 362 } 363 if (codec->priv_class) 364 av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class); 365 366 end: 367 368 return ret; 369 free_and_end: 370 ff_codec_close(avctx); 371 goto end; 372 } 373 374 void avcodec_flush_buffers(AVCodecContext *avctx) 375 { 376 AVCodecInternal *avci = avctx->internal; 377 378 if (av_codec_is_encoder(avctx->codec)) { 379 int caps = avctx->codec->capabilities; 380 381 if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) { 382 // Only encoders that explicitly declare support for it can be 383 // flushed. Otherwise, this is a no-op. 384 av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder " 385 "that doesn't support it\n"); 386 return; 387 } 388 ff_encode_flush_buffers(avctx); 389 } else 390 ff_decode_flush_buffers(avctx); 391 392 avci->draining = 0; 393 avci->draining_done = 0; 394 if (avci->buffer_frame) 395 av_frame_unref(avci->buffer_frame); 396 if (avci->buffer_pkt) 397 av_packet_unref(avci->buffer_pkt); 398 399 if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME && 400 !avci->is_frame_mt) 401 ff_thread_flush(avctx); 402 else if (ffcodec(avctx->codec)->flush) 403 ffcodec(avctx->codec)->flush(avctx); 404 } 405 406 void avsubtitle_free(AVSubtitle *sub) 407 { 408 int i; 409 410 for (i = 0; i < sub->num_rects; i++) { 411 AVSubtitleRect *const rect = sub->rects[i]; 412 413 av_freep(&rect->data[0]); 414 av_freep(&rect->data[1]); 415 av_freep(&rect->data[2]); 416 av_freep(&rect->data[3]); 417 av_freep(&rect->text); 418 av_freep(&rect->ass); 419 420 av_freep(&sub->rects[i]); 421 } 422 423 av_freep(&sub->rects); 424 425 memset(sub, 0, sizeof(*sub)); 426 } 427 428 av_cold void ff_codec_close(AVCodecContext *avctx) 429 { 430 int i; 431 432 if (!avctx) 433 return; 434 435 if (avcodec_is_open(avctx)) { 436 AVCodecInternal *avci = avctx->internal; 437 438 if (CONFIG_FRAME_THREAD_ENCODER && 439 avci->frame_thread_encoder && avctx->thread_count > 1) { 440 ff_frame_thread_encoder_free(avctx); 441 } 442 if (HAVE_THREADS && avci->thread_ctx) 443 ff_thread_free(avctx); 444 if (avci->needs_close && ffcodec(avctx->codec)->close) 445 ffcodec(avctx->codec)->close(avctx); 446 avci->byte_buffer_size = 0; 447 av_freep(&avci->byte_buffer); 448 av_frame_free(&avci->buffer_frame); 449 av_packet_free(&avci->buffer_pkt); 450 av_packet_free(&avci->last_pkt_props); 451 452 av_packet_free(&avci->in_pkt); 453 av_frame_free(&avci->in_frame); 454 av_frame_free(&avci->recon_frame); 455 456 av_refstruct_unref(&avci->pool); 457 av_refstruct_pool_uninit(&avci->progress_frame_pool); 458 if (av_codec_is_decoder(avctx->codec)) 459 ff_decode_internal_uninit(avctx); 460 461 ff_hwaccel_uninit(avctx); 462 463 av_bsf_free(&avci->bsf); 464 465 #if FF_API_DROPCHANGED 466 av_channel_layout_uninit(&avci->initial_ch_layout); 467 #endif 468 469 #if CONFIG_LCMS2 470 ff_icc_context_uninit(&avci->icc); 471 #endif 472 473 av_freep(&avctx->internal); 474 } 475 476 for (i = 0; i < avctx->nb_coded_side_data; i++) 477 av_freep(&avctx->coded_side_data[i].data); 478 av_freep(&avctx->coded_side_data); 479 avctx->nb_coded_side_data = 0; 480 av_frame_side_data_free(&avctx->decoded_side_data, 481 &avctx->nb_decoded_side_data); 482 483 av_buffer_unref(&avctx->hw_frames_ctx); 484 av_buffer_unref(&avctx->hw_device_ctx); 485 486 if (avctx->priv_data && avctx->codec && avctx->codec->priv_class) 487 av_opt_free(avctx->priv_data); 488 av_opt_free(avctx); 489 av_freep(&avctx->priv_data); 490 if (av_codec_is_encoder(avctx->codec)) { 491 av_freep(&avctx->extradata); 492 avctx->extradata_size = 0; 493 } else if (av_codec_is_decoder(avctx->codec)) 494 av_freep(&avctx->subtitle_header); 495 496 avctx->codec = NULL; 497 avctx->active_thread_type = 0; 498 } 499 500 #if FF_API_AVCODEC_CLOSE 501 int avcodec_close(AVCodecContext *avctx) 502 { 503 ff_codec_close(avctx); 504 return 0; 505 } 506 #endif 507 508 static const char *unknown_if_null(const char *str) 509 { 510 return str ? str : "unknown"; 511 } 512 513 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode) 514 { 515 const char *codec_type; 516 const char *codec_name; 517 const char *profile = NULL; 518 AVBPrint bprint; 519 int64_t bitrate; 520 int new_line = 0; 521 AVRational display_aspect_ratio; 522 const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", "; 523 const char *str; 524 525 if (!buf || buf_size <= 0) 526 return; 527 av_bprint_init_for_buffer(&bprint, buf, buf_size); 528 codec_type = av_get_media_type_string(enc->codec_type); 529 codec_name = avcodec_get_name(enc->codec_id); 530 profile = avcodec_profile_name(enc->codec_id, enc->profile); 531 532 av_bprintf(&bprint, "%s: %s", codec_type ? codec_type : "unknown", 533 codec_name); 534 buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */ 535 536 if (enc->codec && strcmp(enc->codec->name, codec_name)) 537 av_bprintf(&bprint, " (%s)", enc->codec->name); 538 539 if (profile) 540 av_bprintf(&bprint, " (%s)", profile); 541 if ( enc->codec_type == AVMEDIA_TYPE_VIDEO 542 && av_log_get_level() >= AV_LOG_VERBOSE 543 && enc->refs) 544 av_bprintf(&bprint, ", %d reference frame%s", 545 enc->refs, enc->refs > 1 ? "s" : ""); 546 547 if (enc->codec_tag) 548 av_bprintf(&bprint, " (%s / 0x%04X)", 549 av_fourcc2str(enc->codec_tag), enc->codec_tag); 550 551 switch (enc->codec_type) { 552 case AVMEDIA_TYPE_VIDEO: 553 { 554 unsigned len; 555 556 av_bprintf(&bprint, "%s%s", separator, 557 enc->pix_fmt == AV_PIX_FMT_NONE ? "none" : 558 unknown_if_null(av_get_pix_fmt_name(enc->pix_fmt))); 559 560 av_bprint_chars(&bprint, '(', 1); 561 len = bprint.len; 562 563 /* The following check ensures that '(' has been written 564 * and therefore allows us to erase it if it turns out 565 * to be unnecessary. */ 566 if (!av_bprint_is_complete(&bprint)) 567 return; 568 569 if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE && 570 enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth) 571 av_bprintf(&bprint, "%d bpc, ", enc->bits_per_raw_sample); 572 if (enc->color_range != AVCOL_RANGE_UNSPECIFIED && 573 (str = av_color_range_name(enc->color_range))) 574 av_bprintf(&bprint, "%s, ", str); 575 576 if (enc->colorspace != AVCOL_SPC_UNSPECIFIED || 577 enc->color_primaries != AVCOL_PRI_UNSPECIFIED || 578 enc->color_trc != AVCOL_TRC_UNSPECIFIED) { 579 const char *col = unknown_if_null(av_color_space_name(enc->colorspace)); 580 const char *pri = unknown_if_null(av_color_primaries_name(enc->color_primaries)); 581 const char *trc = unknown_if_null(av_color_transfer_name(enc->color_trc)); 582 if (strcmp(col, pri) || strcmp(col, trc)) { 583 new_line = 1; 584 av_bprintf(&bprint, "%s/%s/%s, ", col, pri, trc); 585 } else 586 av_bprintf(&bprint, "%s, ", col); 587 } 588 589 if (enc->field_order != AV_FIELD_UNKNOWN) { 590 const char *field_order = "progressive"; 591 if (enc->field_order == AV_FIELD_TT) 592 field_order = "top first"; 593 else if (enc->field_order == AV_FIELD_BB) 594 field_order = "bottom first"; 595 else if (enc->field_order == AV_FIELD_TB) 596 field_order = "top coded first (swapped)"; 597 else if (enc->field_order == AV_FIELD_BT) 598 field_order = "bottom coded first (swapped)"; 599 600 av_bprintf(&bprint, "%s, ", field_order); 601 } 602 603 if (av_log_get_level() >= AV_LOG_VERBOSE && 604 enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED && 605 (str = av_chroma_location_name(enc->chroma_sample_location))) 606 av_bprintf(&bprint, "%s, ", str); 607 608 if (len == bprint.len) { 609 bprint.str[len - 1] = '\0'; 610 bprint.len--; 611 } else { 612 if (bprint.len - 2 < bprint.size) { 613 /* Erase the last ", " */ 614 bprint.len -= 2; 615 bprint.str[bprint.len] = '\0'; 616 } 617 av_bprint_chars(&bprint, ')', 1); 618 } 619 } 620 621 if (enc->width) { 622 av_bprintf(&bprint, "%s%dx%d", new_line ? separator : ", ", 623 enc->width, enc->height); 624 625 if (av_log_get_level() >= AV_LOG_VERBOSE && 626 enc->coded_width && enc->coded_height && 627 (enc->width != enc->coded_width || 628 enc->height != enc->coded_height)) 629 av_bprintf(&bprint, " (%dx%d)", 630 enc->coded_width, enc->coded_height); 631 632 if (enc->sample_aspect_ratio.num) { 633 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den, 634 enc->width * (int64_t)enc->sample_aspect_ratio.num, 635 enc->height * (int64_t)enc->sample_aspect_ratio.den, 636 1024 * 1024); 637 av_bprintf(&bprint, " [SAR %d:%d DAR %d:%d]", 638 enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den, 639 display_aspect_ratio.num, display_aspect_ratio.den); 640 } 641 if (av_log_get_level() >= AV_LOG_DEBUG) { 642 int g = av_gcd(enc->time_base.num, enc->time_base.den); 643 av_bprintf(&bprint, ", %d/%d", 644 enc->time_base.num / g, enc->time_base.den / g); 645 } 646 } 647 if (encode) { 648 av_bprintf(&bprint, ", q=%d-%d", enc->qmin, enc->qmax); 649 } else { 650 #if FF_API_CODEC_PROPS 651 FF_DISABLE_DEPRECATION_WARNINGS 652 if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS) 653 av_bprintf(&bprint, ", Closed Captions"); 654 if (enc->properties & FF_CODEC_PROPERTY_FILM_GRAIN) 655 av_bprintf(&bprint, ", Film Grain"); 656 if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS) 657 av_bprintf(&bprint, ", lossless"); 658 FF_ENABLE_DEPRECATION_WARNINGS 659 #endif 660 } 661 break; 662 case AVMEDIA_TYPE_AUDIO: 663 av_bprintf(&bprint, "%s", separator); 664 665 if (enc->sample_rate) { 666 av_bprintf(&bprint, "%d Hz, ", enc->sample_rate); 667 } 668 av_channel_layout_describe_bprint(&enc->ch_layout, &bprint); 669 if (enc->sample_fmt != AV_SAMPLE_FMT_NONE && 670 (str = av_get_sample_fmt_name(enc->sample_fmt))) { 671 av_bprintf(&bprint, ", %s", str); 672 } 673 if ( enc->bits_per_raw_sample > 0 674 && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8) 675 av_bprintf(&bprint, " (%d bit)", enc->bits_per_raw_sample); 676 if (av_log_get_level() >= AV_LOG_VERBOSE) { 677 if (enc->initial_padding) 678 av_bprintf(&bprint, ", delay %d", enc->initial_padding); 679 if (enc->trailing_padding) 680 av_bprintf(&bprint, ", padding %d", enc->trailing_padding); 681 } 682 break; 683 case AVMEDIA_TYPE_DATA: 684 if (av_log_get_level() >= AV_LOG_DEBUG) { 685 int g = av_gcd(enc->time_base.num, enc->time_base.den); 686 if (g) 687 av_bprintf(&bprint, ", %d/%d", 688 enc->time_base.num / g, enc->time_base.den / g); 689 } 690 break; 691 case AVMEDIA_TYPE_SUBTITLE: 692 if (enc->width) 693 av_bprintf(&bprint, ", %dx%d", enc->width, enc->height); 694 break; 695 default: 696 return; 697 } 698 if (encode) { 699 if (enc->flags & AV_CODEC_FLAG_PASS1) 700 av_bprintf(&bprint, ", pass 1"); 701 if (enc->flags & AV_CODEC_FLAG_PASS2) 702 av_bprintf(&bprint, ", pass 2"); 703 } 704 bitrate = get_bit_rate(enc); 705 if (bitrate != 0) { 706 av_bprintf(&bprint, ", %"PRId64" kb/s", bitrate / 1000); 707 } else if (enc->rc_max_rate > 0) { 708 av_bprintf(&bprint, ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000); 709 } 710 } 711 712 int avcodec_is_open(AVCodecContext *s) 713 { 714 return !!s->internal; 715 } 716 717 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame) 718 { 719 av_frame_unref(frame); 720 721 if (av_codec_is_decoder(avctx->codec)) 722 return ff_decode_receive_frame(avctx, frame); 723 return ff_encode_receive_frame(avctx, frame); 724 } 725 726 #define WRAP_CONFIG(allowed_type, field, field_type, terminator) \ 727 do { \ 728 static const field_type end = terminator; \ 729 if (codec->type != (allowed_type)) \ 730 return AVERROR(EINVAL); \ 731 *out_configs = (field); \ 732 if (out_num_configs) { \ 733 for (int i = 0;; i++) { \ 734 if (!(field) || !memcmp(&(field)[i], &end, sizeof(end))) { \ 735 *out_num_configs = i; \ 736 break; \ 737 } \ 738 } \ 739 } \ 740 return 0; \ 741 } while (0) 742 743 static const enum AVColorRange color_range_jpeg[] = { 744 AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED 745 }; 746 747 static const enum AVColorRange color_range_mpeg[] = { 748 AVCOL_RANGE_MPEG, AVCOL_RANGE_UNSPECIFIED 749 }; 750 751 static const enum AVColorRange color_range_all[] = { 752 AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED 753 }; 754 755 static const enum AVColorRange *color_range_table[] = { 756 [AVCOL_RANGE_MPEG] = color_range_mpeg, 757 [AVCOL_RANGE_JPEG] = color_range_jpeg, 758 [AVCOL_RANGE_MPEG | AVCOL_RANGE_JPEG] = color_range_all, 759 }; 760 761 int ff_default_get_supported_config(const AVCodecContext *avctx, 762 const AVCodec *codec, 763 enum AVCodecConfig config, 764 unsigned flags, 765 const void **out_configs, 766 int *out_num_configs) 767 { 768 switch (config) { 769 FF_DISABLE_DEPRECATION_WARNINGS 770 case AV_CODEC_CONFIG_PIX_FORMAT: 771 WRAP_CONFIG(AVMEDIA_TYPE_VIDEO, codec->pix_fmts, enum AVPixelFormat, AV_PIX_FMT_NONE); 772 case AV_CODEC_CONFIG_FRAME_RATE: 773 WRAP_CONFIG(AVMEDIA_TYPE_VIDEO, codec->supported_framerates, AVRational, {0}); 774 case AV_CODEC_CONFIG_SAMPLE_RATE: 775 WRAP_CONFIG(AVMEDIA_TYPE_AUDIO, codec->supported_samplerates, int, 0); 776 case AV_CODEC_CONFIG_SAMPLE_FORMAT: 777 WRAP_CONFIG(AVMEDIA_TYPE_AUDIO, codec->sample_fmts, enum AVSampleFormat, AV_SAMPLE_FMT_NONE); 778 case AV_CODEC_CONFIG_CHANNEL_LAYOUT: 779 WRAP_CONFIG(AVMEDIA_TYPE_AUDIO, codec->ch_layouts, AVChannelLayout, {0}); 780 FF_ENABLE_DEPRECATION_WARNINGS 781 782 case AV_CODEC_CONFIG_COLOR_RANGE: 783 if (codec->type != AVMEDIA_TYPE_VIDEO) 784 return AVERROR(EINVAL); 785 *out_configs = color_range_table[ffcodec(codec)->color_ranges]; 786 if (out_num_configs) 787 *out_num_configs = av_popcount(ffcodec(codec)->color_ranges); 788 return 0; 789 790 case AV_CODEC_CONFIG_COLOR_SPACE: 791 *out_configs = NULL; 792 if (out_num_configs) 793 *out_num_configs = 0; 794 return 0; 795 default: 796 return AVERROR(EINVAL); 797 } 798 } 799 800 int avcodec_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, 801 enum AVCodecConfig config, unsigned flags, 802 const void **out, int *out_num) 803 { 804 const FFCodec *codec2; 805 int dummy_num = 0; 806 if (!codec) 807 codec = avctx->codec; 808 if (!out_num) 809 out_num = &dummy_num; 810 811 codec2 = ffcodec(codec); 812 if (codec2->get_supported_config) { 813 return codec2->get_supported_config(avctx, codec, config, flags, out, out_num); 814 } else { 815 return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num); 816 } 817 }