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