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