FFmpeg
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 "config.h"
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/bprint.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 
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 
100 
101 static void lock_avcodec(const FFCodec *codec)
102 {
103  if (codec->caps_internal & FF_CODEC_CAP_NOT_INIT_THREADSAFE && codec->init)
105 }
106 
107 static void unlock_avcodec(const FFCodec *codec)
108 {
109  if (codec->caps_internal & FF_CODEC_CAP_NOT_INIT_THREADSAFE && codec->init)
111 }
112 
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:
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 
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) ?
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;
219  }
220  }
221  } else {
222  avctx->priv_data = NULL;
223  }
224 
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  }
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;
290 
291  if ((avctx->codec->capabilities & AV_CODEC_CAP_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",
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);
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) {
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)) ||
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 
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  }
389  } else
391 
392  avci->draining = 0;
393  avci->draining_done = 0;
394  if (avci->buffer_frame)
396  if (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 
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 
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) {
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);
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);
458  if (av_codec_is_decoder(avctx->codec))
460 
461  ff_hwaccel_uninit(avctx);
462 
463  av_bsf_free(&avci->bsf);
464 
465 #if FF_API_DROPCHANGED
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;
481  &avctx->nb_decoded_side_data);
482 
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
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;
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);
529  codec_name = avcodec_get_name(enc->codec_id);
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
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" :
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 &&
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 ||
579  const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
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 &&
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]",
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 {
651  av_bprintf(&bprint, ", Closed Captions");
653  av_bprintf(&bprint, ", Film Grain");
655  av_bprintf(&bprint, ", lossless");
656  }
657  break;
658  case AVMEDIA_TYPE_AUDIO:
659  av_bprintf(&bprint, "%s", separator);
660 
661  if (enc->sample_rate) {
662  av_bprintf(&bprint, "%d Hz, ", enc->sample_rate);
663  }
665  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE &&
666  (str = av_get_sample_fmt_name(enc->sample_fmt))) {
667  av_bprintf(&bprint, ", %s", str);
668  }
669  if ( enc->bits_per_raw_sample > 0
671  av_bprintf(&bprint, " (%d bit)", enc->bits_per_raw_sample);
672  if (av_log_get_level() >= AV_LOG_VERBOSE) {
673  if (enc->initial_padding)
674  av_bprintf(&bprint, ", delay %d", enc->initial_padding);
675  if (enc->trailing_padding)
676  av_bprintf(&bprint, ", padding %d", enc->trailing_padding);
677  }
678  break;
679  case AVMEDIA_TYPE_DATA:
680  if (av_log_get_level() >= AV_LOG_DEBUG) {
681  int g = av_gcd(enc->time_base.num, enc->time_base.den);
682  if (g)
683  av_bprintf(&bprint, ", %d/%d",
684  enc->time_base.num / g, enc->time_base.den / g);
685  }
686  break;
688  if (enc->width)
689  av_bprintf(&bprint, ", %dx%d", enc->width, enc->height);
690  break;
691  default:
692  return;
693  }
694  if (encode) {
695  if (enc->flags & AV_CODEC_FLAG_PASS1)
696  av_bprintf(&bprint, ", pass 1");
697  if (enc->flags & AV_CODEC_FLAG_PASS2)
698  av_bprintf(&bprint, ", pass 2");
699  }
700  bitrate = get_bit_rate(enc);
701  if (bitrate != 0) {
702  av_bprintf(&bprint, ", %"PRId64" kb/s", bitrate / 1000);
703  } else if (enc->rc_max_rate > 0) {
704  av_bprintf(&bprint, ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
705  }
706 }
707 
709 {
710  return !!s->internal;
711 }
712 
714 {
716 
717  if (av_codec_is_decoder(avctx->codec))
718  return ff_decode_receive_frame(avctx, frame);
719  return ff_encode_receive_frame(avctx, frame);
720 }
721 
722 #define WRAP_CONFIG(allowed_type, field, field_type, terminator) \
723  do { \
724  static const field_type end = terminator; \
725  if (codec->type != (allowed_type)) \
726  return AVERROR(EINVAL); \
727  *out_configs = (field); \
728  if (out_num_configs) { \
729  for (int i = 0;; i++) { \
730  if (!(field) || !memcmp(&(field)[i], &end, sizeof(end))) { \
731  *out_num_configs = i; \
732  break; \
733  } \
734  } \
735  } \
736  return 0; \
737  } while (0)
738 
739 static const enum AVColorRange color_range_jpeg[] = {
741 };
742 
743 static const enum AVColorRange color_range_mpeg[] = {
745 };
746 
747 static const enum AVColorRange color_range_all[] = {
749 };
750 
751 static const enum AVColorRange *color_range_table[] = {
755 };
756 
758  const AVCodec *codec,
759  enum AVCodecConfig config,
760  unsigned flags,
761  const void **out_configs,
762  int *out_num_configs)
763 {
764  switch (config) {
777 
779  if (codec->type != AVMEDIA_TYPE_VIDEO)
780  return AVERROR(EINVAL);
781  *out_configs = color_range_table[ffcodec(codec)->color_ranges];
782  if (out_num_configs)
783  *out_num_configs = av_popcount(ffcodec(codec)->color_ranges);
784  return 0;
785 
787  *out_configs = NULL;
788  if (out_num_configs)
789  *out_num_configs = 0;
790  return 0;
791  default:
792  return AVERROR(EINVAL);
793  }
794 }
795 
796 int avcodec_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec,
797  enum AVCodecConfig config, unsigned flags,
798  const void **out, int *out_num)
799 {
800  const FFCodec *codec2;
801  int dummy_num = 0;
802  if (!codec)
803  codec = avctx->codec;
804  if (!out_num)
805  out_num = &dummy_num;
806 
807  codec2 = ffcodec(codec);
808  if (codec2->get_supported_config) {
809  return codec2->get_supported_config(avctx, codec, config, flags, out, out_num);
810  } else {
811  return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num);
812  }
813 }
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:605
AVSubtitle
Definition: avcodec.h:2254
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:68
hwconfig.h
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:105
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
AVCodec
AVCodec.
Definition: codec.h:187
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:74
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1678
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: packet.h:327
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:218
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2259
opt.h
ff_thread_free
void ff_thread_free(struct AVCodecContext *s)
Definition: pthread.c:84
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:699
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2103
out
FILE * out
Definition: movenc.c:55
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1064
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:221
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AV_CODEC_CONFIG_SAMPLE_RATE
@ AV_CODEC_CONFIG_SAMPLE_RATE
int, terminated by 0
Definition: avcodec.h:2723
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:219
ff_decode_receive_frame
int ff_decode_receive_frame(struct AVCodecContext *avctx, struct AVFrame *frame)
avcodec_receive_frame() implementation for decoders.
Definition: decode.c:815
rect
Definition: f_ebur128.c:76
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:513
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1880
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1942
int64_t
long long int64_t
Definition: coverity.c:34
color_range_mpeg
static enum AVColorRange color_range_mpeg[]
Definition: avcodec.c:743
AVSubtitleRect
Definition: avcodec.h:2227
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2258
ff_thread_flush
void ff_thread_flush(struct AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:984
color_range_table
static enum AVColorRange * color_range_table[]
Definition: avcodec.c:751
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:1008
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:403
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:692
ff_encode_preinit
int ff_encode_preinit(struct AVCodecContext *avctx)
Definition: encode.c:756
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
internal.h
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:722
AV_CODEC_CONFIG_COLOR_RANGE
@ AV_CODEC_CONFIG_COLOR_RANGE
AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED.
Definition: avcodec.h:2726
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:98
AVCodecInternal::in_frame
AVFrame * in_frame
The input frame is stored here for encoders implementing the simple encode API.
Definition: internal.h:106
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
unknown_if_null
static const char * unknown_if_null(const char *str)
Definition: avcodec.c:508
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:35
FFCodec
Definition: codec_internal.h:127
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1918
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:85
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
AVDictionary
Definition: dict.c:34
AV_CODEC_CONFIG_PIX_FORMAT
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
Definition: avcodec.h:2721
avcodec_profile_name
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:442
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:708
av_popcount
#define av_popcount
Definition: common.h:154
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1281
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:328
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
av_bsf_free
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:52
tf_sess_config.config
config
Definition: tf_sess_config.py:33
thread.h
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:75
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3567
av_channel_layout_describe_bprint
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
Definition: channel_layout.c:598
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:206
av_gcd
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
ff_hwaccel_uninit
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1265
ff_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:189
AVCodec::supported_framerates
const attribute_deprecated AVRational * supported_framerates
Deprecated codec capabilities.
Definition: codec.h:213
FFCodec::priv_data_size
int priv_data_size
Definition: codec_internal.h:151
AV_PKT_DATA_REPLAYGAIN
@ AV_PKT_DATA_REPLAYGAIN
This side data should be associated with an audio stream and contains ReplayGain information in form ...
Definition: packet.h:96
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:203
fifo.h
bsf.h
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3546
av_bprint_init_for_buffer
void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size)
Init a print buffer using a pre-existing buffer.
Definition: bprint.c:85
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
AVCodec::supported_samplerates
const attribute_deprecated int * supported_samplerates
Definition: codec.h:217
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1079
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1601
get_bit_rate
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: avcodec.c:113
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1136
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:729
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
ff_encode_internal_alloc
struct AVCodecInternal * ff_encode_internal_alloc(void)
Definition: encode.c:904
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:647
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:166
av_reduce
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
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:205
refstruct.h
av_image_check_size2
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
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:406
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:151
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1442
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:550
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:685
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
frame_thread_encoder.h
AV_CODEC_CAP_EXPERIMENTAL
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:102
av_cold
#define av_cold
Definition: attributes.h:90
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1815
ff_encode_flush_buffers
void ff_encode_flush_buffers(struct AVCodecContext *avctx)
Definition: encode.c:894
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:201
AVMutex
#define AVMutex
Definition: thread.h:184
av_dict_get
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:62
emms_c
#define emms_c()
Definition: emms.h:63
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:538
AV_CODEC_CONFIG_SAMPLE_FORMAT
@ AV_CODEC_CONFIG_SAMPLE_FORMAT
AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE.
Definition: avcodec.h:2724
WRAP_CONFIG
#define WRAP_CONFIG(allowed_type, field, field_type, terminator)
Definition: avcodec.c:722
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition: internal.h:144
ff_decode_preinit
int ff_decode_preinit(struct AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1943
AVCodecInternal::pool
struct FramePool * pool
Definition: internal.h:69
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2104
bitrate
int64_t bitrate
Definition: av1_levels.c:47
g
const char * g
Definition: vf_curves.c:128
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
unlock_avcodec
static void unlock_avcodec(const FFCodec *codec)
Definition: avcodec.c:107
AV_FRAME_DATA_AUDIO_SERVICE_TYPE
@ 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
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
Definition: avcodec.c:713
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
avcodec_close
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: avcodec.c:501
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1593
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FFCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec_internal.h:244
decode.h
color_range_all
static enum AVColorRange color_range_all[]
Definition: avcodec.c:747
AV_PKT_DATA_STEREO3D
@ 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
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1961
ff_icc_context_uninit
void ff_icc_context_uninit(FFIccContext *s)
Definition: fflcms2.c:42
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1310
av_get_sample_fmt_name
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:51
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
FFCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec_internal.h:176
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1817
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:3486
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
AVCodecInternal::progress_frame_pool
struct AVRefStructPool * progress_frame_pool
Definition: internal.h:71
FF_MAX_EXTRADATA_SIZE
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: avcodec.c:56
AV_FRAME_DATA_SPHERICAL
@ AV_FRAME_DATA_SPHERICAL
The data represents the AVSphericalMapping structure defined in libavutil/spherical....
Definition: frame.h:131
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
av_match_list
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:444
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:709
FFCodec::color_ranges
unsigned color_ranges
This field determines the video color ranges supported by an encoder.
Definition: codec_internal.h:142
av_buffer_unref
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:139
AV_CODEC_CONFIG_FRAME_RATE
@ AV_CODEC_CONFIG_FRAME_RATE
AVRational, terminated by {0, 0}.
Definition: avcodec.h:2722
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1943
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
AV_FRAME_DATA_ICC_PROFILE
@ 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
FF_PTR_ADD
#define FF_PTR_ADD(ptr, off)
Definition: internal.h:80
AVCodecContext::trailing_padding
int trailing_padding
Audio only.
Definition: avcodec.h:1147
options
Definition: swscale.c:42
AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
@ AV_FRAME_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata associated with a video frame.
Definition: frame.h:120
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3504
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:143
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:146
ff_sd_global_map
const SideDataMap ff_sd_global_map[]
A map between packet and frame side data types.
Definition: avcodec.c:58
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:232
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:683
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:90
AV_PKT_DATA_NB
@ AV_PKT_DATA_NB
The number of side data types.
Definition: packet.h:356
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1013
AV_PKT_DATA_SPHERICAL
@ 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_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:558
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
avcodec_get_supported_config
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:796
AV_CODEC_CONFIG_CHANNEL_LAYOUT
@ AV_CODEC_CONFIG_CHANNEL_LAYOUT
AVChannelLayout, terminated by {0}.
Definition: avcodec.h:2725
AV_FRAME_DATA_REPLAYGAIN
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:77
AVCodec::ch_layouts
const attribute_deprecated AVChannelLayout * ch_layouts
Array of supported channel layouts, terminated with a zeroed layout.
Definition: codec.h:241
AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: frame.h:220
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:318
codec_internal.h
AVCodec::pix_fmts
attribute_deprecated enum AVPixelFormat * pix_fmts
Definition: codec.h:215
AV_CODEC_ID_DXV
@ AV_CODEC_ID_DXV
Definition: codec_id.h:245
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:84
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1071
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_MUTEX_INITIALIZER
#define AV_MUTEX_INITIALIZER
Definition: thread.h:185
size
int size
Definition: twinvq_data.h:10344
AVCodecInternal::byte_buffer
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:95
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:330
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:737
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
codec_mutex
static AVMutex codec_mutex
Definition: avcodec.c:99
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:314
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:94
color_range_jpeg
static enum AVColorRange color_range_jpeg[]
Definition: avcodec.c:739
avcodec_default_execute
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: avcodec.c:72
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ff_mutex_lock
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:188
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:64
AVCodecInternal
Definition: internal.h:49
AVCodecInternal::byte_buffer_size
unsigned int byte_buffer_size
Definition: internal.h:96
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1612
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
av_refstruct_unref
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:120
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:78
emms.h
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:409
AVCodecInternal::is_frame_mt
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
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1586
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:136
bprint.h
AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
@ AV_FRAME_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: frame.h:137
ff_default_get_supported_config
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)
Default implementation for avcodec_get_supported_config().
Definition: avcodec.c:757
avcodec_default_execute2
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
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1814
av_frame_side_data_free
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: frame.c:114
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:537
av_opt_set_dict2
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:1962
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:204
AV_PKT_DATA_ICC_PROFILE
@ 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
common.h
AVCodecInternal::in_pkt
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
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
AV_FRAME_DATA_STEREO3D
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
Definition: frame.h:64
AVCodecContext::dump_separator
uint8_t * dump_separator
dump format separator.
Definition: avcodec.h:1926
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:623
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::hw_device_ctx
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1515
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:716
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2233
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
AVCodecContext::height
int height
Definition: avcodec.h:632
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:671
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
AVCodec::sample_fmts
attribute_deprecated enum AVSampleFormat * sample_fmts
Definition: codec.h:219
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1493
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2057
ret
ret
Definition: filter_design.txt:187
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1097
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:374
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_decode_internal_alloc
struct AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:2298
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1397
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:782
ff_decode_flush_buffers
void ff_decode_flush_buffers(struct AVCodecContext *avctx)
Definition: decode.c:2280
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:114
AVCodecInternal::needs_close
int needs_close
If this is set, then FFCodec->close (if existing) needs to be called for the parent AVCodecContext.
Definition: internal.h:120
av_get_media_type_string
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
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1620
c2
static const uint64_t c2
Definition: murmur3.c:53
channel_layout.h
avcodec_internal.h
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1274
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1658
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:441
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1816
FFCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec_internal.h:238
ff_frame_thread_encoder_free
av_cold void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:275
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:145
AVCodecInternal::draining
int draining
decoding: AVERROR_EOF has been returned from ff_decode_get_packet(); must not be used by decoders tha...
Definition: internal.h:139
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:647
AV_PKT_DATA_AUDIO_SERVICE_TYPE
@ 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
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:459
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:154
ff_codec_close
av_cold void ff_codec_close(AVCodecContext *avctx)
Definition: avcodec.c:428
FFCodec::get_supported_config
int(* get_supported_config)(const 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().
Definition: codec_internal.h:271
av_refstruct_pool_uninit
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:476
AVDictionaryEntry
Definition: dict.h:89
SideDataMap
Definition: avcodec_internal.h:34
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
codec_string
Definition: dashenc.c:209
AVCodecInternal::thread_ctx
void * thread_ctx
Definition: internal.h:73
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:632
ff_encode_receive_frame
int ff_encode_receive_frame(struct AVCodecContext *avctx, struct AVFrame *frame)
avcodec_receive_frame() implementation for encoders.
Definition: encode.c:881
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_decode_internal_uninit
void ff_decode_internal_uninit(struct AVCodecContext *avctx)
Definition: decode.c:2311
ff_thread_init
int ff_thread_init(struct AVCodecContext *s)
Definition: pthread.c:72
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:145
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3766
AVDictionaryEntry::value
char * value
Definition: dict.h:91
av_image_check_sar
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
avstring.h
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:37
AVCodecContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avcodec.h:1934
lock_avcodec
static void lock_avcodec(const FFCodec *codec)
Definition: avcodec.c:101
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:682
codec_desc.h
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3525
AVCodecContext::sample_aspect_ratio
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:656
AVCodecConfig
AVCodecConfig
Definition: avcodec.h:2720
av_get_pix_fmt_name
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:3090
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
AV_CODEC_CONFIG_COLOR_SPACE
@ AV_CODEC_CONFIG_COLOR_SPACE
AVColorSpace, terminated by AVCOL_SPC_UNSPECIFIED.
Definition: avcodec.h:2727