FFmpeg  4.4.5
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/imgutils.h"
30 #include "libavutil/mem.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/thread.h"
33 #include "avcodec.h"
34 #include "decode.h"
35 #include "encode.h"
36 #include "frame_thread_encoder.h"
37 #include "internal.h"
38 #include "thread.h"
39 #if CONFIG_ICONV
40 # include <iconv.h>
41 #endif
42 
43 #include "libavutil/ffversion.h"
44 const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
45 
46 unsigned avcodec_version(void)
47 {
52 
54 }
55 
56 const char *avcodec_configuration(void)
57 {
58  return FFMPEG_CONFIGURATION;
59 }
60 
61 const char *avcodec_license(void)
62 {
63 #define LICENSE_PREFIX "libavcodec license: "
64  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
65 }
66 
67 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
68 {
69  int i;
70 
71  for (i = 0; i < count; i++) {
72  int r = func(c, (char *)arg + i * size);
73  if (ret)
74  ret[i] = r;
75  }
76  emms_c();
77  return 0;
78 }
79 
80 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
81 {
82  int i;
83 
84  for (i = 0; i < count; i++) {
85  int r = func(c, arg, i, 0);
86  if (ret)
87  ret[i] = r;
88  }
89  emms_c();
90  return 0;
91 }
92 
94 
95 static void lock_avcodec(const AVCodec *codec)
96 {
97  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
99 }
100 
101 static void unlock_avcodec(const AVCodec *codec)
102 {
103  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
105 }
106 
107 #if FF_API_LOCKMGR
108 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
109 {
110  return 0;
111 }
112 #endif
113 
115 {
116  int64_t bit_rate;
117  int bits_per_sample;
118 
119  switch (ctx->codec_type) {
120  case AVMEDIA_TYPE_VIDEO:
121  case AVMEDIA_TYPE_DATA:
124  bit_rate = ctx->bit_rate;
125  break;
126  case AVMEDIA_TYPE_AUDIO:
127  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
128  if (bits_per_sample) {
129  bit_rate = ctx->sample_rate * (int64_t)ctx->channels;
130  if (bit_rate > INT64_MAX / bits_per_sample) {
131  bit_rate = 0;
132  } else
133  bit_rate *= bits_per_sample;
134  } else
135  bit_rate = ctx->bit_rate;
136  break;
137  default:
138  bit_rate = 0;
139  break;
140  }
141  return bit_rate;
142 }
143 
145 {
146  int ret = 0;
147  int codec_init_ok = 0;
148  AVDictionary *tmp = NULL;
149  AVCodecInternal *avci;
150 
151  if (avcodec_is_open(avctx))
152  return 0;
153 
154  if (!codec && !avctx->codec) {
155  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
156  return AVERROR(EINVAL);
157  }
158  if (codec && avctx->codec && codec != avctx->codec) {
159  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
160  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
161  return AVERROR(EINVAL);
162  }
163  if (!codec)
164  codec = avctx->codec;
165 
166  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
167  return AVERROR(EINVAL);
168 
169  if (options)
170  av_dict_copy(&tmp, *options, 0);
171 
172  lock_avcodec(codec);
173 
174  avci = av_mallocz(sizeof(*avci));
175  if (!avci) {
176  ret = AVERROR(ENOMEM);
177  goto end;
178  }
179  avctx->internal = avci;
180 
181 #if FF_API_OLD_ENCDEC
182  avci->to_free = av_frame_alloc();
185  if (!avci->to_free || !avci->compat_decode_frame || !avci->compat_encode_packet) {
186  ret = AVERROR(ENOMEM);
187  goto free_and_end;
188  }
189 #endif
190  avci->buffer_frame = av_frame_alloc();
191  avci->buffer_pkt = av_packet_alloc();
192  avci->es.in_frame = av_frame_alloc();
193  avci->ds.in_pkt = av_packet_alloc();
195  avci->pkt_props = av_fifo_alloc(sizeof(*avci->last_pkt_props));
196  if (!avci->buffer_frame || !avci->buffer_pkt ||
197  !avci->es.in_frame || !avci->ds.in_pkt ||
198  !avci->last_pkt_props || !avci->pkt_props) {
199  ret = AVERROR(ENOMEM);
200  goto free_and_end;
201  }
202 
203  avci->skip_samples_multiplier = 1;
204 
205  if (codec->priv_data_size > 0) {
206  if (!avctx->priv_data) {
207  avctx->priv_data = av_mallocz(codec->priv_data_size);
208  if (!avctx->priv_data) {
209  ret = AVERROR(ENOMEM);
210  goto free_and_end;
211  }
212  if (codec->priv_class) {
213  *(const AVClass **)avctx->priv_data = codec->priv_class;
215  }
216  }
217  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
218  goto free_and_end;
219  } else {
220  avctx->priv_data = NULL;
221  }
222  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
223  goto free_and_end;
224 
225  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
226  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
227  ret = AVERROR(EINVAL);
228  goto free_and_end;
229  }
230 
231  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
232  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
233  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
234  if (avctx->coded_width && avctx->coded_height)
235  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
236  else if (avctx->width && avctx->height)
237  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
238  if (ret < 0)
239  goto free_and_end;
240  }
241 
242  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
243  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
244  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
245  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
246  ff_set_dimensions(avctx, 0, 0);
247  }
248 
249  if (avctx->width > 0 && avctx->height > 0) {
250  if (av_image_check_sar(avctx->width, avctx->height,
251  avctx->sample_aspect_ratio) < 0) {
252  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
253  avctx->sample_aspect_ratio.num,
254  avctx->sample_aspect_ratio.den);
255  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
256  }
257  }
258 
259  if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
260  av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
261  ret = AVERROR(EINVAL);
262  goto free_and_end;
263  }
264  if (av_codec_is_decoder(codec) &&
265  codec->type == AVMEDIA_TYPE_AUDIO &&
267  avctx->channels == 0) {
268  av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
269  ret = AVERROR(EINVAL);
270  goto free_and_end;
271  }
272 
273  if (avctx->sample_rate < 0) {
274  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
275  ret = AVERROR(EINVAL);
276  goto free_and_end;
277  }
278  if (avctx->block_align < 0) {
279  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
280  ret = AVERROR(EINVAL);
281  goto free_and_end;
282  }
283 
284  avctx->codec = codec;
285  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
286  avctx->codec_id == AV_CODEC_ID_NONE) {
287  avctx->codec_type = codec->type;
288  avctx->codec_id = codec->id;
289  }
290  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
291  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
292  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
293  ret = AVERROR(EINVAL);
294  goto free_and_end;
295  }
296  avctx->frame_number = 0;
298 
299  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
301  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
302  const AVCodec *codec2;
303  av_log(avctx, AV_LOG_ERROR,
304  "The %s '%s' is experimental but experimental codecs are not enabled, "
305  "add '-strict %d' if you want to use it.\n",
307  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
308  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
309  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
310  codec_string, codec2->name);
311  ret = AVERROR_EXPERIMENTAL;
312  goto free_and_end;
313  }
314 
315  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
316  (!avctx->time_base.num || !avctx->time_base.den)) {
317  avctx->time_base.num = 1;
318  avctx->time_base.den = avctx->sample_rate;
319  }
320 
321  if (av_codec_is_encoder(avctx->codec))
322  ret = ff_encode_preinit(avctx);
323  else
324  ret = ff_decode_preinit(avctx);
325  if (ret < 0)
326  goto free_and_end;
327 
328  if (!HAVE_THREADS)
329  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
330 
332  unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
334  lock_avcodec(codec);
335  if (ret < 0)
336  goto free_and_end;
337  }
338 
339  if (HAVE_THREADS
340  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
341  ret = ff_thread_init(avctx);
342  if (ret < 0) {
343  goto free_and_end;
344  }
345  }
347  avctx->thread_count = 1;
348 
349  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
350  || avci->frame_thread_encoder)) {
351  ret = avctx->codec->init(avctx);
352  if (ret < 0) {
353  codec_init_ok = -1;
354  goto free_and_end;
355  }
356  codec_init_ok = 1;
357  }
358 
359  ret=0;
360 
361  if (av_codec_is_decoder(avctx->codec)) {
362  if (!avctx->bit_rate)
363  avctx->bit_rate = get_bit_rate(avctx);
364  /* validate channel layout from the decoder */
365  if (avctx->channel_layout) {
367  if (!avctx->channels)
368  avctx->channels = channels;
369  else if (channels != avctx->channels) {
370  char buf[512];
371  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
372  av_log(avctx, AV_LOG_WARNING,
373  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
374  "ignoring specified channel layout\n",
375  buf, channels, avctx->channels);
376  avctx->channel_layout = 0;
377  }
378  }
379  if (avctx->channels && avctx->channels < 0 ||
380  avctx->channels > FF_SANE_NB_CHANNELS) {
381  ret = AVERROR(EINVAL);
382  goto free_and_end;
383  }
384  if (avctx->bits_per_coded_sample < 0) {
385  ret = AVERROR(EINVAL);
386  goto free_and_end;
387  }
388  if (avctx->sub_charenc) {
389  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
390  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
391  "supported with subtitles codecs\n");
392  ret = AVERROR(EINVAL);
393  goto free_and_end;
394  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
395  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
396  "subtitles character encoding will be ignored\n",
397  avctx->codec_descriptor->name);
399  } else {
400  /* input character encoding is set for a text based subtitle
401  * codec at this point */
404 
406 #if CONFIG_ICONV
407  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
408  if (cd == (iconv_t)-1) {
409  ret = AVERROR(errno);
410  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
411  "with input character encoding \"%s\"\n", avctx->sub_charenc);
412  goto free_and_end;
413  }
414  iconv_close(cd);
415 #else
416  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
417  "conversion needs a libavcodec built with iconv support "
418  "for this codec\n");
419  ret = AVERROR(ENOSYS);
420  goto free_and_end;
421 #endif
422  }
423  }
424  }
425 
426 #if FF_API_AVCTX_TIMEBASE
427  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
428  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
429 #endif
430  }
431  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
432  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
433  }
434 
435 end:
436  unlock_avcodec(codec);
437  if (options) {
439  *options = tmp;
440  }
441 
442  return ret;
443 free_and_end:
444  if (avctx->codec && avctx->codec->close &&
445  (codec_init_ok > 0 || (codec_init_ok < 0 &&
447  avctx->codec->close(avctx);
448 
449  if (HAVE_THREADS && avci->thread_ctx)
450  ff_thread_free(avctx);
451 
452  if (codec->priv_class && avctx->priv_data)
453  av_opt_free(avctx->priv_data);
454  av_opt_free(avctx);
455 
456  if (av_codec_is_encoder(avctx->codec)) {
457 #if FF_API_CODED_FRAME
459  av_frame_free(&avctx->coded_frame);
461 #endif
462  av_freep(&avctx->extradata);
463  avctx->extradata_size = 0;
464  }
465 
466  av_dict_free(&tmp);
467  av_freep(&avctx->priv_data);
468  av_freep(&avctx->subtitle_header);
469 
470 #if FF_API_OLD_ENCDEC
471  av_frame_free(&avci->to_free);
474 #endif
475  av_frame_free(&avci->buffer_frame);
476  av_packet_free(&avci->buffer_pkt);
478  av_fifo_freep(&avci->pkt_props);
479 
480  av_packet_free(&avci->ds.in_pkt);
481  av_frame_free(&avci->es.in_frame);
482  av_bsf_free(&avci->bsf);
483 
484  av_buffer_unref(&avci->pool);
485  av_freep(&avci);
486  avctx->internal = NULL;
487  avctx->codec = NULL;
488  goto end;
489 }
490 
492 {
493  AVCodecInternal *avci = avctx->internal;
494 
495  if (av_codec_is_encoder(avctx->codec)) {
496  int caps = avctx->codec->capabilities;
497 
498  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
499  // Only encoders that explicitly declare support for it can be
500  // flushed. Otherwise, this is a no-op.
501  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
502  "that doesn't support it\n");
503  return;
504  }
505 
506  // We haven't implemented flushing for frame-threaded encoders.
508  }
509 
510  avci->draining = 0;
511  avci->draining_done = 0;
512  avci->nb_draining_errors = 0;
514 #if FF_API_OLD_ENCDEC
517 #endif
519 
521  while (av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props)) {
523  avci->last_pkt_props, sizeof(*avci->last_pkt_props),
524  NULL);
526  }
527  av_fifo_reset(avci->pkt_props);
528 
529  av_frame_unref(avci->es.in_frame);
530  av_packet_unref(avci->ds.in_pkt);
531 
533  ff_thread_flush(avctx);
534  else if (avctx->codec->flush)
535  avctx->codec->flush(avctx);
536 
537  avctx->pts_correction_last_pts =
538  avctx->pts_correction_last_dts = INT64_MIN;
539 
540  if (av_codec_is_decoder(avctx->codec))
541  av_bsf_flush(avci->bsf);
542 
543 #if FF_API_OLD_ENCDEC
545  if (!avctx->refcounted_frames)
546  av_frame_unref(avci->to_free);
548 #endif
549 }
550 
552 {
553  int i;
554 
555  for (i = 0; i < sub->num_rects; i++) {
556  av_freep(&sub->rects[i]->data[0]);
557  av_freep(&sub->rects[i]->data[1]);
558  av_freep(&sub->rects[i]->data[2]);
559  av_freep(&sub->rects[i]->data[3]);
560  av_freep(&sub->rects[i]->text);
561  av_freep(&sub->rects[i]->ass);
562  av_freep(&sub->rects[i]);
563  }
564 
565  av_freep(&sub->rects);
566 
567  memset(sub, 0, sizeof(*sub));
568 }
569 
571 {
572  int i;
573 
574  if (!avctx)
575  return 0;
576 
577  if (avcodec_is_open(avctx)) {
579  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
581  }
582  if (HAVE_THREADS && avctx->internal->thread_ctx)
583  ff_thread_free(avctx);
584  if (avctx->codec && avctx->codec->close)
585  avctx->codec->close(avctx);
586  avctx->internal->byte_buffer_size = 0;
587  av_freep(&avctx->internal->byte_buffer);
588 #if FF_API_OLD_ENCDEC
589  av_frame_free(&avctx->internal->to_free);
592 #endif
596  while (av_fifo_size(avctx->internal->pkt_props) >=
597  sizeof(*avctx->internal->last_pkt_props)) {
599  avctx->internal->last_pkt_props,
600  sizeof(*avctx->internal->last_pkt_props),
601  NULL);
603  }
605  av_fifo_freep(&avctx->internal->pkt_props);
606 
607  av_packet_free(&avctx->internal->ds.in_pkt);
608  av_frame_free(&avctx->internal->es.in_frame);
609 
610  av_buffer_unref(&avctx->internal->pool);
611 
612  if (avctx->hwaccel && avctx->hwaccel->uninit)
613  avctx->hwaccel->uninit(avctx);
615 
616  av_bsf_free(&avctx->internal->bsf);
617 
618  av_freep(&avctx->internal);
619  }
620 
621  for (i = 0; i < avctx->nb_coded_side_data; i++)
622  av_freep(&avctx->coded_side_data[i].data);
623  av_freep(&avctx->coded_side_data);
624  avctx->nb_coded_side_data = 0;
625 
628 
629  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
630  av_opt_free(avctx->priv_data);
631  av_opt_free(avctx);
632  av_freep(&avctx->priv_data);
633  if (av_codec_is_encoder(avctx->codec)) {
634  av_freep(&avctx->extradata);
635 #if FF_API_CODED_FRAME
637  av_frame_free(&avctx->coded_frame);
639 #endif
640  }
641  avctx->codec = NULL;
642  avctx->active_thread_type = 0;
643 
644  return 0;
645 }
646 
647 static const char *unknown_if_null(const char *str)
648 {
649  return str ? str : "unknown";
650 }
651 
652 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
653 {
654  const char *codec_type;
655  const char *codec_name;
656  const char *profile = NULL;
658  int new_line = 0;
659  AVRational display_aspect_ratio;
660  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
661  const char *str;
662 
663  if (!buf || buf_size <= 0)
664  return;
666  codec_name = avcodec_get_name(enc->codec_id);
668 
669  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
670  codec_name);
671  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
672 
673  if (enc->codec && strcmp(enc->codec->name, codec_name))
674  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
675 
676  if (profile)
677  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
678  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
680  && enc->refs)
681  snprintf(buf + strlen(buf), buf_size - strlen(buf),
682  ", %d reference frame%s",
683  enc->refs, enc->refs > 1 ? "s" : "");
684 
685  if (enc->codec_tag)
686  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
687  av_fourcc2str(enc->codec_tag), enc->codec_tag);
688 
689  switch (enc->codec_type) {
690  case AVMEDIA_TYPE_VIDEO:
691  {
692  char detail[256] = "(";
693 
694  av_strlcat(buf, separator, buf_size);
695 
696  snprintf(buf + strlen(buf), buf_size - strlen(buf),
697  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
699  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
701  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
702  if (enc->color_range != AVCOL_RANGE_UNSPECIFIED &&
704  av_strlcatf(detail, sizeof(detail), "%s, ", str);
705 
706  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
709  const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
711  const char *trc = unknown_if_null(av_color_transfer_name(enc->color_trc));
712  if (strcmp(col, pri) || strcmp(col, trc)) {
713  new_line = 1;
714  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
715  col, pri, trc);
716  } else
717  av_strlcatf(detail, sizeof(detail), "%s, ", col);
718  }
719 
720  if (enc->field_order != AV_FIELD_UNKNOWN) {
721  const char *field_order = "progressive";
722  if (enc->field_order == AV_FIELD_TT)
723  field_order = "top first";
724  else if (enc->field_order == AV_FIELD_BB)
725  field_order = "bottom first";
726  else if (enc->field_order == AV_FIELD_TB)
727  field_order = "top coded first (swapped)";
728  else if (enc->field_order == AV_FIELD_BT)
729  field_order = "bottom coded first (swapped)";
730 
731  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
732  }
733 
734  if (av_log_get_level() >= AV_LOG_VERBOSE &&
737  av_strlcatf(detail, sizeof(detail), "%s, ", str);
738 
739  if (strlen(detail) > 1) {
740  detail[strlen(detail) - 2] = 0;
741  av_strlcatf(buf, buf_size, "%s)", detail);
742  }
743  }
744 
745  if (enc->width) {
746  av_strlcat(buf, new_line ? separator : ", ", buf_size);
747 
748  snprintf(buf + strlen(buf), buf_size - strlen(buf),
749  "%dx%d",
750  enc->width, enc->height);
751 
752  if (av_log_get_level() >= AV_LOG_VERBOSE &&
753  (enc->width != enc->coded_width ||
754  enc->height != enc->coded_height))
755  snprintf(buf + strlen(buf), buf_size - strlen(buf),
756  " (%dx%d)", enc->coded_width, enc->coded_height);
757 
758  if (enc->sample_aspect_ratio.num) {
759  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
760  enc->width * (int64_t)enc->sample_aspect_ratio.num,
761  enc->height * (int64_t)enc->sample_aspect_ratio.den,
762  1024 * 1024);
763  snprintf(buf + strlen(buf), buf_size - strlen(buf),
764  " [SAR %d:%d DAR %d:%d]",
766  display_aspect_ratio.num, display_aspect_ratio.den);
767  }
768  if (av_log_get_level() >= AV_LOG_DEBUG) {
769  int g = av_gcd(enc->time_base.num, enc->time_base.den);
770  snprintf(buf + strlen(buf), buf_size - strlen(buf),
771  ", %d/%d",
772  enc->time_base.num / g, enc->time_base.den / g);
773  }
774  }
775  if (encode) {
776  snprintf(buf + strlen(buf), buf_size - strlen(buf),
777  ", q=%d-%d", enc->qmin, enc->qmax);
778  } else {
780  snprintf(buf + strlen(buf), buf_size - strlen(buf),
781  ", Closed Captions");
783  snprintf(buf + strlen(buf), buf_size - strlen(buf),
784  ", lossless");
785  }
786  break;
787  case AVMEDIA_TYPE_AUDIO:
788  av_strlcat(buf, separator, buf_size);
789 
790  if (enc->sample_rate) {
791  snprintf(buf + strlen(buf), buf_size - strlen(buf),
792  "%d Hz, ", enc->sample_rate);
793  }
794  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
795  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE &&
797  snprintf(buf + strlen(buf), buf_size - strlen(buf),
798  ", %s", str);
799  }
800  if ( enc->bits_per_raw_sample > 0
802  snprintf(buf + strlen(buf), buf_size - strlen(buf),
803  " (%d bit)", enc->bits_per_raw_sample);
804  if (av_log_get_level() >= AV_LOG_VERBOSE) {
805  if (enc->initial_padding)
806  snprintf(buf + strlen(buf), buf_size - strlen(buf),
807  ", delay %d", enc->initial_padding);
808  if (enc->trailing_padding)
809  snprintf(buf + strlen(buf), buf_size - strlen(buf),
810  ", padding %d", enc->trailing_padding);
811  }
812  break;
813  case AVMEDIA_TYPE_DATA:
814  if (av_log_get_level() >= AV_LOG_DEBUG) {
815  int g = av_gcd(enc->time_base.num, enc->time_base.den);
816  if (g)
817  snprintf(buf + strlen(buf), buf_size - strlen(buf),
818  ", %d/%d",
819  enc->time_base.num / g, enc->time_base.den / g);
820  }
821  break;
823  if (enc->width)
824  snprintf(buf + strlen(buf), buf_size - strlen(buf),
825  ", %dx%d", enc->width, enc->height);
826  break;
827  default:
828  return;
829  }
830  if (encode) {
831  if (enc->flags & AV_CODEC_FLAG_PASS1)
832  snprintf(buf + strlen(buf), buf_size - strlen(buf),
833  ", pass 1");
834  if (enc->flags & AV_CODEC_FLAG_PASS2)
835  snprintf(buf + strlen(buf), buf_size - strlen(buf),
836  ", pass 2");
837  }
838  bitrate = get_bit_rate(enc);
839  if (bitrate != 0) {
840  snprintf(buf + strlen(buf), buf_size - strlen(buf),
841  ", %"PRId64" kb/s", bitrate / 1000);
842  } else if (enc->rc_max_rate > 0) {
843  snprintf(buf + strlen(buf), buf_size - strlen(buf),
844  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
845  }
846 }
847 
849 {
850  return !!s->internal;
851 }
channels
Definition: aptx.h:33
#define av_cold
Definition: attributes.h:88
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static void lock_avcodec(const AVCodec *codec)
Definition: avcodec.c:95
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:80
static void unlock_avcodec(const AVCodec *codec)
Definition: avcodec.c:101
static const char * unknown_if_null(const char *str)
Definition: avcodec.c:647
static AVMutex codec_mutex
Definition: avcodec.c:93
const char av_codec_ffversion[]
Definition: avcodec.c:44
#define LICENSE_PREFIX
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: avcodec.c:114
Libavcodec external API header.
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2185
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
#define FF_SUB_CHARENC_MODE_DO_NOTHING
do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for inst...
Definition: avcodec.h:2118
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:2184
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:2119
#define FF_SUB_CHARENC_MODE_PRE_DECODER
the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
Definition: avcodec.h:2120
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
#define s(width, name)
Definition: cbs_vp9.c:257
@ AV_FIELD_TT
Definition: codec_par.h:39
@ AV_FIELD_BB
Definition: codec_par.h:40
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
@ AV_FIELD_BT
Definition: codec_par.h:42
@ AV_FIELD_TB
Definition: codec_par.h:41
#define CONFIG_FRAME_THREAD_ENCODER
Definition: config.h:639
#define FFMPEG_CONFIGURATION
Definition: config.h:4
#define HAVE_THREADS
Definition: config.h:275
#define FFMPEG_LICENSE
Definition: config.h:5
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:2015
static float sub(float src0, float src1)
int ff_encode_preinit(AVCodecContext *avctx)
Definition: encode.c:527
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
const OptionDef options[]
#define FFMPEG_VERSION
Definition: ffversion.h:4
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
Initialize frame thread encoder.
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1656
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.
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
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:40
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:144
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:477
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:178
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:74
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:79
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:189
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:941
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:551
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: avcodec.c:56
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: codec_desc.h:97
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: avcodec.c:46
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
const char * avcodec_license(void)
Return the libavcodec license.
Definition: avcodec.c:61
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:570
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: codec.h:100
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:141
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:381
@ AV_CODEC_ID_SRT
Definition: codec_id.h:531
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
@ AV_CODEC_ID_DXV
Definition: codec_id.h:240
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:340
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:636
int av_lockmgr_register(int(*cb)(void **mutex, enum AVLockOp op))
Register a user provided lock manager supporting the operations specified by AVLockOp.
Definition: avcodec.c:108
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:652
AVLockOp
Lock operation used by lockmgr.
Definition: avcodec.h:4126
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:532
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:848
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: avcodec.c:67
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:491
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
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:125
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:72
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
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
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
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:71
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
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:288
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:322
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
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:49
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:93
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:452
misc image utilities
int i
Definition: input.c:407
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:75
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:244
#define FF_SANE_NB_CHANNELS
Definition: internal.h:107
#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: internal.h:41
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
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:84
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
const char * arg
Definition: jacosubdec.c:66
int ff_thread_init(AVCodecContext *avctx)
Definition: pthread.c:70
void ff_thread_free(AVCodecContext *avctx)
Definition: pthread.c:82
#define LIBAVCODEC_VERSION_MICRO
Definition: version.h:32
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
void av_fifo_reset(AVFifoBuffer *f)
Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied.
Definition: fifo.c:71
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
common internal API header
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
#define attribute_align_arg
Definition: internal.h:61
#define emms_c()
Definition: internal.h:54
#define AV_MUTEX_INITIALIZER
Definition: thread.h:165
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:168
#define AVMutex
Definition: thread.h:164
static AVMutex mutex
Definition: log.c:44
Memory handling functions.
static const uint64_t c2
Definition: murmur3.c:52
AVOptions.
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2940
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:2982
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2901
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2961
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2919
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:2489
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:606
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:552
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:461
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:486
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:515
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
mfxU16 profile
Definition: qsvenc.c:45
enum AVMediaType codec_type
Definition: rtp.c:37
#define snprintf
Definition: snprintf.h:34
Describe the class of an AVClass context structure.
Definition: log.h:67
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:2102
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:2092
int width
picture width / height.
Definition: avcodec.h:709
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2193
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:2101
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:1368
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2248
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:2109
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:561
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
int nb_coded_side_data
Definition: avcodec.h:2194
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:2218
int qmin
minimum quantizer
Definition: avcodec.h:1380
enum AVMediaType codec_type
Definition: avcodec.h:544
AVRational framerate
Definition: avcodec.h:2071
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:915
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
uint8_t * dump_separator
dump format separator.
Definition: avcodec.h:2168
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1764
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1193
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2117
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avcodec.h:2176
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
const struct AVCodec * codec
Definition: avcodec.h:545
int profile
profile
Definition: avcodec.h:1858
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2183
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
int initial_padding
Audio only.
Definition: avcodec.h:2062
int sample_rate
samples per second
Definition: avcodec.h:1196
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1227
int refs
number of reference frames
Definition: avcodec.h:1124
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1416
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1773
int qmax
maximum quantizer
Definition: avcodec.h:1387
int coded_height
Definition: avcodec.h:724
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2016
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
int channels
number of audio channels
Definition: avcodec.h:1197
int trailing_padding
Audio only.
Definition: avcodec.h:2240
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1178
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:2270
enum AVCodecID codec_id
Definition: avcodec.h:546
int extradata_size
Definition: avcodec.h:638
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1233
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:571
void * priv_data
Definition: avcodec.h:563
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
int nb_draining_errors
Definition: internal.h:211
AVFrame * to_free
Definition: internal.h:145
void * thread_ctx
Definition: internal.h:150
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:159
AVFifoBuffer * pkt_props
Definition: internal.h:160
unsigned int byte_buffer_size
Definition: internal.h:166
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:165
EncodeSimpleContext es
Definition: internal.h:170
AVBSFContext * bsf
Definition: internal.h:153
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:180
AVFrame * buffer_frame
Definition: internal.h:191
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:190
AVBufferRef * pool
Definition: internal.h:148
DecodeSimpleContext ds
Definition: internal.h:152
int skip_samples_multiplier
Definition: internal.h:208
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:185
AVFrame * compat_decode_frame
Definition: internal.h:202
void * frame_thread_encoder
Definition: internal.h:168
AVPacket * compat_encode_packet
Definition: internal.h:203
AVCodec.
Definition: codec.h:197
enum AVCodecID id
Definition: codec.h:211
int caps_internal
Internal codec capabilities.
Definition: codec.h:328
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:223
int(* init)(struct AVCodecContext *)
Definition: codec.h:276
int priv_data_size
Definition: codec.h:245
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:323
enum AVMediaType type
Definition: codec.h:210
const char * name
Name of the codec implementation.
Definition: codec.h:204
int(* close)(struct AVCodecContext *)
Definition: codec.h:305
int capabilities
Codec capabilities.
Definition: codec.h:216
int depth
Number of bits in the component.
Definition: pixdesc.h:58
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1354
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2576
uint8_t * data
Definition: packet.h:307
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
AVPacket * in_pkt
Definition: internal.h:122
AVFrame * in_frame
Definition: internal.h:126
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
int64_t bitrate
Definition: h264_levels.c:131
AVFormatContext * ctx
Definition: movenc.c:48
int size
const char * g
Definition: vf_curves.c:117
const char * r
Definition: vf_curves.c:116
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
if(ret< 0)
Definition: vf_mcdeint.c:282
static double c[64]