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/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 {
48  av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
49  av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
50  av_assert0(AV_CODEC_ID_SRT==94216);
51  av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
52 
53  return LIBAVCODEC_VERSION_INT;
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 
93 static AVMutex codec_mutex = AV_MUTEX_INITIALIZER;
94 
95 static void lock_avcodec(const AVCodec *codec)
96 {
97  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
98  ff_mutex_lock(&codec_mutex);
99 }
100 
101 static void unlock_avcodec(const AVCodec *codec)
102 {
103  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
104  ff_mutex_unlock(&codec_mutex);
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 
114 static int64_t get_bit_rate(AVCodecContext *ctx)
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:
122  case AVMEDIA_TYPE_SUBTITLE:
123  case AVMEDIA_TYPE_ATTACHMENT:
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 
144 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
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();
183  avci->compat_decode_frame = av_frame_alloc();
184  avci->compat_encode_packet = av_packet_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();
194  avci->last_pkt_props = 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;
214  av_opt_set_defaults(avctx->priv_data);
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 &&
266  !(codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF) &&
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;
297  avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
298 
299  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
300  avctx->strict_std_compliance > FF_COMPLIANCE_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",
306  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
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 
331  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
332  unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
333  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
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  }
346  if (!HAVE_THREADS && !(codec->caps_internal & FF_CODEC_CAP_AUTO_THREADS))
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) {
366  int channels = av_get_channel_layout_nb_channels(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);
398  avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
399  } else {
400  /* input character encoding is set for a text based subtitle
401  * codec at this point */
402  if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
403  avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
404 
405  if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
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) {
438  av_dict_free(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 &&
446  avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)))
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
458 FF_DISABLE_DEPRECATION_WARNINGS
459  av_frame_free(&avctx->coded_frame);
460 FF_ENABLE_DEPRECATION_WARNINGS
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);
472  av_frame_free(&avci->compat_decode_frame);
473  av_packet_free(&avci->compat_encode_packet);
474 #endif
475  av_frame_free(&avci->buffer_frame);
476  av_packet_free(&avci->buffer_pkt);
477  av_packet_free(&avci->last_pkt_props);
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 
491 void avcodec_flush_buffers(AVCodecContext *avctx)
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.
507  av_assert0(!(caps & AV_CODEC_CAP_FRAME_THREADS));
508  }
509 
510  avci->draining = 0;
511  avci->draining_done = 0;
512  avci->nb_draining_errors = 0;
513  av_frame_unref(avci->buffer_frame);
514 #if FF_API_OLD_ENCDEC
515  av_frame_unref(avci->compat_decode_frame);
516  av_packet_unref(avci->compat_encode_packet);
517 #endif
518  av_packet_unref(avci->buffer_pkt);
519 
520  av_packet_unref(avci->last_pkt_props);
521  while (av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props)) {
522  av_fifo_generic_read(avci->pkt_props,
523  avci->last_pkt_props, sizeof(*avci->last_pkt_props),
524  NULL);
525  av_packet_unref(avci->last_pkt_props);
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 
532  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
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
544 FF_DISABLE_DEPRECATION_WARNINGS
545  if (!avctx->refcounted_frames)
546  av_frame_unref(avci->to_free);
547 FF_ENABLE_DEPRECATION_WARNINGS
548 #endif
549 }
550 
551 void avsubtitle_free(AVSubtitle *sub)
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 
570 av_cold int avcodec_close(AVCodecContext *avctx)
571 {
572  int i;
573 
574  if (!avctx)
575  return 0;
576 
577  if (avcodec_is_open(avctx)) {
578  if (CONFIG_FRAME_THREAD_ENCODER &&
579  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
580  ff_frame_thread_encoder_free(avctx);
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);
590  av_frame_free(&avctx->internal->compat_decode_frame);
591  av_packet_free(&avctx->internal->compat_encode_packet);
592 #endif
593  av_frame_free(&avctx->internal->buffer_frame);
594  av_packet_free(&avctx->internal->buffer_pkt);
595  av_packet_unref(avctx->internal->last_pkt_props);
596  while (av_fifo_size(avctx->internal->pkt_props) >=
597  sizeof(*avctx->internal->last_pkt_props)) {
598  av_fifo_generic_read(avctx->internal->pkt_props,
599  avctx->internal->last_pkt_props,
600  sizeof(*avctx->internal->last_pkt_props),
601  NULL);
602  av_packet_unref(avctx->internal->last_pkt_props);
603  }
604  av_packet_free(&avctx->internal->last_pkt_props);
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);
614  av_freep(&avctx->internal->hwaccel_priv_data);
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 
626  av_buffer_unref(&avctx->hw_frames_ctx);
627  av_buffer_unref(&avctx->hw_device_ctx);
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
636 FF_DISABLE_DEPRECATION_WARNINGS
637  av_frame_free(&avctx->coded_frame);
638 FF_ENABLE_DEPRECATION_WARNINGS
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;
657  int64_t bitrate;
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;
665  codec_type = av_get_media_type_string(enc->codec_type);
666  codec_name = avcodec_get_name(enc->codec_id);
667  profile = avcodec_profile_name(enc->codec_id, enc->profile);
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
679  && av_log_get_level() >= AV_LOG_VERBOSE
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" :
698  unknown_if_null(av_get_pix_fmt_name(enc->pix_fmt)));
699  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
700  enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
701  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
702  if (enc->color_range != AVCOL_RANGE_UNSPECIFIED &&
703  (str = av_color_range_name(enc->color_range)))
704  av_strlcatf(detail, sizeof(detail), "%s, ", str);
705 
706  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
707  enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
708  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
709  const char *col = unknown_if_null(av_color_space_name(enc->colorspace));
710  const char *pri = unknown_if_null(av_color_primaries_name(enc->color_primaries));
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 &&
735  enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED &&
736  (str = av_chroma_location_name(enc->chroma_sample_location)))
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]",
765  enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
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 {
779  if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
780  snprintf(buf + strlen(buf), buf_size - strlen(buf),
781  ", Closed Captions");
782  if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
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 &&
796  (str = av_get_sample_fmt_name(enc->sample_fmt))) {
797  snprintf(buf + strlen(buf), buf_size - strlen(buf),
798  ", %s", str);
799  }
800  if ( enc->bits_per_raw_sample > 0
801  && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
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;
822  case AVMEDIA_TYPE_SUBTITLE:
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 
848 int avcodec_is_open(AVCodecContext *s)
849 {
850  return !!s->internal;
851 }
AVSubtitle
Definition: avcodec.h:2722
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:570
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
AVCodec
AVCodec.
Definition: codec.h:197
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:141
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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: internal.h:41
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:72
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::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
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:1358
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:223
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:32
thread.h
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
ff_thread_flush
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:950
AVCodecInternal::es
EncodeSimpleContext es
Definition: internal.h:170
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: avcodec.c:652
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2193
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
profile
mfxU16 profile
Definition: qsvenc.c:45
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:217
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:216
internal.h
av_lockmgr_register
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
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1193
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:168
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:486
unknown_if_null
static const char * unknown_if_null(const char *str)
Definition: avcodec.c:647
AVLockOp
AVLockOp
Lock operation used by lockmgr.
Definition: avcodec.h:4126
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2016
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:381
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:526
ff_frame_thread_encoder_init
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
Initialize frame thread encoder.
Definition: frame_thread_encoder.c:124
FF_SUB_CHARENC_MODE_PRE_DECODER
#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
AVDictionary
Definition: dict.c:30
ff_thread_init
int ff_thread_init(AVCodecContext *avctx)
Definition: pthread.c:70
av_fifo_generic_read
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
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:848
AVCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:323
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1387
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
av_fifo_reset
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
FF_SUB_CHARENC_MODE_AUTOMATIC
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:2119
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
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:75
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:2982
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:148
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
AV_CODEC_ID_SRT
@ AV_CODEC_ID_SRT
Definition: codec_id.h:531
ff_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2071
EncodeSimpleContext::in_frame
AVFrame * in_frame
Definition: internal.h:126
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:39
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2961
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:545
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1773
get_bit_rate
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: avcodec.c:114
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:2062
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1124
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:941
FF_SUB_CHARENC_MODE_DO_NOTHING
#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
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
unlock_avcodec
static void unlock_avcodec(const AVCodec *codec)
Definition: avcodec.c:101
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:724
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:178
AV_FIELD_TB
@ AV_FIELD_TB
Definition: codec_par.h:41
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:288
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:551
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1354
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:100
av_cold
#define av_cold
Definition: attributes.h:90
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:2184
LIBAVCODEC_VERSION_MICRO
#define LIBAVCODEC_VERSION_MICRO
Definition: version.h:32
AVMutex
#define AVMutex
Definition: thread.h:164
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:1656
AVCodecInternal::to_free
AVFrame * to_free
Definition: internal.h:145
ff_frame_thread_encoder_free
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:255
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:638
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:190
AVCodecInternal::compat_decode_frame
AVFrame * compat_decode_frame
Definition: internal.h:202
AVHWAccel::uninit
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2576
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
op
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
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:37
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
AVPacketSideData::data
uint8_t * data
Definition: packet.h:307
ctx
AVFormatContext * ctx
Definition: movenc.c:48
channels
channels
Definition: aptx.h:33
decode.h
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2248
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1416
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:49
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AVCodecInternal::ds
DecodeSimpleContext ds
Definition: internal.h:152
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:461
AV_FIELD_BT
@ AV_FIELD_BT
Definition: codec_par.h:42
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
ff_thread_free
void ff_thread_free(AVCodecContext *avctx)
Definition: pthread.c:82
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:546
arg
const char * arg
Definition: jacosubdec.c:66
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:2109
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2901
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
LIBAVCODEC_VERSION_INT
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:452
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
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:125
AVCodec::type
enum AVMediaType type
Definition: codec.h:210
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:2194
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:571
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
AV_CODEC_PROP_BITMAP_SUB
#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
AVCodecContext::trailing_padding
int trailing_padding
Audio only.
Definition: avcodec.h:2240
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2919
avcodec_license
const char * avcodec_license(void)
Return the libavcodec license.
Definition: avcodec.c:61
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
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:144
avcodec_version
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: avcodec.c:46
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:208
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:192
AVCodecInternal::bsf
AVBSFContext * bsf
Definition: internal.h:153
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:552
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
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:226
AVCodecInternal::compat_encode_packet
AVPacket * compat_encode_packet
Definition: internal.h:203
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:159
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
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:659
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:79
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: internal.h:80
options
const OptionDef options[]
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:630
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:180
AVCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec.h:305
AV_CODEC_ID_DXV
@ AV_CODEC_ID_DXV
Definition: codec_id.h:240
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AV_MUTEX_INITIALIZER
#define AV_MUTEX_INITIALIZER
Definition: thread.h:165
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:165
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:606
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:93
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
encode
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
lock_avcodec
static void lock_avcodec(const AVCodec *codec)
Definition: avcodec.c:95
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:2101
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:67
ff_mutex_lock
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:168
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
AVCodecInternal
Definition: internal.h:129
AVCodecInternal::byte_buffer_size
unsigned int byte_buffer_size
Definition: internal.h:166
bitrate
int64_t bitrate
Definition: h264_levels.c:131
ff_encode_preinit
int ff_encode_preinit(AVCodecContext *avctx)
Definition: encode.c:527
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
AVCodec::id
enum AVCodecID id
Definition: codec.h:211
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:471
AV_FIELD_BB
@ AV_FIELD_BB
Definition: codec_par.h:40
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
i
int i
Definition: input.c:407
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:80
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2183
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
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: internal.h:49
AVCodecInternal::pkt_props
AVFifoBuffer * pkt_props
Definition: internal.h:160
AVCodecContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:2102
ff_decode_preinit
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
Definition: decode.c:2015
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:2168
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
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:237
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
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:2270
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1178
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:515
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:211
AVCodec::priv_data_size
int priv_data_size
Definition: codec.h:245
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:2218
avcodec.h
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2117
ret
ret
Definition: filter_design.txt:187
AVCodec::caps_internal
int caps_internal
Internal codec capabilities.
Definition: codec.h:328
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:1233
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:491
av_strlcat
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
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1601
LICENSE_PREFIX
#define LICENSE_PREFIX
AVCodecContext::refcounted_frames
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
av_bsf_flush
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:189
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:71
AVCodecContext::coded_frame
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1764
AVCodecContext
main external API structure.
Definition: avcodec.h:536
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:2092
c2
static const uint64_t c2
Definition: murmur3.c:52
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1380
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:1858
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2185
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:191
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:185
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:544
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_codec_ffversion
const char av_codec_ffversion[]
Definition: avcodec.c:44
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:84
av_fifo_size
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
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1227
av_fifo_freep
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:561
FF_MAX_EXTRADATA_SIZE
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:244
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
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:40
avcodec_configuration
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: avcodec.c:56
AVCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec.h:276
codec_string
Definition: dashenc.c:204
AVCodecInternal::thread_ctx
void * thread_ctx
Definition: internal.h:150
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:340
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
convert_header.str
string str
Definition: convert_header.py:20
av_fifo_alloc
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
imgutils.h
DecodeSimpleContext::in_pkt
AVPacket * in_pkt
Definition: internal.h:122
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
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:322
avstring.h
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:107
AVCodecContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avcodec.h:2176
snprintf
#define snprintf
Definition: snprintf.h:34
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2940
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:915
mutex
static AVMutex mutex
Definition: log.c:44
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:2489
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
Generated on Wed Aug 24 2022 21:33:48 for FFmpeg by   doxygen 1.8.17