FFmpeg
avcodec.c
Go to the documentation of this file.
1 /*
2  * AVCodecContext functions for libavcodec
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * AVCodecContext functions for libavcodec
24  */
25 
26 #include "config.h"
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/bprint.h"
31 #include "libavutil/fifo.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/thread.h"
36 #include "avcodec.h"
37 #include "bsf.h"
38 #include "codec_internal.h"
39 #include "decode.h"
40 #include "encode.h"
41 #include "frame_thread_encoder.h"
42 #include "internal.h"
43 #include "thread.h"
44 
45 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
46 {
47  int i;
48 
49  for (i = 0; i < count; i++) {
50  int r = func(c, (char *)arg + i * size);
51  if (ret)
52  ret[i] = r;
53  }
54  emms_c();
55  return 0;
56 }
57 
58 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
59 {
60  int i;
61 
62  for (i = 0; i < count; i++) {
63  int r = func(c, arg, i, 0);
64  if (ret)
65  ret[i] = r;
66  }
67  emms_c();
68  return 0;
69 }
70 
72 
73 static void lock_avcodec(const FFCodec *codec)
74 {
75  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
77 }
78 
79 static void unlock_avcodec(const FFCodec *codec)
80 {
81  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
83 }
84 
86 {
87  int64_t bit_rate;
88  int bits_per_sample;
89 
90  switch (ctx->codec_type) {
91  case AVMEDIA_TYPE_VIDEO:
92  case AVMEDIA_TYPE_DATA:
95  bit_rate = ctx->bit_rate;
96  break;
97  case AVMEDIA_TYPE_AUDIO:
98  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
99  if (bits_per_sample) {
100  bit_rate = ctx->sample_rate * (int64_t)ctx->ch_layout.nb_channels;
101  if (bit_rate > INT64_MAX / bits_per_sample) {
102  bit_rate = 0;
103  } else
104  bit_rate *= bits_per_sample;
105  } else
106  bit_rate = ctx->bit_rate;
107  break;
108  default:
109  bit_rate = 0;
110  break;
111  }
112  return bit_rate;
113 }
114 
115 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
116 {
117  int ret = 0;
118  AVCodecInternal *avci;
119  const FFCodec *codec2;
120 
121  if (avcodec_is_open(avctx))
122  return 0;
123 
124  if (!codec && !avctx->codec) {
125  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
126  return AVERROR(EINVAL);
127  }
128  if (codec && avctx->codec && codec != avctx->codec) {
129  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
130  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
131  return AVERROR(EINVAL);
132  }
133  if (!codec)
134  codec = avctx->codec;
135  codec2 = ffcodec(codec);
136 
137  if ((avctx->codec_type != AVMEDIA_TYPE_UNKNOWN && avctx->codec_type != codec->type) ||
138  (avctx->codec_id != AV_CODEC_ID_NONE && avctx->codec_id != codec->id)) {
139  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
140  return AVERROR(EINVAL);
141  }
142 
143  avctx->codec_type = codec->type;
144  avctx->codec_id = codec->id;
145  avctx->codec = codec;
146 
147  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
148  return AVERROR(EINVAL);
149 
150  avci = av_mallocz(sizeof(*avci));
151  if (!avci) {
152  ret = AVERROR(ENOMEM);
153  goto end;
154  }
155  avctx->internal = avci;
156 
157  avci->buffer_frame = av_frame_alloc();
158  avci->buffer_pkt = av_packet_alloc();
159  if (!avci->buffer_frame || !avci->buffer_pkt) {
160  ret = AVERROR(ENOMEM);
161  goto free_and_end;
162  }
163 
164  avci->skip_samples_multiplier = 1;
165 
166  if (codec2->priv_data_size > 0) {
167  if (!avctx->priv_data) {
168  avctx->priv_data = av_mallocz(codec2->priv_data_size);
169  if (!avctx->priv_data) {
170  ret = AVERROR(ENOMEM);
171  goto free_and_end;
172  }
173  if (codec->priv_class) {
174  *(const AVClass **)avctx->priv_data = codec->priv_class;
176  }
177  }
178  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, options)) < 0)
179  goto free_and_end;
180  } else {
181  avctx->priv_data = NULL;
182  }
183  if ((ret = av_opt_set_dict(avctx, options)) < 0)
184  goto free_and_end;
185 
186  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
187  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
188  ret = AVERROR(EINVAL);
189  goto free_and_end;
190  }
191 
192  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
193  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
194  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
195  if (avctx->coded_width && avctx->coded_height)
196  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
197  else if (avctx->width && avctx->height)
198  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
199  if (ret < 0)
200  goto free_and_end;
201  }
202 
203  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
204  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
205  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
206  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
207  ff_set_dimensions(avctx, 0, 0);
208  }
209 
210  if (avctx->width > 0 && avctx->height > 0) {
211  if (av_image_check_sar(avctx->width, avctx->height,
212  avctx->sample_aspect_ratio) < 0) {
213  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
214  avctx->sample_aspect_ratio.num,
215  avctx->sample_aspect_ratio.den);
216  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
217  }
218  }
219 
220  if (avctx->sample_rate < 0) {
221  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
222  ret = AVERROR(EINVAL);
223  goto free_and_end;
224  }
225  if (avctx->block_align < 0) {
226  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
227  ret = AVERROR(EINVAL);
228  goto free_and_end;
229  }
230 
231 #if FF_API_OLD_CHANNEL_LAYOUT
233  /* compat wrapper for old-style callers */
234  if (avctx->channel_layout && !avctx->channels)
235  avctx->channels = av_popcount64(avctx->channel_layout);
236 
237  if ((avctx->channels > 0 && avctx->ch_layout.nb_channels != avctx->channels) ||
238  (avctx->channel_layout && (avctx->ch_layout.order != AV_CHANNEL_ORDER_NATIVE ||
239  avctx->ch_layout.u.mask != avctx->channel_layout))) {
240  if (avctx->channel_layout) {
241  av_channel_layout_from_mask(&avctx->ch_layout, avctx->channel_layout);
242  } else {
244  avctx->ch_layout.nb_channels = avctx->channels;
245  }
246  }
248 #endif
249 
251  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d\n", avctx->ch_layout.nb_channels);
252  ret = AVERROR(EINVAL);
253  goto free_and_end;
254  }
255 
256  avctx->frame_number = 0;
258 
259  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
261  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
262  const AVCodec *codec2;
263  av_log(avctx, AV_LOG_ERROR,
264  "The %s '%s' is experimental but experimental codecs are not enabled, "
265  "add '-strict %d' if you want to use it.\n",
267  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
268  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
269  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
270  codec_string, codec2->name);
272  goto free_and_end;
273  }
274 
275  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
276  (!avctx->time_base.num || !avctx->time_base.den)) {
277  avctx->time_base.num = 1;
278  avctx->time_base.den = avctx->sample_rate;
279  }
280 
281  if (av_codec_is_encoder(avctx->codec))
282  ret = ff_encode_preinit(avctx);
283  else
284  ret = ff_decode_preinit(avctx);
285  if (ret < 0)
286  goto free_and_end;
287 
288  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
290  if (ret < 0)
291  goto free_and_end;
292  }
293 
294  if (HAVE_THREADS
295  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
296  /* Frame-threaded decoders call FFCodec.init for their child contexts. */
297  lock_avcodec(codec2);
298  ret = ff_thread_init(avctx);
299  unlock_avcodec(codec2);
300  if (ret < 0) {
301  goto free_and_end;
302  }
303  }
304  if (!HAVE_THREADS && !(codec2->caps_internal & FF_CODEC_CAP_AUTO_THREADS))
305  avctx->thread_count = 1;
306 
307  if (!(avctx->active_thread_type & FF_THREAD_FRAME) ||
308  avci->frame_thread_encoder) {
309  if (codec2->init) {
310  lock_avcodec(codec2);
311  ret = codec2->init(avctx);
312  unlock_avcodec(codec2);
313  if (ret < 0) {
315  goto free_and_end;
316  }
317  }
318  avci->needs_close = 1;
319  }
320 
321  ret=0;
322 
323  if (av_codec_is_decoder(avctx->codec)) {
324  if (!avctx->bit_rate)
325  avctx->bit_rate = get_bit_rate(avctx);
326 
327 #if FF_API_OLD_CHANNEL_LAYOUT
329  /* update the deprecated fields for old-style callers */
330  avctx->channels = avctx->ch_layout.nb_channels;
331  avctx->channel_layout = avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ?
332  avctx->ch_layout.u.mask : 0;
333 
334  /* validate channel layout from the decoder */
335  if (avctx->channel_layout) {
336  int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
337  if (!avctx->channels)
338  avctx->channels = channels;
339  else if (channels != avctx->channels) {
340  char buf[512];
341  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
342  av_log(avctx, AV_LOG_WARNING,
343  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
344  "ignoring specified channel layout\n",
345  buf, channels, avctx->channels);
346  avctx->channel_layout = 0;
347  }
348  }
349  if (avctx->channels && avctx->channels < 0 ||
350  avctx->channels > FF_SANE_NB_CHANNELS) {
351  ret = AVERROR(EINVAL);
352  goto free_and_end;
353  }
354  if (avctx->bits_per_coded_sample < 0) {
355  ret = AVERROR(EINVAL);
356  goto free_and_end;
357  }
359 #endif
360 
361 #if FF_API_AVCTX_TIMEBASE
362  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
363  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
364 #endif
365  }
366  if (codec->priv_class)
367  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
368 
369 end:
370 
371  return ret;
372 free_and_end:
373  avcodec_close(avctx);
374  goto end;
375 }
376 
378 {
379  AVCodecInternal *avci = avctx->internal;
380 
381  if (av_codec_is_encoder(avctx->codec)) {
382  int caps = avctx->codec->capabilities;
383 
384  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
385  // Only encoders that explicitly declare support for it can be
386  // flushed. Otherwise, this is a no-op.
387  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
388  "that doesn't support it\n");
389  return;
390  }
391  if (avci->in_frame)
392  av_frame_unref(avci->in_frame);
393  } else {
395  while (av_fifo_read(avci->pkt_props, avci->last_pkt_props, 1) >= 0)
397 
398  av_packet_unref(avci->in_pkt);
399 
400  avctx->pts_correction_last_pts =
401  avctx->pts_correction_last_dts = INT64_MIN;
402 
403  av_bsf_flush(avci->bsf);
404  }
405 
406  avci->draining = 0;
407  avci->draining_done = 0;
408  avci->nb_draining_errors = 0;
411 
412  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
413  ff_thread_flush(avctx);
414  else if (ffcodec(avctx->codec)->flush)
415  ffcodec(avctx->codec)->flush(avctx);
416 }
417 
419 {
420  int i;
421 
422  for (i = 0; i < sub->num_rects; i++) {
423  AVSubtitleRect *const rect = sub->rects[i];
424 
425  av_freep(&rect->data[0]);
426  av_freep(&rect->data[1]);
427  av_freep(&rect->data[2]);
428  av_freep(&rect->data[3]);
429  av_freep(&rect->text);
430  av_freep(&rect->ass);
431 
432  av_freep(&sub->rects[i]);
433  }
434 
435  av_freep(&sub->rects);
436 
437  memset(sub, 0, sizeof(*sub));
438 }
439 
441 {
442  int i;
443 
444  if (!avctx)
445  return 0;
446 
447  if (avcodec_is_open(avctx)) {
448  AVCodecInternal *avci = avctx->internal;
449 
450  if (CONFIG_FRAME_THREAD_ENCODER &&
451  avci->frame_thread_encoder && avctx->thread_count > 1) {
453  }
454  if (HAVE_THREADS && avci->thread_ctx)
455  ff_thread_free(avctx);
456  if (avci->needs_close && ffcodec(avctx->codec)->close)
457  ffcodec(avctx->codec)->close(avctx);
458  avci->byte_buffer_size = 0;
459  av_freep(&avci->byte_buffer);
460  av_frame_free(&avci->buffer_frame);
461  av_packet_free(&avci->buffer_pkt);
462  if (avci->pkt_props) {
463  while (av_fifo_can_read(avci->pkt_props)) {
465  av_fifo_read(avci->pkt_props, avci->last_pkt_props, 1);
466  }
467  av_fifo_freep2(&avci->pkt_props);
468  }
470 
471  av_packet_free(&avci->in_pkt);
472  av_frame_free(&avci->in_frame);
473 
474  av_buffer_unref(&avci->pool);
475 
476  if (avctx->hwaccel && avctx->hwaccel->uninit)
477  avctx->hwaccel->uninit(avctx);
478  av_freep(&avci->hwaccel_priv_data);
479 
480  av_bsf_free(&avci->bsf);
481 
483 
484  av_freep(&avctx->internal);
485  }
486 
487  for (i = 0; i < avctx->nb_coded_side_data; i++)
488  av_freep(&avctx->coded_side_data[i].data);
489  av_freep(&avctx->coded_side_data);
490  avctx->nb_coded_side_data = 0;
491 
494 
495  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
496  av_opt_free(avctx->priv_data);
497  av_opt_free(avctx);
498  av_freep(&avctx->priv_data);
499  if (av_codec_is_encoder(avctx->codec)) {
500  av_freep(&avctx->extradata);
501  avctx->extradata_size = 0;
502  } else if (av_codec_is_decoder(avctx->codec))
503  av_freep(&avctx->subtitle_header);
504 
505  avctx->codec = NULL;
506  avctx->active_thread_type = 0;
507 
508  return 0;
509 }
510 
511 static const char *unknown_if_null(const char *str)
512 {
513  return str ? str : "unknown";
514 }
515 
516 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
517 {
518  const char *codec_type;
519  const char *codec_name;
520  const char *profile = NULL;
521  AVBPrint bprint;
522  int64_t bitrate;
523  int new_line = 0;
524  AVRational display_aspect_ratio;
525  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
526  const char *str;
527 
528  if (!buf || buf_size <= 0)
529  return;
530  av_bprint_init_for_buffer(&bprint, buf, buf_size);
532  codec_name = avcodec_get_name(enc->codec_id);
534 
535  av_bprintf(&bprint, "%s: %s", codec_type ? codec_type : "unknown",
536  codec_name);
537  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
538 
539  if (enc->codec && strcmp(enc->codec->name, codec_name))
540  av_bprintf(&bprint, " (%s)", enc->codec->name);
541 
542  if (profile)
543  av_bprintf(&bprint, " (%s)", profile);
544  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
546  && enc->refs)
547  av_bprintf(&bprint, ", %d reference frame%s",
548  enc->refs, enc->refs > 1 ? "s" : "");
549 
550  if (enc->codec_tag)
551  av_bprintf(&bprint, " (%s / 0x%04X)",
552  av_fourcc2str(enc->codec_tag), enc->codec_tag);
553 
554  switch (enc->codec_type) {
555  case AVMEDIA_TYPE_VIDEO:
556  {
557  unsigned len;
558 
559  av_bprintf(&bprint, "%s%s", separator,
560  enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
562 
563  av_bprint_chars(&bprint, '(', 1);
564  len = bprint.len;
565 
566  /* The following check ensures that '(' has been written
567  * and therefore allows us to erase it if it turns out
568  * to be unnecessary. */
569  if (!av_bprint_is_complete(&bprint))
570  return;
571 
572  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
574  av_bprintf(&bprint, "%d bpc, ", enc->bits_per_raw_sample);
575  if (enc->color_range != AVCOL_RANGE_UNSPECIFIED &&
577  av_bprintf(&bprint, "%s, ", str);
578 
579  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
582  const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
584  const char *trc = unknown_if_null(av_color_transfer_name(enc->color_trc));
585  if (strcmp(col, pri) || strcmp(col, trc)) {
586  new_line = 1;
587  av_bprintf(&bprint, "%s/%s/%s, ", col, pri, trc);
588  } else
589  av_bprintf(&bprint, "%s, ", col);
590  }
591 
592  if (enc->field_order != AV_FIELD_UNKNOWN) {
593  const char *field_order = "progressive";
594  if (enc->field_order == AV_FIELD_TT)
595  field_order = "top first";
596  else if (enc->field_order == AV_FIELD_BB)
597  field_order = "bottom first";
598  else if (enc->field_order == AV_FIELD_TB)
599  field_order = "top coded first (swapped)";
600  else if (enc->field_order == AV_FIELD_BT)
601  field_order = "bottom coded first (swapped)";
602 
603  av_bprintf(&bprint, "%s, ", field_order);
604  }
605 
606  if (av_log_get_level() >= AV_LOG_VERBOSE &&
609  av_bprintf(&bprint, "%s, ", str);
610 
611  if (len == bprint.len) {
612  bprint.str[len - 1] = '\0';
613  bprint.len--;
614  } else {
615  if (bprint.len - 2 < bprint.size) {
616  /* Erase the last ", " */
617  bprint.len -= 2;
618  bprint.str[bprint.len] = '\0';
619  }
620  av_bprint_chars(&bprint, ')', 1);
621  }
622  }
623 
624  if (enc->width) {
625  av_bprintf(&bprint, "%s%dx%d", new_line ? separator : ", ",
626  enc->width, enc->height);
627 
628  if (av_log_get_level() >= AV_LOG_VERBOSE &&
629  (enc->width != enc->coded_width ||
630  enc->height != enc->coded_height))
631  av_bprintf(&bprint, " (%dx%d)",
632  enc->coded_width, enc->coded_height);
633 
634  if (enc->sample_aspect_ratio.num) {
635  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
636  enc->width * (int64_t)enc->sample_aspect_ratio.num,
637  enc->height * (int64_t)enc->sample_aspect_ratio.den,
638  1024 * 1024);
639  av_bprintf(&bprint, " [SAR %d:%d DAR %d:%d]",
641  display_aspect_ratio.num, display_aspect_ratio.den);
642  }
643  if (av_log_get_level() >= AV_LOG_DEBUG) {
644  int g = av_gcd(enc->time_base.num, enc->time_base.den);
645  av_bprintf(&bprint, ", %d/%d",
646  enc->time_base.num / g, enc->time_base.den / g);
647  }
648  }
649  if (encode) {
650  av_bprintf(&bprint, ", q=%d-%d", enc->qmin, enc->qmax);
651  } else {
653  av_bprintf(&bprint, ", Closed Captions");
655  av_bprintf(&bprint, ", Film Grain");
657  av_bprintf(&bprint, ", lossless");
658  }
659  break;
660  case AVMEDIA_TYPE_AUDIO:
661  av_bprintf(&bprint, "%s", separator);
662 
663  if (enc->sample_rate) {
664  av_bprintf(&bprint, "%d Hz, ", enc->sample_rate);
665  }
666  {
667  char buf[512];
668  int ret = av_channel_layout_describe(&enc->ch_layout, buf, sizeof(buf));
669  if (ret >= 0)
670  av_bprintf(&bprint, "%s", buf);
671  }
672  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE &&
674  av_bprintf(&bprint, ", %s", str);
675  }
676  if ( enc->bits_per_raw_sample > 0
678  av_bprintf(&bprint, " (%d bit)", enc->bits_per_raw_sample);
679  if (av_log_get_level() >= AV_LOG_VERBOSE) {
680  if (enc->initial_padding)
681  av_bprintf(&bprint, ", delay %d", enc->initial_padding);
682  if (enc->trailing_padding)
683  av_bprintf(&bprint, ", padding %d", enc->trailing_padding);
684  }
685  break;
686  case AVMEDIA_TYPE_DATA:
687  if (av_log_get_level() >= AV_LOG_DEBUG) {
688  int g = av_gcd(enc->time_base.num, enc->time_base.den);
689  if (g)
690  av_bprintf(&bprint, ", %d/%d",
691  enc->time_base.num / g, enc->time_base.den / g);
692  }
693  break;
695  if (enc->width)
696  av_bprintf(&bprint, ", %dx%d", enc->width, enc->height);
697  break;
698  default:
699  return;
700  }
701  if (encode) {
702  if (enc->flags & AV_CODEC_FLAG_PASS1)
703  av_bprintf(&bprint, ", pass 1");
704  if (enc->flags & AV_CODEC_FLAG_PASS2)
705  av_bprintf(&bprint, ", pass 2");
706  }
707  bitrate = get_bit_rate(enc);
708  if (bitrate != 0) {
709  av_bprintf(&bprint, ", %"PRId64" kb/s", bitrate / 1000);
710  } else if (enc->rc_max_rate > 0) {
711  av_bprintf(&bprint, ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
712  }
713 }
714 
716 {
717  return !!s->internal;
718 }
av_get_channel_layout_string
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
Definition: channel_layout.c:309
AVSubtitle
Definition: avcodec.h:2306
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:440
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:68
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1379
AVCodec
AVCodec.
Definition: codec.h:196
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:142
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:39
r
const char * r
Definition: vf_curves.c:116
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
opt.h
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:966
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:1458
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1305
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:228
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
av_popcount64
#define av_popcount64
Definition: common.h:152
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
ff_thread_flush
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:902
rect
Definition: f_ebur128.c:76
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:516
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1856
AVSubtitleRect
Definition: avcodec.h:2278
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:928
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:959
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:215
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:995
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:96
AVCodecInternal::in_frame
AVFrame * in_frame
The input frame is stored here for encoders implementing the simple encode API.
Definition: internal.h:104
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:499
unknown_if_null
static const char * unknown_if_null(const char *str)
Definition: avcodec.c:511
FFCodec
Definition: codec_internal.h:112
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:1706
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AVDictionary
Definition: dict.c:30
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:295
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:480
ff_thread_init
int ff_thread_init(AVCodecContext *avctx)
Definition: pthread.c:74
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:715
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:322
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1185
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
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:53
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:73
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:3071
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:61
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_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:173
FFCodec::priv_data_size
int priv_data_size
Definition: codec_internal.h:130
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1733
fifo.h
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:40
bsf.h
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3050
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:398
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1463
get_bit_rate
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: avcodec.c:85
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1724
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:938
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:577
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:183
AV_FIELD_TB
@ AV_FIELD_TB
Definition: codec_par.h:42
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:418
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1322
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:586
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:952
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:105
av_cold
#define av_cold
Definition: attributes.h:90
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:1846
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:112
AVMutex
#define AVMutex
Definition: thread.h:168
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:1766
ff_frame_thread_encoder_init
av_cold int ff_frame_thread_encoder_init(AVCodecContext *avctx)
Initialize frame thread encoder.
Definition: frame_thread_encoder.c:134
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:130
av_bsf_flush
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:191
AVHWAccel::uninit
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2194
g
const char * g
Definition: vf_curves.c:117
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:106
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
unlock_avcodec
static void unlock_avcodec(const FFCodec *codec)
Definition: avcodec.c:79
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:38
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1448
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
channels
channels
Definition: aptx.h:32
FFCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec_internal.h:231
decode.h
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1909
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1214
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:474
AV_FIELD_BT
@ AV_FIELD_BT
Definition: codec_par.h:43
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
ff_thread_free
void ff_thread_free(AVCodecContext *avctx)
Definition: pthread.c:86
FFCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec_internal.h:163
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:399
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1848
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:2990
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:437
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVChannelLayout::u
union AVChannelLayout::@296 u
Details about which channels are present in this layout.
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:455
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:973
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:209
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:1857
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:424
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:439
AVCodecContext::trailing_padding
int trailing_padding
Audio only.
Definition: avcodec.h:1901
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3008
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1718
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:115
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:136
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:132
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:565
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:80
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:185
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:630
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:933
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:512
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:82
options
const OptionDef options[]
codec_internal.h
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:120
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:318
AV_CODEC_ID_DXV
@ AV_CODEC_ID_DXV
Definition: codec_id.h:241
AVCodecInternal::bsf
struct AVBSFContext * bsf
Definition: internal.h:74
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1014
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
AV_MUTEX_INITIALIZER
#define AV_MUTEX_INITIALIZER
Definition: thread.h:169
size
int size
Definition: twinvq_data.h:10344
AVCodecInternal::byte_buffer
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:86
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:273
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:619
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:71
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:241
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:94
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:1763
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:45
ff_mutex_lock
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:172
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:62
AVCodecInternal
Definition: internal.h:48
AVCodecInternal::byte_buffer_size
unsigned int byte_buffer_size
Definition: internal.h:87
bitrate
int64_t bitrate
Definition: h264_levels.c:131
ff_encode_preinit
int ff_encode_preinit(AVCodecContext *avctx)
Definition: encode.c:564
AVCodecInternal::pkt_props
struct AVFifo * pkt_props
Definition: internal.h:81
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1474
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
AVCodec::id
enum AVCodecID id
Definition: codec.h:210
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:74
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:447
AV_FIELD_BB
@ AV_FIELD_BB
Definition: codec_par.h:41
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1441
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:121
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:58
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1845
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:490
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:73
AVCodecContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:1764
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:1529
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:1830
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: codec_internal.h:31
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:477
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:264
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
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:1931
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:980
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2005
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:528
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:139
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:1881
avcodec.h
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:389
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:1043
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:377
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1300
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
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:110
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:389
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1482
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1754
c2
static const uint64_t c2
Definition: murmur3.c:52
channel_layout.h
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1178
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:1548
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
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:776
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1847
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
FFCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec_internal.h:225
ff_frame_thread_encoder_free
av_cold void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:257
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:131
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:125
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:577
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:397
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
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:90
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:70
AVCodecInternal::initial_ch_layout
AVChannelLayout initial_ch_layout
Definition: internal.h:150
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1037
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:414
FF_MAX_EXTRADATA_SIZE
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:168
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
codec_string
Definition: dashenc.c:204
AVCodecInternal::thread_ctx
void * thread_ctx
Definition: internal.h:63
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
convert_header.str
string str
Definition: convert_header.py:20
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3552
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:36
AVCodecContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avcodec.h:1838
lock_avcodec
static void lock_avcodec(const FFCodec *codec)
Definition: avcodec.c:73
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3029
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:759
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:140
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:2582
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:237
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:354