FFmpeg
Loading...
Searching...
No Matches
avcodec.c
Go to the documentation of this file.
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 <assert.h>
27
28#include "config.h"
29#include "libavutil/avassert.h"
30#include "libavutil/avstring.h"
31#include "libavutil/bprint.h"
33#include "libavutil/common.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"
45#include "hwconfig.h"
46#include "internal.h"
47#include "libavutil/refstruct.h"
48
49/**
50 * Maximum size in bytes of extradata.
51 * This value was chosen such that every bit of the buffer is
52 * addressable by a 32-bit signed integer as used by get_bits.
53 */
54#define FF_MAX_EXTRADATA_SIZE ((1 << 28) - AV_INPUT_BUFFER_PADDING_SIZE)
55
71
72
73int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
74{
75 size_t i;
76
77 for (i = 0; i < count; i++) {
78 size_t offset = i * size;
79 int r = func(c, FF_PTR_ADD((char *)arg, offset));
80 if (ret)
81 ret[i] = r;
82 }
83 return 0;
84}
85
86int 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 return 0;
96}
97
99
100static void lock_avcodec(const FFCodec *codec)
101{
104}
105
106static void unlock_avcodec(const FFCodec *codec)
107{
110}
111
113{
114 int64_t bit_rate;
115 int bits_per_sample;
116
117 switch (ctx->codec_type) {
122 bit_rate = ctx->bit_rate;
123 break;
125 bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
126 if (bits_per_sample) {
127 bit_rate = ctx->sample_rate * (int64_t)ctx->ch_layout.nb_channels;
128 if (bit_rate > INT64_MAX / bits_per_sample) {
129 bit_rate = 0;
130 } else
131 bit_rate *= bits_per_sample;
132 } else
133 bit_rate = ctx->bit_rate;
134 break;
135 default:
136 bit_rate = 0;
137 break;
138 }
139 return bit_rate;
140}
141
143{
144 int ret = 0;
145 AVCodecInternal *avci;
146 const FFCodec *codec2;
147 const AVDictionaryEntry *e;
148
149 if (avcodec_is_open(avctx))
150 return 0;
151
152 if (!codec && !avctx->codec) {
153 av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
154 return AVERROR(EINVAL);
155 }
156 if (codec && avctx->codec && codec != avctx->codec) {
157 av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
158 "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
159 return AVERROR(EINVAL);
160 }
161 if (!codec)
162 codec = avctx->codec;
163 codec2 = ffcodec(codec);
164
165 if ((avctx->codec_type != AVMEDIA_TYPE_UNKNOWN && avctx->codec_type != codec->type) ||
166 (avctx->codec_id != AV_CODEC_ID_NONE && avctx->codec_id != codec->id)) {
167 av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
168 return AVERROR(EINVAL);
169 }
170
171 avctx->codec_type = codec->type;
172 avctx->codec_id = codec->id;
173 avctx->codec = codec;
174
175 if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
176 return AVERROR(EINVAL);
177
178 // set the whitelist from provided options dict,
179 // so we can check it immediately
180 e = options ? av_dict_get(*options, "codec_whitelist", NULL, 0) : NULL;
181 if (e) {
182 ret = av_opt_set(avctx, e->key, e->value, 0);
183 if (ret < 0)
184 return ret;
185 }
186
187 if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
188 av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
189 return AVERROR(EINVAL);
190 }
191
192 avci = ff_codec_is_decoder(codec) ?
195 if (!avci) {
196 ret = AVERROR(ENOMEM);
197 goto end;
198 }
199 avctx->internal = avci;
200
202 avci->buffer_pkt = av_packet_alloc();
203 if (!avci->buffer_frame || !avci->buffer_pkt) {
204 ret = AVERROR(ENOMEM);
205 goto free_and_end;
206 }
207
208 if (codec2->priv_data_size > 0) {
209 if (!avctx->priv_data) {
210 avctx->priv_data = av_mallocz(codec2->priv_data_size);
211 if (!avctx->priv_data) {
212 ret = AVERROR(ENOMEM);
213 goto free_and_end;
214 }
215 if (codec->priv_class) {
216 *(const AVClass **)avctx->priv_data = codec->priv_class;
218 }
219 }
220 } else {
221 avctx->priv_data = NULL;
222 }
223
225 if (ret < 0)
226 goto free_and_end;
227
228 // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
229 if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
230 (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
231 if (avctx->coded_width && avctx->coded_height)
232 ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
233 else if (avctx->width && avctx->height)
234 ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
235 if (ret < 0)
236 goto free_and_end;
237 }
238
239 if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
240 && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
241 || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
242 av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
243 ff_set_dimensions(avctx, 0, 0);
244 }
245
246 if (avctx->width > 0 && avctx->height > 0) {
247 if (av_image_check_sar(avctx->width, avctx->height,
248 avctx->sample_aspect_ratio) < 0) {
249 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
251 avctx->sample_aspect_ratio.den);
252 avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
253 }
254 }
255
256 /* AV_CODEC_CAP_CHANNEL_CONF is a decoder-only flag; so the code below
257 * in particular checks that sample_rate is set for all audio encoders. */
258 if (avctx->sample_rate < 0 ||
259 avctx->sample_rate == 0 && avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
261 av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
262 ret = AVERROR(EINVAL);
263 goto free_and_end;
264 }
265 if (avctx->block_align < 0) {
266 av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
267 ret = AVERROR(EINVAL);
268 goto free_and_end;
269 }
270
271 /* AV_CODEC_CAP_CHANNEL_CONF is a decoder-only flag; so the code below
272 * in particular checks that nb_channels is set for all audio encoders. */
273 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && !avctx->ch_layout.nb_channels
275 av_log(avctx, AV_LOG_ERROR, "%s requires channel layout to be set\n",
276 ff_codec_is_decoder(codec) ? "Decoder" : "Encoder");
277 ret = AVERROR(EINVAL);
278 goto free_and_end;
279 }
280 if (avctx->ch_layout.nb_channels && !av_channel_layout_check(&avctx->ch_layout)) {
281 av_log(avctx, AV_LOG_ERROR, "Invalid channel layout\n");
282 ret = AVERROR(EINVAL);
283 goto free_and_end;
284 }
286 av_log(avctx, AV_LOG_ERROR, "Too many channels: %d\n", avctx->ch_layout.nb_channels);
287 ret = AVERROR(EINVAL);
288 goto free_and_end;
289 }
290
291 avctx->frame_num = 0;
293
296 const char *codec_string = ff_codec_is_encoder(codec) ? "encoder" : "decoder";
297 const AVCodec *codec2;
298 av_log(avctx, AV_LOG_ERROR,
299 "The %s '%s' is experimental but experimental codecs are not enabled, "
300 "add '-strict %d' if you want to use it.\n",
302 codec2 = ff_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
304 av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
305 codec_string, codec2->name);
307 goto free_and_end;
308 }
309
310 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
311 (!avctx->time_base.num || !avctx->time_base.den)) {
312 avctx->time_base.num = 1;
313 avctx->time_base.den = avctx->sample_rate;
314 }
315
316 if (ff_codec_is_encoder(avctx->codec))
317 ret = ff_encode_preinit(avctx);
318 else
319 ret = ff_decode_preinit(avctx);
320 if (ret < 0)
321 goto free_and_end;
322
323 if (HAVE_THREADS && !avci->frame_thread_encoder) {
324 /* Frame-threaded decoders call FFCodec.init for their child contexts. */
325 lock_avcodec(codec2);
326 ret = ff_thread_init(avctx);
327 unlock_avcodec(codec2);
328 if (ret < 0) {
329 goto free_and_end;
330 }
331 }
332 if (!HAVE_THREADS && !(codec2->caps_internal & FF_CODEC_CAP_AUTO_THREADS))
333 avctx->thread_count = 1;
334
335 if (!(avctx->active_thread_type & FF_THREAD_FRAME) ||
336 avci->frame_thread_encoder) {
337 if (codec2->init) {
338 lock_avcodec(codec2);
339 ret = codec2->init(avctx);
340 unlock_avcodec(codec2);
341 if (ret < 0) {
343 goto free_and_end;
344 }
345 }
346 avci->needs_close = 1;
347 }
348
349 ret=0;
350
351 if (ff_codec_is_decoder(avctx->codec)) {
352 if (!avctx->bit_rate)
353 avctx->bit_rate = get_bit_rate(avctx);
354
355
356 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
357 !avctx->frame_size && (avctx->flags2 & AV_CODEC_FLAG2_FIXED_FRAME_SIZE)) {
358 av_log(avctx, AV_LOG_ERROR, "Fixed frame size requested but no frame_size value set\n");
359 ret = AVERROR(EINVAL);
360 goto free_and_end;
361 }
362
363 avci->skip_samples = avctx->delay;
364
365 /* validate channel layout from the decoder */
366 if ((avctx->ch_layout.nb_channels && !av_channel_layout_check(&avctx->ch_layout)) ||
368 ret = AVERROR(EINVAL);
369 goto free_and_end;
370 }
371 if (avctx->bits_per_coded_sample < 0) {
372 ret = AVERROR(EINVAL);
373 goto free_and_end;
374 }
375 }
376 if (codec->priv_class)
377 av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
378
379end:
380
381 return ret;
382free_and_end:
383 ff_codec_close(avctx);
384 goto end;
385}
386
388{
389 AVCodecInternal *avci = avctx->internal;
390
391 if (av_codec_is_encoder(avctx->codec)) {
392 int caps = avctx->codec->capabilities;
393
394 if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
395 // Only encoders that explicitly declare support for it can be
396 // flushed. Otherwise, this is a no-op.
397 av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
398 "that doesn't support it\n");
399 return;
400 }
402 } else
404
405 avci->draining = 0;
406 avci->draining_done = 0;
407 if (avci->buffer_frame)
409 if (avci->buffer_pkt)
411
412 if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME &&
413 !avci->is_frame_mt)
414 ff_thread_flush(avctx);
415 else if (ffcodec(avctx->codec)->flush)
416 ffcodec(avctx->codec)->flush(avctx);
417}
418
420{
421 int i;
422
423 for (i = 0; i < sub->num_rects; i++) {
424 AVSubtitleRect *const rect = sub->rects[i];
425
426 av_freep(&rect->data[0]);
427 av_freep(&rect->data[1]);
428 av_freep(&rect->data[2]);
429 av_freep(&rect->data[3]);
430 av_freep(&rect->text);
431 av_freep(&rect->ass);
432
433 av_freep(&sub->rects[i]);
434 }
435
436 av_freep(&sub->rects);
437
438 memset(sub, 0, sizeof(*sub));
439}
440
442{
443 int i;
444
445 if (avcodec_is_open(avctx)) {
446 AVCodecInternal *avci = avctx->internal;
447
448#if CONFIG_FRAME_THREAD_ENCODER
449 if (avci->frame_thread_encoder && avctx->thread_count > 1) {
451 }
452#endif
453 if (HAVE_THREADS && avci->thread_ctx)
454 ff_thread_free(avctx);
455 if (avci->needs_close && ffcodec(avctx->codec)->close)
456 ffcodec(avctx->codec)->close(avctx);
457 avci->byte_buffer_size = 0;
458 av_freep(&avci->byte_buffer);
462
463 av_packet_free(&avci->in_pkt);
464 av_frame_free(&avci->in_frame);
466
467 av_refstruct_unref(&avci->pool);
469 if (av_codec_is_decoder(avctx->codec))
471
472 ff_hwaccel_uninit(avctx);
473
474 av_bsf_free(&avci->bsf);
475
476#if CONFIG_LCMS2
477 ff_icc_context_uninit(&avci->icc);
478#endif
479
480 av_freep(&avctx->internal);
481 }
482
483 for (i = 0; i < avctx->nb_coded_side_data; i++)
484 av_freep(&avctx->coded_side_data[i].data);
485 av_freep(&avctx->coded_side_data);
486 avctx->nb_coded_side_data = 0;
488 &avctx->nb_decoded_side_data);
489
492
493 if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
494 av_opt_free(avctx->priv_data);
495 av_opt_free(avctx);
496 av_freep(&avctx->priv_data);
497 if (av_codec_is_encoder(avctx->codec)) {
498 av_freep(&avctx->extradata);
499 avctx->extradata_size = 0;
500 } else if (av_codec_is_decoder(avctx->codec))
501 av_freep(&avctx->subtitle_header);
502
503 avctx->codec = NULL;
504 avctx->active_thread_type = 0;
505}
506
507static const char *unknown_if_null(const char *str)
508{
509 return str ? str : "unknown";
510}
511
512void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
513{
514 const char *codec_type;
515 const char *codec_name;
516 const char *profile = NULL;
517 AVBPrint bprint;
519 int new_line = 0;
520 AVRational display_aspect_ratio;
521 const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
522 const char *str;
523
524 if (!buf || buf_size <= 0)
525 return;
526 av_bprint_init_for_buffer(&bprint, buf, buf_size);
528 codec_name = avcodec_get_name(enc->codec_id);
530
531 av_bprintf(&bprint, "%s: %s", codec_type ? codec_type : "unknown",
532 codec_name);
533 buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
534
535 if (enc->codec && strcmp(enc->codec->name, codec_name))
536 av_bprintf(&bprint, " (%s)", enc->codec->name);
537
538 if (profile)
539 av_bprintf(&bprint, " (%s)", profile);
540 if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
542 && enc->refs)
543 av_bprintf(&bprint, ", %d reference frame%s",
544 enc->refs, enc->refs > 1 ? "s" : "");
545
546 if (enc->codec_tag)
547 av_bprintf(&bprint, " (%s / 0x%04X)",
548 av_fourcc2str(enc->codec_tag), enc->codec_tag);
549
550 switch (enc->codec_type) {
552 {
553 unsigned len;
554
555 av_bprintf(&bprint, "%s%s", separator,
556 enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
558
559 av_bprint_chars(&bprint, '(', 1);
560 len = bprint.len;
561
562 /* The following check ensures that '(' has been written
563 * and therefore allows us to erase it if it turns out
564 * to be unnecessary. */
565 if (!av_bprint_is_complete(&bprint))
566 return;
567
568 if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
569 enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
570 av_bprintf(&bprint, "%d bpc, ", enc->bits_per_raw_sample);
572 (str = av_color_range_name(enc->color_range)))
573 av_bprintf(&bprint, "%s, ", str);
574
575 if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
578 const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
580 const char *trc = unknown_if_null(av_color_transfer_name(enc->color_trc));
581 if (strcmp(col, pri) || strcmp(col, trc)) {
582 new_line = 1;
583 av_bprintf(&bprint, "%s/%s/%s, ", col, pri, trc);
584 } else
585 av_bprintf(&bprint, "%s, ", col);
586 }
587
588 if (enc->field_order != AV_FIELD_UNKNOWN) {
589 const char *field_order = "progressive";
590 if (enc->field_order == AV_FIELD_TT)
591 field_order = "top first";
592 else if (enc->field_order == AV_FIELD_BB)
593 field_order = "bottom first";
594 else if (enc->field_order == AV_FIELD_TB)
595 field_order = "top coded first (swapped)";
596 else if (enc->field_order == AV_FIELD_BT)
597 field_order = "bottom coded first (swapped)";
598
599 av_bprintf(&bprint, "%s, ", field_order);
600 }
601
605 av_bprintf(&bprint, "%s, ", str);
606
607 if (len == bprint.len) {
608 bprint.str[len - 1] = '\0';
609 bprint.len--;
610 } else {
611 if (bprint.len - 2 < bprint.size) {
612 /* Erase the last ", " */
613 bprint.len -= 2;
614 bprint.str[bprint.len] = '\0';
615 }
616 av_bprint_chars(&bprint, ')', 1);
617 }
618 }
619
620 if (enc->width) {
621 av_bprintf(&bprint, "%s%dx%d", new_line ? separator : ", ",
622 enc->width, enc->height);
623
625 enc->coded_width && enc->coded_height &&
626 (enc->width != enc->coded_width ||
627 enc->height != enc->coded_height))
628 av_bprintf(&bprint, " (%dx%d)",
629 enc->coded_width, enc->coded_height);
630
631 if (enc->sample_aspect_ratio.num) {
632 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
635 1024 * 1024);
636 av_bprintf(&bprint, " [SAR %d:%d DAR %d:%d]",
638 display_aspect_ratio.num, display_aspect_ratio.den);
639 }
641 int g = av_gcd(enc->time_base.num, enc->time_base.den);
642 av_bprintf(&bprint, ", %d/%d",
643 enc->time_base.num / g, enc->time_base.den / g);
644 }
645 }
646 if (encode) {
647 av_bprintf(&bprint, ", q=%d-%d", enc->qmin, enc->qmax);
648 }
649 break;
651 av_bprintf(&bprint, "%s", separator);
652
653 if (enc->sample_rate) {
654 av_bprintf(&bprint, "%d Hz, ", enc->sample_rate);
655 }
657 if (enc->sample_fmt != AV_SAMPLE_FMT_NONE &&
658 (str = av_get_sample_fmt_name(enc->sample_fmt))) {
659 av_bprintf(&bprint, ", %s", str);
660 }
661 if ( enc->bits_per_raw_sample > 0
663 av_bprintf(&bprint, " (%d bit)", enc->bits_per_raw_sample);
665 if (enc->initial_padding)
666 av_bprintf(&bprint, ", delay %d", enc->initial_padding);
667 if (enc->trailing_padding)
668 av_bprintf(&bprint, ", padding %d", enc->trailing_padding);
669 }
670 break;
673 int g = av_gcd(enc->time_base.num, enc->time_base.den);
674 if (g)
675 av_bprintf(&bprint, ", %d/%d",
676 enc->time_base.num / g, enc->time_base.den / g);
677 }
678 break;
680 if (enc->width)
681 av_bprintf(&bprint, ", %dx%d", enc->width, enc->height);
682 break;
683 default:
684 return;
685 }
686 if (encode) {
687 if (enc->flags & AV_CODEC_FLAG_PASS1)
688 av_bprintf(&bprint, ", pass 1");
689 if (enc->flags & AV_CODEC_FLAG_PASS2)
690 av_bprintf(&bprint, ", pass 2");
691 }
692 bitrate = get_bit_rate(enc);
693 if (bitrate != 0) {
694 av_bprintf(&bprint, ", %"PRId64" kb/s", bitrate / 1000);
695 } else if (enc->rc_max_rate > 0) {
696 av_bprintf(&bprint, ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
697 }
698}
699
701{
702 return !!s->internal;
703}
704
706 AVFrame *frame, unsigned flags)
707{
709
710 if (!avcodec_is_open(avctx) || !avctx->codec)
711 return AVERROR(EINVAL);
712
713 if (ff_codec_is_decoder(avctx->codec))
714 return ff_decode_receive_frame(avctx, frame, flags);
715 return ff_encode_receive_frame(avctx, frame);
716}
717
722
723#define WRAP_CONFIG(allowed_type, field, var, field_type, sentinel_check) \
724 do { \
725 if (codec->type != (allowed_type)) \
726 return AVERROR(EINVAL); \
727 const field_type *ptr = codec2->field; \
728 *out_configs = ptr; \
729 if (ptr) { \
730 for (int i = 0;; i++) { \
731 const field_type var = ptr[i]; \
732 if (sentinel_check) { \
733 *out_num_configs = i; \
734 break; \
735 } \
736 } \
737 } else \
738 *out_num_configs = 0; \
739 return 0; \
740 } while (0)
741
746
751
752static_assert((int)AVCOL_RANGE_MPEG == (int)AVALPHA_MODE_PREMULTIPLIED, "unexpected enum values");
753static_assert((int)AVCOL_RANGE_JPEG == (int)AVALPHA_MODE_STRAIGHT, "unexpected enum values");
754static_assert(AVCOL_RANGE_UNSPECIFIED == 0 && AVALPHA_MODE_UNSPECIFIED == 0, "unexpected enum values");
755static_assert(AVCOL_RANGE_NB == 3 && AVALPHA_MODE_NB == 3, "unexpected enum values");
756
757static const uint8_t offset_tab[] = {
758 [AVCOL_RANGE_MPEG] = 3,
759 [AVCOL_RANGE_JPEG] = 1,
761};
762
764 const AVCodec *codec,
765 enum AVCodecConfig config,
766 unsigned flags,
767 const void **out_configs,
768 int *out_num_configs)
769{
770 const FFCodec *codec2 = ffcodec(codec);
771
772 switch (config) {
776 WRAP_CONFIG(AVMEDIA_TYPE_VIDEO, supported_framerates, framerate, AVRational, framerate.num == 0);
778 WRAP_CONFIG(AVMEDIA_TYPE_AUDIO, supported_samplerates, samplerate, int, samplerate == 0);
782 WRAP_CONFIG(AVMEDIA_TYPE_AUDIO, ch_layouts, ch_layout, AVChannelLayout, ch_layout.nb_channels == 0);
783
785 if (codec->type != AVMEDIA_TYPE_VIDEO)
786 return AVERROR(EINVAL);
787 unsigned color_ranges = codec2->color_ranges;
788 if (color_ranges)
789 *out_configs = color_range_tab + offset_tab[color_ranges];
790 else
791 *out_configs = NULL;
792 *out_num_configs = av_popcount(color_ranges);
793 return 0;
794
796 *out_configs = NULL;
797 *out_num_configs = 0;
798 return 0;
799
801 if (codec->type != AVMEDIA_TYPE_VIDEO)
802 return AVERROR(EINVAL);
803 unsigned alpha_modes = codec2->alpha_modes;
804 if (alpha_modes)
805 *out_configs = alpha_mode_tab + offset_tab[alpha_modes];
806 else
807 *out_configs = NULL;
808 *out_num_configs = av_popcount(alpha_modes);
809 return 0;
810
812 WRAP_CONFIG(AVMEDIA_TYPE_VIDEO, chroma_locations, loc,
814
815 default:
816 return AVERROR(EINVAL);
817 }
818}
819
821 enum AVCodecConfig config, unsigned flags,
822 const void **out, int *out_num)
823{
824 const FFCodec *codec2;
825 int dummy_num = 0;
826 if (!codec)
827 codec = avctx->codec;
828 if (!out_num)
829 out_num = &dummy_num;
830
831 codec2 = ffcodec(codec);
832 if (codec2->get_supported_config) {
833 return codec2->get_supported_config(avctx, codec, config, flags, out, out_num);
834 } else {
835 return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num);
836 }
837}
838
840 const AVFrameSideData *src, unsigned int flags)
841{
843
844 for (unsigned j = 0; ff_sd_global_map[j].packet < AV_PKT_DATA_NB; j++) {
845 if (ff_sd_global_map[j].frame != src->type)
846 continue;
847
848 sd = av_packet_side_data_new(psd, pnb_sd, ff_sd_global_map[j].packet,
849 src->size, 0);
850
851 if (!sd)
852 return AVERROR(ENOMEM);
853
854 memcpy(sd->data, src->data, src->size);
855 break;
856 }
857
858 if (!sd)
859 return AVERROR(EINVAL);
860
861 return 0;
862}
863
865 const AVPacketSideData *src, unsigned int flags)
866{
867 AVFrameSideData *sd = NULL;
868
869 for (unsigned j = 0; ff_sd_global_map[j].packet < AV_PKT_DATA_NB; j++) {
870 if (ff_sd_global_map[j].packet != src->type)
871 continue;
872
873 sd = av_frame_side_data_new(psd, pnb_sd, ff_sd_global_map[j].frame,
874 src->size, flags);
875
876 if (!sd)
877 return AVERROR(ENOMEM);
878
879 memcpy(sd->data, src->data, src->size);
880 break;
881 }
882
883 if (!sd)
884 return AVERROR(EINVAL);
885
886 return 0;
887}
static enum AVSampleFormat sample_fmts[]
Definition adpcmenc.c:933
static FILE * out
static AVFormatContext * ctx
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition avassert.h:42
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition avcodec.c:54
static const uint8_t offset_tab[]
Definition avcodec.c:757
int ff_default_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out_configs, int *out_num_configs)
Definition avcodec.c:763
static void lock_avcodec(const FFCodec *codec)
Definition avcodec.c:100
static enum AVColorRange color_range_tab[]
Definition avcodec.c:742
av_cold void ff_codec_close(AVCodecContext *avctx)
Definition avcodec.c:441
static AVMutex codec_mutex
Definition avcodec.c:98
const SideDataMap ff_sd_global_map[]
A map between packet and frame side data types.
Definition avcodec.c:56
static const char * unknown_if_null(const char *str)
Definition avcodec.c:507
static enum AVAlphaMode alpha_mode_tab[]
Definition avcodec.c:747
static void unlock_avcodec(const FFCodec *codec)
Definition avcodec.c:106
int av_packet_side_data_from_frame(AVPacketSideData **psd, int *pnb_sd, const AVFrameSideData *src, unsigned int flags)
Definition avcodec.c:839
#define WRAP_CONFIG(allowed_type, field, var, field_type, sentinel_check)
Definition avcodec.c:723
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition avcodec.c:112
Libavcodec external API header.
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition avcodec.h:1600
void ff_thread_free(struct AVCodecContext *s)
Definition pthread.c:84
int ff_encode_receive_frame(struct AVCodecContext *avctx, struct AVFrame *frame)
avcodec_receive_frame() implementation for encoders.
Definition encode.c:1033
void ff_thread_flush(struct AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
int ff_decode_preinit(struct AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition decode.c:2066
void ff_encode_flush_buffers(struct AVCodecContext *avctx)
Definition encode.c:1046
void ff_decode_flush_buffers(struct AVCodecContext *avctx)
Definition decode.c:2411
void ff_decode_internal_uninit(struct AVCodecContext *avctx)
Definition decode.c:2453
int ff_encode_preinit(struct AVCodecContext *avctx)
Definition encode.c:920
int ff_decode_receive_frame(struct AVCodecContext *avctx, struct AVFrame *frame, unsigned flags)
avcodec_receive_frame() implementation for decoders.
Definition decode.c:825
int ff_thread_init(struct AVCodecContext *s)
Definition pthread.c:72
struct AVCodecInternal * ff_decode_internal_alloc(void)
Definition decode.c:2431
struct AVCodecInternal * ff_encode_internal_alloc(void)
Definition encode.c:1056
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition bprint.c:121
AVBPrint public header.
#define flags(name, subs,...)
Definition cbs_h264.c:74
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
#define s(width, name)
Definition cbs_vp9.c:198
Public libavutil channel layout APIs header.
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
static av_always_inline const FFCodec * ffcodec(const AVCodec *codec)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
static int ff_codec_is_decoder(const AVCodec *avcodec)
Internal version of av_codec_is_decoder().
static int ff_codec_is_encoder(const AVCodec *avcodec)
Internal version of av_codec_is_encoder().
common internal and external API header
#define av_popcount
Definition common.h:154
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition decode.c:1236
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition utils.c:91
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition defs.h:62
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition defs.h:230
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition defs.h:231
@ AV_FIELD_UNKNOWN
Definition defs.h:228
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition defs.h:233
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition defs.h:232
static enum AVPixelFormat pix_fmt
static AVFrame * frame
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
static char separator(CheckasmFormat format)
Definition checkasm.c:149
static const char * unknown_if_null(const char *str)
int ret
Definition ffplay.c:391
av_cold void ff_frame_thread_encoder_free(AVCodecContext *avctx)
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition bsf.c:47
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition utils.c:557
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition avcodec.c:142
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition codec.h:154
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition avcodec.h:294
int av_codec_is_encoder(const AVCodec *codec)
Definition utils.c:79
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition utils.c:446
int av_codec_is_decoder(const AVCodec *codec)
Definition utils.c:85
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition avcodec.h:290
#define AV_CODEC_FLAG2_FIXED_FRAME_SIZE
Force audio encoders to use a fixed frame size.
Definition avcodec.h:359
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition allcodecs.c:999
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition allcodecs.c:994
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition avcodec.c:419
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition utils.c:421
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition codec.h:94
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition codec.h:90
@ AV_CODEC_ID_VP6F
Definition codec_id.h:142
@ AV_CODEC_ID_H264
Definition codec_id.h:77
@ AV_CODEC_ID_NONE
Definition codec_id.h:48
@ AV_CODEC_ID_DXV
Definition codec_id.h:240
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Alias for avcodec_receive_frame_flags(avctx, frame, 0).
Definition avcodec.c:718
int attribute_align_arg avcodec_receive_frame_flags(AVCodecContext *avctx, AVFrame *frame, unsigned flags)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
Definition avcodec.c:705
AVCodecConfig
Definition avcodec.h:2592
int avcodec_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out, int *out_num)
Retrieve a list of all supported values for a given configuration type.
Definition avcodec.c:820
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
Definition avcodec.h:2593
@ AV_CODEC_CONFIG_SAMPLE_FORMAT
AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE.
Definition avcodec.h:2596
@ AV_CODEC_CONFIG_ALPHA_MODE
AVAlphaMode, terminated by AVALPHA_MODE_UNSPECIFIED.
Definition avcodec.h:2600
@ AV_CODEC_CONFIG_FRAME_RATE
AVRational, terminated by {0, 0}.
Definition avcodec.h:2594
@ AV_CODEC_CONFIG_COLOR_SPACE
AVColorSpace, terminated by AVCOL_SPC_UNSPECIFIED.
Definition avcodec.h:2599
@ AV_CODEC_CONFIG_CHROMA_LOCATION
AVChromaLocation, terminated by AVCHROMA_LOC_UNSPECIFIED.
Definition avcodec.h:2601
@ AV_CODEC_CONFIG_COLOR_RANGE
AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED.
Definition avcodec.h:2598
@ AV_CODEC_CONFIG_SAMPLE_RATE
int, terminated by 0
Definition avcodec.h:2595
@ AV_CODEC_CONFIG_CHANNEL_LAYOUT
AVChannelLayout, terminated by {0}.
Definition avcodec.h:2597
int avcodec_default_execute2(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
Definition avcodec.c:86
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition avcodec.c:512
int avcodec_is_open(AVCodecContext *s)
Definition avcodec.c:700
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition avcodec.c:73
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition avcodec.c:387
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition packet.c:621
int av_packet_side_data_to_frame(AVFrameSideData ***psd, int *pnb_sd, const AVPacketSideData *src, unsigned int flags)
Add a new frame side data entry to an array based on existing packet side data, if a matching type ex...
Definition avcodec.c:864
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition packet.h:327
@ AV_PKT_DATA_3D_REFERENCE_DISPLAYS
This side data contains information about the reference display width(s) and reference viewing distan...
Definition packet.h:357
@ AV_PKT_DATA_GAIN_MAP_PARAMS
Parameters describing how to combine this gain map with its base image to form an alternate rendition...
Definition packet.h:391
@ AV_PKT_DATA_ICC_PROFILE
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1.
Definition packet.h:271
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition packet.h:219
@ AV_PKT_DATA_AUDIO_SERVICE_TYPE
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
Definition packet.h:117
@ AV_PKT_DATA_SPHERICAL
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
Definition packet.h:225
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition packet.h:105
@ AV_PKT_DATA_EXIF
Extensible image file format metadata.
Definition packet.h:369
@ AV_PKT_DATA_NB
The number of side data types.
Definition packet.h:401
@ AV_PKT_DATA_STEREO3D
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
Definition packet.h:111
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition packet.h:232
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition packet.h:96
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition packet.c:74
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition packet.c:435
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition packet.c:63
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition bprint.h:218
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition bprint.c:129
void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size)
Init a print buffer using a pre-existing buffer.
Definition bprint.c:84
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition buffer.c:140
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition dict.c:61
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition error.h:74
#define AVERROR(e)
Definition error.h:45
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition frame.c:499
AVFrameSideData * av_frame_side_data_new(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, size_t size, unsigned int flags)
Add new side data entry to an array.
Definition side_data.c:205
void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd)
Free all side data entries and their contents, then zeroes out the values which the pointers are poin...
Definition side_data.c:140
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition frame.c:65
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition frame.c:53
@ AV_FRAME_DATA_EXIF
Exchangeable image file format metadata.
Definition frame.h:263
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition frame.h:131
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition frame.h:137
@ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition frame.h:220
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition frame.h:85
@ AV_FRAME_DATA_AUDIO_SERVICE_TYPE
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition frame.h:114
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition frame.h:77
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition frame.h:120
@ AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
This side data contains information about the reference display width(s) and reference viewing distan...
Definition frame.h:256
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition frame.h:144
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition frame.h:64
@ AV_FRAME_DATA_GAIN_MAP_PARAMS
Parameters describing how to combine this gain map with its base image to form an alternate rendition...
Definition frame.h:314
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition log.h:231
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_VERBOSE
Detailed information.
Definition log.h:226
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
int av_log_get_level(void)
Get the current log level.
Definition log.c:477
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition rational.c:35
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition mathematics.c:37
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition utils.c:28
#define av_fourcc2str(fourcc)
Definition avutil.h:323
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition avutil.h:204
@ AVMEDIA_TYPE_AUDIO
Definition avutil.h:201
@ AVMEDIA_TYPE_SUBTITLE
Definition avutil.h:203
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition avutil.h:202
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition avutil.h:199
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition imgutils.c:289
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition imgutils.c:323
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition samplefmt.c:109
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition samplefmt.c:52
AVSampleFormat
Audio sample formats.
Definition samplefmt.h:55
@ AV_SAMPLE_FMT_NONE
Definition samplefmt.h:56
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition avstring.c:443
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition opt.h:604
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition opt.c:2042
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition opt.c:1771
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition opt.c:904
int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
Set all the options from a given dictionary on an object.
Definition opt.c:2055
misc image utilities
#define r
Definition input.c:42
unsigned offset
Definition libaomenc.c:763
void ff_icc_context_uninit(FFIccContext *s)
Definition fflcms2.c:42
common internal api header.
#define FF_SANE_NB_CHANNELS
Definition internal.h:37
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition jacosubdec.c:67
const char * arg
Definition jacosubdec.c:66
#define av_cold
Definition attributes.h:117
#define FF_PTR_ADD(ptr, off)
Definition internal.h:83
#define attribute_align_arg
Definition internal.h:51
#define AV_MUTEX_INITIALIZER
Definition thread.h:185
static int ff_mutex_unlock(AVMutex *mutex)
Definition thread.h:189
static int ff_mutex_lock(AVMutex *mutex)
Definition thread.h:188
#define AVMutex
Definition thread.h:184
static enum AVPixelFormat pix_fmts[]
Definition libkvazaar.c:296
Memory handling functions.
static const uint64_t c2
Definition murmur3.c:53
int profile
Definition mxfenc.c:2346
AVOptions.
const char * av_color_space_name(enum AVColorSpace space)
Definition pixdesc.c:3884
const char * av_color_range_name(enum AVColorRange range)
Definition pixdesc.c:3800
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition pixdesc.c:3404
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition pixdesc.c:3905
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition pixdesc.c:3851
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition pixdesc.c:3818
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3484
AVChromaLocation
Location of chroma samples.
Definition pixfmt.h:811
@ AVCHROMA_LOC_UNSPECIFIED
Definition pixfmt.h:812
AVColorRange
Visual content value range.
Definition pixfmt.h:757
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:775
@ AVCOL_RANGE_UNSPECIFIED
Definition pixfmt.h:758
@ AVCOL_RANGE_NB
Not part of ABI.
Definition pixfmt.h:793
@ AVCOL_RANGE_JPEG
Full range content.
Definition pixfmt.h:792
AVAlphaMode
Correlation between the alpha channel and color values.
Definition pixfmt.h:825
@ AVALPHA_MODE_NB
Not part of ABI.
Definition pixfmt.h:829
@ AVALPHA_MODE_STRAIGHT
Alpha channel is independent of color values.
Definition pixfmt.h:828
@ AVALPHA_MODE_UNSPECIFIED
Unknown alpha handling, or no alpha channel.
Definition pixfmt.h:826
@ AVALPHA_MODE_PREMULTIPLIED
Alpha channel is multiplied into color values.
Definition pixfmt.h:827
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
@ AVCOL_PRI_UNSPECIFIED
Definition pixfmt.h:650
@ AVCOL_TRC_UNSPECIFIED
Definition pixfmt.h:680
@ AVCOL_SPC_UNSPECIFIED
Definition pixfmt.h:714
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition refstruct.c:121
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition refstruct.h:292
enum AVMediaType codec_type
Definition rtp.c:37
An AVChannelLayout holds information about the channel layout of audio data.
int nb_channels
Number of channels in this layout.
Describe the class of an AVClass context structure.
Definition log.h:76
main external API structure.
Definition avcodec.h:443
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition avcodec.h:644
int width
picture width / height.
Definition avcodec.h:605
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition avcodec.h:1778
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition avcodec.h:1719
AVChannelLayout ch_layout
Audio channel layout.
Definition avcodec.h:1059
int flags2
AV_CODEC_FLAG2_*.
Definition avcodec.h:507
enum AVSampleFormat sample_fmt
audio sample format
Definition avcodec.h:1051
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition avcodec.h:1797
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition avcodec.h:685
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition avcodec.h:468
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition avcodec.h:1381
int nb_coded_side_data
Definition avcodec.h:1779
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition avcodec.h:658
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition avcodec.h:1477
int qmin
minimum quantizer
Definition avcodec.h:1257
enum AVMediaType codec_type
Definition avcodec.h:451
int64_t frame_num
Frame counter, set by libavcodec.
Definition avcodec.h:1893
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition avcodec.h:629
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition avcodec.h:1574
uint8_t * dump_separator
dump format separator.
Definition avcodec.h:1762
enum AVFieldOrder field_order
Field order.
Definition avcodec.h:698
int active_thread_type
Which multithreading methods are in use by the codec.
Definition avcodec.h:1608
char * codec_whitelist
',' separated list of allowed decoders.
Definition avcodec.h:1770
int64_t bit_rate
the average bitrate
Definition avcodec.h:493
const struct AVCodec * codec
Definition avcodec.h:452
int profile
profile
Definition avcodec.h:1646
int nb_decoded_side_data
Definition avcodec.h:1940
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition avcodec.h:1581
enum AVColorSpace colorspace
YUV colorspace type.
Definition avcodec.h:672
int initial_padding
Audio only.
Definition avcodec.h:1118
int sample_rate
samples per second
Definition avcodec.h:1044
int delay
Codec delay.
Definition avcodec.h:588
int refs
number of reference frames
Definition avcodec.h:705
int64_t rc_max_rate
maximum bitrate
Definition avcodec.h:1293
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition avcodec.h:1589
int qmax
maximum quantizer
Definition avcodec.h:1264
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition avcodec.h:665
uint8_t * subtitle_header
Definition avcodec.h:1754
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition avcodec.h:547
int flags
AV_CODEC_FLAG_*.
Definition avcodec.h:500
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition avcodec.h:1939
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition avcodec.h:526
int trailing_padding
Audio only.
Definition avcodec.h:1129
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition avcodec.h:692
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition avcodec.h:1499
enum AVCodecID codec_id
Definition avcodec.h:453
int extradata_size
Definition avcodec.h:527
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition avcodec.h:620
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition avcodec.h:1079
int frame_size
Number of samples per channel in an audio frame.
Definition avcodec.h:1072
struct AVCodecInternal * internal
Private context used for internal data.
Definition avcodec.h:478
void * priv_data
Definition avcodec.h:470
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition internal.h:83
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition internal.h:114
void * thread_ctx
Definition internal.h:73
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition internal.h:90
int needs_close
If this is set, then FFCodec->close (if existing) needs to be called for the parent AVCodecContext.
Definition internal.h:120
int is_frame_mt
This field is set to 1 when frame threading is being used and the parent AVCodecContext of this AVCod...
Definition internal.h:61
struct FramePool * pool
Definition internal.h:69
unsigned int byte_buffer_size
Definition internal.h:96
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition internal.h:95
AVFrame * buffer_frame
Definition internal.h:145
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition internal.h:144
AVFrame * in_frame
The input frame is stored here for encoders implementing the simple encode API.
Definition internal.h:106
int draining
decoding: AVERROR_EOF has been returned from ff_decode_get_packet(); must not be used by decoders tha...
Definition internal.h:139
struct AVRefStructPool * progress_frame_pool
Definition internal.h:71
void * frame_thread_encoder
Definition internal.h:98
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
Definition internal.h:125
struct AVBSFContext * bsf
Definition internal.h:84
AVCodec.
Definition codec.h:175
enum AVCodecID id
Definition codec.h:189
const AVClass * priv_class
AVClass for the private context.
Definition codec.h:197
enum AVMediaType type
Definition codec.h:188
const char * name
Name of the codec implementation.
Definition codec.h:182
int capabilities
Codec capabilities.
Definition codec.h:194
char * key
Definition dict.h:91
char * value
Definition dict.h:92
Structure to hold side data for an AVFrame.
Definition frame.h:334
uint8_t * data
Definition frame.h:336
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition packet.h:431
uint8_t * data
Definition packet.h:432
Rational number (pair of numerator and denominator).
Definition rational.h:58
int num
Numerator.
Definition rational.h:59
int den
Denominator.
Definition rational.h:60
unsigned num_rects
Definition avcodec.h:2111
AVSubtitleRect ** rects
Definition avcodec.h:2112
int priv_data_size
int(* init)(struct AVCodecContext *)
void(* flush)(struct AVCodecContext *)
Flush buffers.
unsigned alpha_modes
This field determines the alpha modes supported by an encoder.
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
int(* close)(struct AVCodecContext *)
int(* get_supported_config)(const struct AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out_configs, int *out_num_configs)
Custom callback for avcodec_get_supported_config().
unsigned color_ranges
This field determines the video color ranges supported by an encoder.
#define av_mallocz(s)
#define av_freep(p)
#define av_log(a,...)
float framerate
Definition av1_levels.c:29
int64_t bitrate
Definition av1_levels.c:47
#define src
Definition vp8dsp.c:248
int size
const char * g
Definition vf_curves.c:128
int len
static double c[64]