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"
30 #include "libavutil/channel_layout.h"
31 #include "libavutil/emms.h"
32 #include "libavutil/fifo.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/mem.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/thread.h"
37 #include "avcodec.h"
38 #include "avcodec_internal.h"
39 #include "bsf.h"
40 #include "codec_desc.h"
41 #include "codec_internal.h"
42 #include "decode.h"
43 #include "encode.h"
44 #include "frame_thread_encoder.h"
45 #include "hwconfig.h"
46 #include "internal.h"
47 #include "refstruct.h"
48 #include "thread.h"
49 
50 /**
51  * Maximum size in bytes of extradata.
52  * This value was chosen such that every bit of the buffer is
53  * addressable by a 32-bit signed integer as used by get_bits.
54  */
55 #define FF_MAX_EXTRADATA_SIZE ((1 << 28) - AV_INPUT_BUFFER_PADDING_SIZE)
56 
57 const SideDataMap ff_sd_global_map[] = {
58  { AV_PKT_DATA_REPLAYGAIN , AV_FRAME_DATA_REPLAYGAIN },
59  { AV_PKT_DATA_DISPLAYMATRIX, AV_FRAME_DATA_DISPLAYMATRIX },
60  { AV_PKT_DATA_SPHERICAL, AV_FRAME_DATA_SPHERICAL },
61  { AV_PKT_DATA_STEREO3D, AV_FRAME_DATA_STEREO3D },
62  { AV_PKT_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
63  { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
64  { AV_PKT_DATA_CONTENT_LIGHT_LEVEL, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL },
65  { AV_PKT_DATA_ICC_PROFILE, AV_FRAME_DATA_ICC_PROFILE },
66  { AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT,AV_FRAME_DATA_AMBIENT_VIEWING_ENVIRONMENT },
67  { AV_PKT_DATA_NB },
68 };
69 
70 
71 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
72 {
73  size_t i;
74 
75  for (i = 0; i < count; i++) {
76  size_t offset = i * size;
77  int r = func(c, FF_PTR_ADD((char *)arg, offset));
78  if (ret)
79  ret[i] = r;
80  }
81  emms_c();
82  return 0;
83 }
84 
85 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
86 {
87  int i;
88 
89  for (i = 0; i < count; i++) {
90  int r = func(c, arg, i, 0);
91  if (ret)
92  ret[i] = r;
93  }
94  emms_c();
95  return 0;
96 }
97 
98 static AVMutex codec_mutex = AV_MUTEX_INITIALIZER;
99 
100 static void lock_avcodec(const FFCodec *codec)
101 {
102  if (codec->caps_internal & FF_CODEC_CAP_NOT_INIT_THREADSAFE && codec->init)
103  ff_mutex_lock(&codec_mutex);
104 }
105 
106 static void unlock_avcodec(const FFCodec *codec)
107 {
108  if (codec->caps_internal & FF_CODEC_CAP_NOT_INIT_THREADSAFE && codec->init)
109  ff_mutex_unlock(&codec_mutex);
110 }
111 
112 static int64_t get_bit_rate(AVCodecContext *ctx)
113 {
114  int64_t bit_rate;
115  int bits_per_sample;
116 
117  switch (ctx->codec_type) {
118  case AVMEDIA_TYPE_VIDEO:
119  case AVMEDIA_TYPE_DATA:
120  case AVMEDIA_TYPE_SUBTITLE:
121  case AVMEDIA_TYPE_ATTACHMENT:
122  bit_rate = ctx->bit_rate;
123  break;
124  case AVMEDIA_TYPE_AUDIO:
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 
142 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
143 {
144  int ret = 0;
145  AVCodecInternal *avci;
146  const FFCodec *codec2;
147 
148  if (avcodec_is_open(avctx))
149  return 0;
150 
151  if (!codec && !avctx->codec) {
152  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
153  return AVERROR(EINVAL);
154  }
155  if (codec && avctx->codec && codec != avctx->codec) {
156  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
157  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
158  return AVERROR(EINVAL);
159  }
160  if (!codec)
161  codec = avctx->codec;
162  codec2 = ffcodec(codec);
163 
164  if ((avctx->codec_type != AVMEDIA_TYPE_UNKNOWN && avctx->codec_type != codec->type) ||
165  (avctx->codec_id != AV_CODEC_ID_NONE && avctx->codec_id != codec->id)) {
166  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
167  return AVERROR(EINVAL);
168  }
169 
170  avctx->codec_type = codec->type;
171  avctx->codec_id = codec->id;
172  avctx->codec = codec;
173 
174  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
175  return AVERROR(EINVAL);
176 
177  avci = av_codec_is_decoder(codec) ?
178  ff_decode_internal_alloc() :
179  ff_encode_internal_alloc();
180  if (!avci) {
181  ret = AVERROR(ENOMEM);
182  goto end;
183  }
184  avctx->internal = avci;
185 
186  avci->buffer_frame = av_frame_alloc();
187  avci->buffer_pkt = av_packet_alloc();
188  if (!avci->buffer_frame || !avci->buffer_pkt) {
189  ret = AVERROR(ENOMEM);
190  goto free_and_end;
191  }
192 
193  if (codec2->priv_data_size > 0) {
194  if (!avctx->priv_data) {
195  avctx->priv_data = av_mallocz(codec2->priv_data_size);
196  if (!avctx->priv_data) {
197  ret = AVERROR(ENOMEM);
198  goto free_and_end;
199  }
200  if (codec->priv_class) {
201  *(const AVClass **)avctx->priv_data = codec->priv_class;
202  av_opt_set_defaults(avctx->priv_data);
203  }
204  }
205  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, options)) < 0)
206  goto free_and_end;
207  } else {
208  avctx->priv_data = NULL;
209  }
210  if ((ret = av_opt_set_dict(avctx, options)) < 0)
211  goto free_and_end;
212 
213  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
214  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
215  ret = AVERROR(EINVAL);
216  goto free_and_end;
217  }
218 
219  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
220  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
221  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
222  if (avctx->coded_width && avctx->coded_height)
223  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
224  else if (avctx->width && avctx->height)
225  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
226  if (ret < 0)
227  goto free_and_end;
228  }
229 
230  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
231  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
232  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
233  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
234  ff_set_dimensions(avctx, 0, 0);
235  }
236 
237  if (avctx->width > 0 && avctx->height > 0) {
238  if (av_image_check_sar(avctx->width, avctx->height,
239  avctx->sample_aspect_ratio) < 0) {
240  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
241  avctx->sample_aspect_ratio.num,
242  avctx->sample_aspect_ratio.den);
243  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
244  }
245  }
246 
247  if (avctx->sample_rate < 0) {
248  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
249  ret = AVERROR(EINVAL);
250  goto free_and_end;
251  }
252  if (avctx->block_align < 0) {
253  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
254  ret = AVERROR(EINVAL);
255  goto free_and_end;
256  }
257 
258  /* AV_CODEC_CAP_CHANNEL_CONF is a decoder-only flag; so the code below
259  * in particular checks that nb_channels is set for all audio encoders. */
260  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && !avctx->ch_layout.nb_channels
261  && !(codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)) {
262  av_log(avctx, AV_LOG_ERROR, "%s requires channel layout to be set\n",
263  av_codec_is_decoder(codec) ? "Decoder" : "Encoder");
264  ret = AVERROR(EINVAL);
265  goto free_and_end;
266  }
267  if (avctx->ch_layout.nb_channels && !av_channel_layout_check(&avctx->ch_layout)) {
268  av_log(avctx, AV_LOG_ERROR, "Invalid channel layout\n");
269  ret = AVERROR(EINVAL);
270  goto free_and_end;
271  }
272  if (avctx->ch_layout.nb_channels > FF_SANE_NB_CHANNELS) {
273  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d\n", avctx->ch_layout.nb_channels);
274  ret = AVERROR(EINVAL);
275  goto free_and_end;
276  }
277 
278  avctx->frame_num = 0;
279  avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
280 
281  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
282  avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
283  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
284  const AVCodec *codec2;
285  av_log(avctx, AV_LOG_ERROR,
286  "The %s '%s' is experimental but experimental codecs are not enabled, "
287  "add '-strict %d' if you want to use it.\n",
288  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
289  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
290  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
291  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
292  codec_string, codec2->name);
293  ret = AVERROR_EXPERIMENTAL;
294  goto free_and_end;
295  }
296 
297  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
298  (!avctx->time_base.num || !avctx->time_base.den)) {
299  avctx->time_base.num = 1;
300  avctx->time_base.den = avctx->sample_rate;
301  }
302 
303  if (av_codec_is_encoder(avctx->codec))
304  ret = ff_encode_preinit(avctx);
305  else
306  ret = ff_decode_preinit(avctx);
307  if (ret < 0)
308  goto free_and_end;
309 
310  if (HAVE_THREADS && !avci->frame_thread_encoder) {
311  /* Frame-threaded decoders call FFCodec.init for their child contexts. */
312  lock_avcodec(codec2);
313  ret = ff_thread_init(avctx);
314  unlock_avcodec(codec2);
315  if (ret < 0) {
316  goto free_and_end;
317  }
318  }
319  if (!HAVE_THREADS && !(codec2->caps_internal & FF_CODEC_CAP_AUTO_THREADS))
320  avctx->thread_count = 1;
321 
322  if (!(avctx->active_thread_type & FF_THREAD_FRAME) ||
323  avci->frame_thread_encoder) {
324  if (codec2->init) {
325  lock_avcodec(codec2);
326  ret = codec2->init(avctx);
327  unlock_avcodec(codec2);
328  if (ret < 0) {
329  avci->needs_close = codec2->caps_internal & FF_CODEC_CAP_INIT_CLEANUP;
330  goto free_and_end;
331  }
332  }
333  avci->needs_close = 1;
334  }
335 
336  ret=0;
337 
338  if (av_codec_is_decoder(avctx->codec)) {
339  if (!avctx->bit_rate)
340  avctx->bit_rate = get_bit_rate(avctx);
341 
342  /* validate channel layout from the decoder */
343  if ((avctx->ch_layout.nb_channels && !av_channel_layout_check(&avctx->ch_layout)) ||
344  avctx->ch_layout.nb_channels > FF_SANE_NB_CHANNELS) {
345  ret = AVERROR(EINVAL);
346  goto free_and_end;
347  }
348  if (avctx->bits_per_coded_sample < 0) {
349  ret = AVERROR(EINVAL);
350  goto free_and_end;
351  }
352  }
353  if (codec->priv_class)
354  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
355 
356 end:
357 
358  return ret;
359 free_and_end:
360  ff_codec_close(avctx);
361  goto end;
362 }
363 
364 void avcodec_flush_buffers(AVCodecContext *avctx)
365 {
366  AVCodecInternal *avci = avctx->internal;
367 
368  if (av_codec_is_encoder(avctx->codec)) {
369  int caps = avctx->codec->capabilities;
370 
371  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
372  // Only encoders that explicitly declare support for it can be
373  // flushed. Otherwise, this is a no-op.
374  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
375  "that doesn't support it\n");
376  return;
377  }
378  ff_encode_flush_buffers(avctx);
379  } else
380  ff_decode_flush_buffers(avctx);
381 
382  avci->draining = 0;
383  avci->draining_done = 0;
384  av_frame_unref(avci->buffer_frame);
385  av_packet_unref(avci->buffer_pkt);
386 
387  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
388  ff_thread_flush(avctx);
389  else if (ffcodec(avctx->codec)->flush)
390  ffcodec(avctx->codec)->flush(avctx);
391 }
392 
393 void avsubtitle_free(AVSubtitle *sub)
394 {
395  int i;
396 
397  for (i = 0; i < sub->num_rects; i++) {
398  AVSubtitleRect *const rect = sub->rects[i];
399 
400  av_freep(&rect->data[0]);
401  av_freep(&rect->data[1]);
402  av_freep(&rect->data[2]);
403  av_freep(&rect->data[3]);
404  av_freep(&rect->text);
405  av_freep(&rect->ass);
406 
407  av_freep(&sub->rects[i]);
408  }
409 
410  av_freep(&sub->rects);
411 
412  memset(sub, 0, sizeof(*sub));
413 }
414 
415 av_cold void ff_codec_close(AVCodecContext *avctx)
416 {
417  int i;
418 
419  if (!avctx)
420  return;
421 
422  if (avcodec_is_open(avctx)) {
423  AVCodecInternal *avci = avctx->internal;
424 
425  if (CONFIG_FRAME_THREAD_ENCODER &&
426  avci->frame_thread_encoder && avctx->thread_count > 1) {
427  ff_frame_thread_encoder_free(avctx);
428  }
429  if (HAVE_THREADS && avci->thread_ctx)
430  ff_thread_free(avctx);
431  if (avci->needs_close && ffcodec(avctx->codec)->close)
432  ffcodec(avctx->codec)->close(avctx);
433  avci->byte_buffer_size = 0;
434  av_freep(&avci->byte_buffer);
435  av_frame_free(&avci->buffer_frame);
436  av_packet_free(&avci->buffer_pkt);
437  av_packet_free(&avci->last_pkt_props);
438 
439  av_packet_free(&avci->in_pkt);
440  av_frame_free(&avci->in_frame);
441  av_frame_free(&avci->recon_frame);
442 
443  ff_refstruct_unref(&avci->pool);
444 
445  ff_hwaccel_uninit(avctx);
446 
447  av_bsf_free(&avci->bsf);
448 
449 #if FF_API_DROPCHANGED
450  av_channel_layout_uninit(&avci->initial_ch_layout);
451 #endif
452 
453 #if CONFIG_LCMS2
454  ff_icc_context_uninit(&avci->icc);
455 #endif
456 
457  av_freep(&avctx->internal);
458  }
459 
460  for (i = 0; i < avctx->nb_coded_side_data; i++)
461  av_freep(&avctx->coded_side_data[i].data);
462  av_freep(&avctx->coded_side_data);
463  avctx->nb_coded_side_data = 0;
464 
465  av_buffer_unref(&avctx->hw_frames_ctx);
466  av_buffer_unref(&avctx->hw_device_ctx);
467 
468  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
469  av_opt_free(avctx->priv_data);
470  av_opt_free(avctx);
471  av_freep(&avctx->priv_data);
472  if (av_codec_is_encoder(avctx->codec)) {
473  av_freep(&avctx->extradata);
474  avctx->extradata_size = 0;
475  } else if (av_codec_is_decoder(avctx->codec))
476  av_freep(&avctx->subtitle_header);
477 
478  avctx->codec = NULL;
479  avctx->active_thread_type = 0;
480 }
481 
482 #if FF_API_AVCODEC_CLOSE
483 int avcodec_close(AVCodecContext *avctx)
484 {
485  ff_codec_close(avctx);
486  return 0;
487 }
488 #endif
489 
490 static const char *unknown_if_null(const char *str)
491 {
492  return str ? str : "unknown";
493 }
494 
495 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
496 {
497  const char *codec_type;
498  const char *codec_name;
499  const char *profile = NULL;
500  AVBPrint bprint;
501  int64_t bitrate;
502  int new_line = 0;
503  AVRational display_aspect_ratio;
504  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
505  const char *str;
506 
507  if (!buf || buf_size <= 0)
508  return;
509  av_bprint_init_for_buffer(&bprint, buf, buf_size);
510  codec_type = av_get_media_type_string(enc->codec_type);
511  codec_name = avcodec_get_name(enc->codec_id);
512  profile = avcodec_profile_name(enc->codec_id, enc->profile);
513 
514  av_bprintf(&bprint, "%s: %s", codec_type ? codec_type : "unknown",
515  codec_name);
516  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
517 
518  if (enc->codec && strcmp(enc->codec->name, codec_name))
519  av_bprintf(&bprint, " (%s)", enc->codec->name);
520 
521  if (profile)
522  av_bprintf(&bprint, " (%s)", profile);
523  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
524  && av_log_get_level() >= AV_LOG_VERBOSE
525  && enc->refs)
526  av_bprintf(&bprint, ", %d reference frame%s",
527  enc->refs, enc->refs > 1 ? "s" : "");
528 
529  if (enc->codec_tag)
530  av_bprintf(&bprint, " (%s / 0x%04X)",
531  av_fourcc2str(enc->codec_tag), enc->codec_tag);
532 
533  switch (enc->codec_type) {
534  case AVMEDIA_TYPE_VIDEO:
535  {
536  unsigned len;
537 
538  av_bprintf(&bprint, "%s%s", separator,
539  enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
540  unknown_if_null(av_get_pix_fmt_name(enc->pix_fmt)));
541 
542  av_bprint_chars(&bprint, '(', 1);
543  len = bprint.len;
544 
545  /* The following check ensures that '(' has been written
546  * and therefore allows us to erase it if it turns out
547  * to be unnecessary. */
548  if (!av_bprint_is_complete(&bprint))
549  return;
550 
551  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
552  enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
553  av_bprintf(&bprint, "%d bpc, ", enc->bits_per_raw_sample);
554  if (enc->color_range != AVCOL_RANGE_UNSPECIFIED &&
555  (str = av_color_range_name(enc->color_range)))
556  av_bprintf(&bprint, "%s, ", str);
557 
558  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
559  enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
560  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
561  const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
562  const char *pri = unknown_if_null(av_color_primaries_name(enc->color_primaries));
563  const char *trc = unknown_if_null(av_color_transfer_name(enc->color_trc));
564  if (strcmp(col, pri) || strcmp(col, trc)) {
565  new_line = 1;
566  av_bprintf(&bprint, "%s/%s/%s, ", col, pri, trc);
567  } else
568  av_bprintf(&bprint, "%s, ", col);
569  }
570 
571  if (enc->field_order != AV_FIELD_UNKNOWN) {
572  const char *field_order = "progressive";
573  if (enc->field_order == AV_FIELD_TT)
574  field_order = "top first";
575  else if (enc->field_order == AV_FIELD_BB)
576  field_order = "bottom first";
577  else if (enc->field_order == AV_FIELD_TB)
578  field_order = "top coded first (swapped)";
579  else if (enc->field_order == AV_FIELD_BT)
580  field_order = "bottom coded first (swapped)";
581 
582  av_bprintf(&bprint, "%s, ", field_order);
583  }
584 
585  if (av_log_get_level() >= AV_LOG_VERBOSE &&
586  enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED &&
587  (str = av_chroma_location_name(enc->chroma_sample_location)))
588  av_bprintf(&bprint, "%s, ", str);
589 
590  if (len == bprint.len) {
591  bprint.str[len - 1] = '\0';
592  bprint.len--;
593  } else {
594  if (bprint.len - 2 < bprint.size) {
595  /* Erase the last ", " */
596  bprint.len -= 2;
597  bprint.str[bprint.len] = '\0';
598  }
599  av_bprint_chars(&bprint, ')', 1);
600  }
601  }
602 
603  if (enc->width) {
604  av_bprintf(&bprint, "%s%dx%d", new_line ? separator : ", ",
605  enc->width, enc->height);
606 
607  if (av_log_get_level() >= AV_LOG_VERBOSE &&
608  enc->coded_width && enc->coded_height &&
609  (enc->width != enc->coded_width ||
610  enc->height != enc->coded_height))
611  av_bprintf(&bprint, " (%dx%d)",
612  enc->coded_width, enc->coded_height);
613 
614  if (enc->sample_aspect_ratio.num) {
615  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
616  enc->width * (int64_t)enc->sample_aspect_ratio.num,
617  enc->height * (int64_t)enc->sample_aspect_ratio.den,
618  1024 * 1024);
619  av_bprintf(&bprint, " [SAR %d:%d DAR %d:%d]",
620  enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
621  display_aspect_ratio.num, display_aspect_ratio.den);
622  }
623  if (av_log_get_level() >= AV_LOG_DEBUG) {
624  int g = av_gcd(enc->time_base.num, enc->time_base.den);
625  av_bprintf(&bprint, ", %d/%d",
626  enc->time_base.num / g, enc->time_base.den / g);
627  }
628  }
629  if (encode) {
630  av_bprintf(&bprint, ", q=%d-%d", enc->qmin, enc->qmax);
631  } else {
632  if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
633  av_bprintf(&bprint, ", Closed Captions");
634  if (enc->properties & FF_CODEC_PROPERTY_FILM_GRAIN)
635  av_bprintf(&bprint, ", Film Grain");
636  if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
637  av_bprintf(&bprint, ", lossless");
638  }
639  break;
640  case AVMEDIA_TYPE_AUDIO:
641  av_bprintf(&bprint, "%s", separator);
642 
643  if (enc->sample_rate) {
644  av_bprintf(&bprint, "%d Hz, ", enc->sample_rate);
645  }
646  av_channel_layout_describe_bprint(&enc->ch_layout, &bprint);
647  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE &&
648  (str = av_get_sample_fmt_name(enc->sample_fmt))) {
649  av_bprintf(&bprint, ", %s", str);
650  }
651  if ( enc->bits_per_raw_sample > 0
652  && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
653  av_bprintf(&bprint, " (%d bit)", enc->bits_per_raw_sample);
654  if (av_log_get_level() >= AV_LOG_VERBOSE) {
655  if (enc->initial_padding)
656  av_bprintf(&bprint, ", delay %d", enc->initial_padding);
657  if (enc->trailing_padding)
658  av_bprintf(&bprint, ", padding %d", enc->trailing_padding);
659  }
660  break;
661  case AVMEDIA_TYPE_DATA:
662  if (av_log_get_level() >= AV_LOG_DEBUG) {
663  int g = av_gcd(enc->time_base.num, enc->time_base.den);
664  if (g)
665  av_bprintf(&bprint, ", %d/%d",
666  enc->time_base.num / g, enc->time_base.den / g);
667  }
668  break;
669  case AVMEDIA_TYPE_SUBTITLE:
670  if (enc->width)
671  av_bprintf(&bprint, ", %dx%d", enc->width, enc->height);
672  break;
673  default:
674  return;
675  }
676  if (encode) {
677  if (enc->flags & AV_CODEC_FLAG_PASS1)
678  av_bprintf(&bprint, ", pass 1");
679  if (enc->flags & AV_CODEC_FLAG_PASS2)
680  av_bprintf(&bprint, ", pass 2");
681  }
682  bitrate = get_bit_rate(enc);
683  if (bitrate != 0) {
684  av_bprintf(&bprint, ", %"PRId64" kb/s", bitrate / 1000);
685  } else if (enc->rc_max_rate > 0) {
686  av_bprintf(&bprint, ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
687  }
688 }
689 
690 int avcodec_is_open(AVCodecContext *s)
691 {
692  return !!s->internal;
693 }
694 
695 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
696 {
697  av_frame_unref(frame);
698 
699  if (av_codec_is_decoder(avctx->codec))
700  return ff_decode_receive_frame(avctx, frame);
701  return ff_encode_receive_frame(avctx, frame);
702 }
AVSubtitle
Definition: avcodec.h:2227
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:109
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
AVCodec
AVCodec.
Definition: codec.h:187
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:186
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:1640
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:42
AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
@ AV_PKT_DATA_AMBIENT_VIEWING_ENVIRONMENT
Ambient viewing environment metadata, as defined by H.274.
Definition: packet.h:331
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:2232
opt.h
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:212
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
ff_thread_flush
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:908
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
ff_decode_receive_frame
int ff_decode_receive_frame(struct AVCodecContext *avctx, struct AVFrame *frame)
avcodec_receive_frame() implementation for decoders.
Definition: decode.c:762
rect
Definition: f_ebur128.c:77
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:495
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1861
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1915
AVSubtitleRect
Definition: avcodec.h:2200
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2231
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:968
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
ff_encode_preinit
int ff_encode_preinit(struct AVCodecContext *avctx)
Definition: encode.c:732
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
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:708
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:89
AVCodecInternal::in_frame
AVFrame * in_frame
The input frame is stored here for encoders implementing the simple encode API.
Definition: internal.h:97
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
unknown_if_null
static const char * unknown_if_null(const char *str)
Definition: avcodec.c:490
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:34
FFCodec
Definition: codec_internal.h:127
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1891
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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
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:439
ff_thread_init
int ff_thread_init(AVCodecContext *avctx)
Definition: pthread.c:71
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:690
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1263
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
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
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:74
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3362
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:591
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:204
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:1208
ff_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:189
FFCodec::priv_data_size
int priv_data_size
Definition: codec_internal.h:145
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:100
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:201
fifo.h
bsf.h
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3341
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:454
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
get_bit_rate
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: avcodec.c:112
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1122
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:715
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1910
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
ff_encode_internal_alloc
struct AVCodecInternal * ff_encode_internal_alloc(void)
Definition: encode.c:875
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
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:203
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:393
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1397
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:1796
ff_encode_flush_buffers
void ff_encode_flush_buffers(struct AVCodecContext *avctx)
Definition: encode.c:865
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:199
AVMutex
#define AVMutex
Definition: thread.h:184
emms_c
#define emms_c()
Definition: emms.h:63
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
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:131
ff_decode_preinit
int ff_decode_preinit(struct AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1671
AVCodecInternal::pool
struct FramePool * pool
Definition: internal.h:62
bitrate
int64_t bitrate
Definition: av1_levels.c:47
g
const char * g
Definition: vf_curves.c:128
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
unlock_avcodec
static void unlock_avcodec(const FFCodec *codec)
Definition: avcodec.c:106
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:695
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:483
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1574
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:376
ctx
AVFormatContext * ctx
Definition: movenc.c:49
FFCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec_internal.h:246
decode.h
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:115
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1934
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:1292
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:558
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
ff_thread_free
void ff_thread_free(AVCodecContext *avctx)
Definition: pthread.c:83
FFCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec_internal.h:178
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1798
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:3281
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
FF_MAX_EXTRADATA_SIZE
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: avcodec.c:55
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:66
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:695
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
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:1916
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
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:1133
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:3299
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:142
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:133
ff_sd_global_map
const SideDataMap ff_sd_global_map[]
A map between packet and frame side data types.
Definition: avcodec.c:57
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:652
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:81
AV_PKT_DATA_NB
@ AV_PKT_DATA_NB
The number of side data types.
Definition: packet.h:341
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:973
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:229
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:544
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
options
const OptionDef options[]
AV_FRAME_DATA_REPLAYGAIN
@ AV_FRAME_DATA_REPLAYGAIN
ReplayGain information in the form of the AVReplayGain struct.
Definition: frame.h:77
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
codec_internal.h
AV_CODEC_ID_DXV
@ AV_CODEC_ID_DXV
Definition: codec_id.h:243
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:75
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
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:86
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:306
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:706
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:98
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
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:71
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:63
AVCodecInternal
Definition: internal.h:49
AVCodecInternal::byte_buffer_size
unsigned int byte_buffer_size
Definition: internal.h:87
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1593
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
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:406
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1567
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
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:85
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:1795
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
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:202
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:275
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:74
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:1899
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
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:1497
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2227
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
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:1475
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2030
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:1083
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:364
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:2002
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
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:775
ff_decode_flush_buffers
void ff_decode_flush_buffers(struct AVCodecContext *avctx)
Definition: decode.c:1985
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:105
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:111
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:445
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1601
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:1256
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:1639
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:433
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:1797
FFCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec_internal.h:240
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:132
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:126
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
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:121
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
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:141
ff_codec_close
av_cold void ff_codec_close(AVCodecContext *avctx)
Definition: avcodec.c:415
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
SideDataMap
Definition: avcodec_internal.h:34
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
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:64
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
ff_encode_receive_frame
int ff_encode_receive_frame(struct AVCodecContext *avctx, struct AVFrame *frame)
avcodec_receive_frame() implementation for encoders.
Definition: encode.c:852
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:3734
av_opt_set_dict
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1947
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:1907
lock_avcodec
static void lock_avcodec(const FFCodec *codec)
Definition: avcodec.c:100
codec_desc.h
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3320
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
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:642
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:2885
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:345
Generated on Thu Apr 18 2024 19:21:19 for FFmpeg by   doxygen 1.8.17