FFmpeg  4.3
utils.c
Go to the documentation of this file.
1 /*
2  * utils for libavcodec
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * utils.
26  */
27 
28 #include "config.h"
29 #include "libavutil/attributes.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/bprint.h"
34 #include "libavutil/crc.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/hwcontext.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/mem_internal.h"
40 #include "libavutil/pixdesc.h"
41 #include "libavutil/imgutils.h"
42 #include "libavutil/samplefmt.h"
43 #include "libavutil/dict.h"
44 #include "libavutil/thread.h"
45 #include "avcodec.h"
46 #include "decode.h"
47 #include "hwconfig.h"
48 #include "libavutil/opt.h"
49 #include "mpegvideo.h"
50 #include "thread.h"
51 #include "frame_thread_encoder.h"
52 #include "internal.h"
53 #include "raw.h"
54 #include "bytestream.h"
55 #include "version.h"
56 #include <stdlib.h>
57 #include <stdarg.h>
58 #include <stdatomic.h>
59 #include <limits.h>
60 #include <float.h>
61 #if CONFIG_ICONV
62 # include <iconv.h>
63 #endif
64 
65 #include "libavutil/ffversion.h"
66 const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
67 
69 
70 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
71 {
72  uint8_t **p = ptr;
73  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
74  av_freep(p);
75  *size = 0;
76  return;
77  }
78  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
79  memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
80 }
81 
82 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
83 {
84  uint8_t **p = ptr;
85  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
86  av_freep(p);
87  *size = 0;
88  return;
89  }
90  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
91  memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
92 }
93 
94 int av_codec_is_encoder(const AVCodec *codec)
95 {
96  return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
97 }
98 
99 int av_codec_is_decoder(const AVCodec *codec)
100 {
101  return codec && (codec->decode || codec->receive_frame);
102 }
103 
105 {
106  int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
107 
108  if (ret < 0)
109  width = height = 0;
110 
111  s->coded_width = width;
112  s->coded_height = height;
113  s->width = AV_CEIL_RSHIFT(width, s->lowres);
114  s->height = AV_CEIL_RSHIFT(height, s->lowres);
115 
116  return ret;
117 }
118 
120 {
121  int ret = av_image_check_sar(avctx->width, avctx->height, sar);
122 
123  if (ret < 0) {
124  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
125  sar.num, sar.den);
126  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
127  return ret;
128  } else {
129  avctx->sample_aspect_ratio = sar;
130  }
131  return 0;
132 }
133 
135  enum AVMatrixEncoding matrix_encoding)
136 {
137  AVFrameSideData *side_data;
138  enum AVMatrixEncoding *data;
139 
141  if (!side_data)
143  sizeof(enum AVMatrixEncoding));
144 
145  if (!side_data)
146  return AVERROR(ENOMEM);
147 
148  data = (enum AVMatrixEncoding*)side_data->data;
149  *data = matrix_encoding;
150 
151  return 0;
152 }
153 
155  int linesize_align[AV_NUM_DATA_POINTERS])
156 {
157  int i;
158  int w_align = 1;
159  int h_align = 1;
160  AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
161 
162  if (desc) {
163  w_align = 1 << desc->log2_chroma_w;
164  h_align = 1 << desc->log2_chroma_h;
165  }
166 
167  switch (s->pix_fmt) {
168  case AV_PIX_FMT_YUV420P:
169  case AV_PIX_FMT_YUYV422:
170  case AV_PIX_FMT_YVYU422:
171  case AV_PIX_FMT_UYVY422:
172  case AV_PIX_FMT_YUV422P:
173  case AV_PIX_FMT_YUV440P:
174  case AV_PIX_FMT_YUV444P:
175  case AV_PIX_FMT_GBRP:
176  case AV_PIX_FMT_GBRAP:
177  case AV_PIX_FMT_GRAY8:
178  case AV_PIX_FMT_GRAY16BE:
179  case AV_PIX_FMT_GRAY16LE:
180  case AV_PIX_FMT_YUVJ420P:
181  case AV_PIX_FMT_YUVJ422P:
182  case AV_PIX_FMT_YUVJ440P:
183  case AV_PIX_FMT_YUVJ444P:
184  case AV_PIX_FMT_YUVA420P:
185  case AV_PIX_FMT_YUVA422P:
186  case AV_PIX_FMT_YUVA444P:
243  case AV_PIX_FMT_GBRP9LE:
244  case AV_PIX_FMT_GBRP9BE:
245  case AV_PIX_FMT_GBRP10LE:
246  case AV_PIX_FMT_GBRP10BE:
247  case AV_PIX_FMT_GBRP12LE:
248  case AV_PIX_FMT_GBRP12BE:
249  case AV_PIX_FMT_GBRP14LE:
250  case AV_PIX_FMT_GBRP14BE:
251  case AV_PIX_FMT_GBRP16LE:
252  case AV_PIX_FMT_GBRP16BE:
257  w_align = 16; //FIXME assume 16 pixel per macroblock
258  h_align = 16 * 2; // interlaced needs 2 macroblocks height
259  break;
260  case AV_PIX_FMT_YUV411P:
261  case AV_PIX_FMT_YUVJ411P:
263  w_align = 32;
264  h_align = 16 * 2;
265  break;
266  case AV_PIX_FMT_YUV410P:
267  if (s->codec_id == AV_CODEC_ID_SVQ1) {
268  w_align = 64;
269  h_align = 64;
270  }
271  break;
272  case AV_PIX_FMT_RGB555:
273  if (s->codec_id == AV_CODEC_ID_RPZA) {
274  w_align = 4;
275  h_align = 4;
276  }
277  if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
278  w_align = 8;
279  h_align = 8;
280  }
281  break;
282  case AV_PIX_FMT_PAL8:
283  case AV_PIX_FMT_BGR8:
284  case AV_PIX_FMT_RGB8:
285  if (s->codec_id == AV_CODEC_ID_SMC ||
286  s->codec_id == AV_CODEC_ID_CINEPAK) {
287  w_align = 4;
288  h_align = 4;
289  }
290  if (s->codec_id == AV_CODEC_ID_JV ||
291  s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
292  w_align = 8;
293  h_align = 8;
294  }
295  break;
296  case AV_PIX_FMT_BGR24:
297  if ((s->codec_id == AV_CODEC_ID_MSZH) ||
298  (s->codec_id == AV_CODEC_ID_ZLIB)) {
299  w_align = 4;
300  h_align = 4;
301  }
302  break;
303  case AV_PIX_FMT_RGB24:
304  if (s->codec_id == AV_CODEC_ID_CINEPAK) {
305  w_align = 4;
306  h_align = 4;
307  }
308  break;
309  default:
310  break;
311  }
312 
313  if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
314  w_align = FFMAX(w_align, 8);
315  }
316 
317  *width = FFALIGN(*width, w_align);
318  *height = FFALIGN(*height, h_align);
319  if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
320  s->codec_id == AV_CODEC_ID_VP5 || s->codec_id == AV_CODEC_ID_VP6 ||
321  s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A
322  ) {
323  // some of the optimized chroma MC reads one line too much
324  // which is also done in mpeg decoders with lowres > 0
325  *height += 2;
326 
327  // H.264 uses edge emulation for out of frame motion vectors, for this
328  // it requires a temporary area large enough to hold a 21x21 block,
329  // increasing witdth ensure that the temporary area is large enough,
330  // the next rounded up width is 32
331  *width = FFMAX(*width, 32);
332  }
333 
334  for (i = 0; i < 4; i++)
335  linesize_align[i] = STRIDE_ALIGN;
336 }
337 
339 {
340  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
341  int chroma_shift = desc->log2_chroma_w;
342  int linesize_align[AV_NUM_DATA_POINTERS];
343  int align;
344 
345  avcodec_align_dimensions2(s, width, height, linesize_align);
346  align = FFMAX(linesize_align[0], linesize_align[3]);
347  linesize_align[1] <<= chroma_shift;
348  linesize_align[2] <<= chroma_shift;
349  align = FFMAX3(align, linesize_align[1], linesize_align[2]);
350  *width = FFALIGN(*width, align);
351 }
352 
353 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
354 {
355  if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
356  return AVERROR(EINVAL);
357  pos--;
358 
359  *xpos = (pos&1) * 128;
360  *ypos = ((pos>>1)^(pos<4)) * 128;
361 
362  return 0;
363 }
364 
366 {
367  int pos, xout, yout;
368 
370  if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
371  return pos;
372  }
374 }
375 
377  enum AVSampleFormat sample_fmt, const uint8_t *buf,
378  int buf_size, int align)
379 {
380  int ch, planar, needed_size, ret = 0;
381 
383  frame->nb_samples, sample_fmt,
384  align);
385  if (buf_size < needed_size)
386  return AVERROR(EINVAL);
387 
388  planar = av_sample_fmt_is_planar(sample_fmt);
390  if (!(frame->extended_data = av_mallocz_array(nb_channels,
391  sizeof(*frame->extended_data))))
392  return AVERROR(ENOMEM);
393  } else {
394  frame->extended_data = frame->data;
395  }
396 
397  if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
398  (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
399  sample_fmt, align)) < 0) {
400  if (frame->extended_data != frame->data)
401  av_freep(&frame->extended_data);
402  return ret;
403  }
404  if (frame->extended_data != frame->data) {
405  for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
406  frame->data[ch] = frame->extended_data[ch];
407  }
408 
409  return ret;
410 }
411 
412 void ff_color_frame(AVFrame *frame, const int c[4])
413 {
415  int p, y;
416 
418 
419  for (p = 0; p<desc->nb_components; p++) {
420  uint8_t *dst = frame->data[p];
421  int is_chroma = p == 1 || p == 2;
422  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
423  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
424  if (desc->comp[0].depth >= 9) {
425  ((uint16_t*)dst)[0] = c[p];
426  av_memcpy_backptr(dst + 2, 2, bytes - 2);
427  dst += frame->linesize[p];
428  for (y = 1; y < height; y++) {
429  memcpy(dst, frame->data[p], 2*bytes);
430  dst += frame->linesize[p];
431  }
432  } else {
433  for (y = 0; y < height; y++) {
434  memset(dst, c[p], bytes);
435  dst += frame->linesize[p];
436  }
437  }
438  }
439 }
440 
441 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
442 {
443  int i;
444 
445  for (i = 0; i < count; i++) {
446  int r = func(c, (char *)arg + i * size);
447  if (ret)
448  ret[i] = r;
449  }
450  emms_c();
451  return 0;
452 }
453 
454 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
455 {
456  int i;
457 
458  for (i = 0; i < count; i++) {
459  int r = func(c, arg, i, 0);
460  if (ret)
461  ret[i] = r;
462  }
463  emms_c();
464  return 0;
465 }
466 
468  unsigned int fourcc)
469 {
470  while (tags->pix_fmt >= 0) {
471  if (tags->fourcc == fourcc)
472  return tags->pix_fmt;
473  tags++;
474  }
475  return AV_PIX_FMT_NONE;
476 }
477 
478 #if FF_API_CODEC_GET_SET
479 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
480 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
482 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
483 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
484 
486 {
487  return codec->properties;
488 }
489 
491 {
492  return codec->max_lowres;
493 }
494 #endif
495 
498 }
499 
501 {
502  int64_t bit_rate;
503  int bits_per_sample;
504 
505  switch (ctx->codec_type) {
506  case AVMEDIA_TYPE_VIDEO:
507  case AVMEDIA_TYPE_DATA:
510  bit_rate = ctx->bit_rate;
511  break;
512  case AVMEDIA_TYPE_AUDIO:
513  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
514  bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
515  break;
516  default:
517  bit_rate = 0;
518  break;
519  }
520  return bit_rate;
521 }
522 
523 
524 static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
525 {
526  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
528 }
529 
530 static void ff_unlock_avcodec(const AVCodec *codec)
531 {
532  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
534 }
535 
537 {
538  int ret = 0;
539 
540  ff_unlock_avcodec(codec);
541 
542  ret = avcodec_open2(avctx, codec, options);
543 
544  ff_lock_avcodec(avctx, codec);
545  return ret;
546 }
547 
549 {
550  int ret = 0;
551  int codec_init_ok = 0;
552  AVDictionary *tmp = NULL;
553  const AVPixFmtDescriptor *pixdesc;
554  AVCodecInternal *avci;
555 
556  if (avcodec_is_open(avctx))
557  return 0;
558 
559  if (!codec && !avctx->codec) {
560  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
561  return AVERROR(EINVAL);
562  }
563  if (codec && avctx->codec && codec != avctx->codec) {
564  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
565  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
566  return AVERROR(EINVAL);
567  }
568  if (!codec)
569  codec = avctx->codec;
570 
571  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
572  return AVERROR(EINVAL);
573 
574  if (options)
575  av_dict_copy(&tmp, *options, 0);
576 
577  ff_lock_avcodec(avctx, codec);
578 
579  avci = av_mallocz(sizeof(*avci));
580  if (!avci) {
581  ret = AVERROR(ENOMEM);
582  goto end;
583  }
584  avctx->internal = avci;
585 
586  avci->to_free = av_frame_alloc();
588  avci->buffer_frame = av_frame_alloc();
589  avci->buffer_pkt = av_packet_alloc();
590  avci->ds.in_pkt = av_packet_alloc();
592  if (!avci->to_free || !avci->compat_decode_frame ||
593  !avci->buffer_frame || !avci->buffer_pkt ||
594  !avci->ds.in_pkt || !avci->last_pkt_props) {
595  ret = AVERROR(ENOMEM);
596  goto free_and_end;
597  }
598 
599  avci->skip_samples_multiplier = 1;
600 
601  if (codec->priv_data_size > 0) {
602  if (!avctx->priv_data) {
603  avctx->priv_data = av_mallocz(codec->priv_data_size);
604  if (!avctx->priv_data) {
605  ret = AVERROR(ENOMEM);
606  goto end;
607  }
608  if (codec->priv_class) {
609  *(const AVClass **)avctx->priv_data = codec->priv_class;
611  }
612  }
613  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
614  goto free_and_end;
615  } else {
616  avctx->priv_data = NULL;
617  }
618  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
619  goto free_and_end;
620 
621  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
622  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
623  ret = AVERROR(EINVAL);
624  goto free_and_end;
625  }
626 
627  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
628  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
629  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
630  if (avctx->coded_width && avctx->coded_height)
631  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
632  else if (avctx->width && avctx->height)
633  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
634  if (ret < 0)
635  goto free_and_end;
636  }
637 
638  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
639  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
640  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
641  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
642  ff_set_dimensions(avctx, 0, 0);
643  }
644 
645  if (avctx->width > 0 && avctx->height > 0) {
646  if (av_image_check_sar(avctx->width, avctx->height,
647  avctx->sample_aspect_ratio) < 0) {
648  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
649  avctx->sample_aspect_ratio.num,
650  avctx->sample_aspect_ratio.den);
651  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
652  }
653  }
654 
655  /* if the decoder init function was already called previously,
656  * free the already allocated subtitle_header before overwriting it */
657  if (av_codec_is_decoder(codec))
658  av_freep(&avctx->subtitle_header);
659 
660  if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
661  av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
662  ret = AVERROR(EINVAL);
663  goto free_and_end;
664  }
665  if (avctx->sample_rate < 0) {
666  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
667  ret = AVERROR(EINVAL);
668  goto free_and_end;
669  }
670  if (avctx->block_align < 0) {
671  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
672  ret = AVERROR(EINVAL);
673  goto free_and_end;
674  }
675 
676  avctx->codec = codec;
677  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
678  avctx->codec_id == AV_CODEC_ID_NONE) {
679  avctx->codec_type = codec->type;
680  avctx->codec_id = codec->id;
681  }
682  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
683  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
684  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
685  ret = AVERROR(EINVAL);
686  goto free_and_end;
687  }
688  avctx->frame_number = 0;
690 
691  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
693  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
694  AVCodec *codec2;
695  av_log(avctx, AV_LOG_ERROR,
696  "The %s '%s' is experimental but experimental codecs are not enabled, "
697  "add '-strict %d' if you want to use it.\n",
699  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
700  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
701  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
702  codec_string, codec2->name);
704  goto free_and_end;
705  }
706 
707  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
708  (!avctx->time_base.num || !avctx->time_base.den)) {
709  avctx->time_base.num = 1;
710  avctx->time_base.den = avctx->sample_rate;
711  }
712 
713  if (!HAVE_THREADS)
714  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
715 
717  ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
719  ff_lock_avcodec(avctx, codec);
720  if (ret < 0)
721  goto free_and_end;
722  }
723 
724  if (av_codec_is_decoder(avctx->codec)) {
725  ret = ff_decode_bsfs_init(avctx);
726  if (ret < 0)
727  goto free_and_end;
728  }
729 
730  if (HAVE_THREADS
731  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
732  ret = ff_thread_init(avctx);
733  if (ret < 0) {
734  goto free_and_end;
735  }
736  }
738  avctx->thread_count = 1;
739 
740  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
741  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
742  avctx->codec->max_lowres);
743  avctx->lowres = avctx->codec->max_lowres;
744  }
745 
746  if (av_codec_is_encoder(avctx->codec)) {
747  int i;
748 #if FF_API_CODED_FRAME
750  avctx->coded_frame = av_frame_alloc();
751  if (!avctx->coded_frame) {
752  ret = AVERROR(ENOMEM);
753  goto free_and_end;
754  }
756 #endif
757 
758  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
759  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
760  ret = AVERROR(EINVAL);
761  goto free_and_end;
762  }
763 
764  if (avctx->codec->sample_fmts) {
765  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
766  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
767  break;
768  if (avctx->channels == 1 &&
771  avctx->sample_fmt = avctx->codec->sample_fmts[i];
772  break;
773  }
774  }
775  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
776  char buf[128];
777  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
778  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
779  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
780  ret = AVERROR(EINVAL);
781  goto free_and_end;
782  }
783  }
784  if (avctx->codec->pix_fmts) {
785  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
786  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
787  break;
788  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
789  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
791  char buf[128];
792  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
793  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
794  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
795  ret = AVERROR(EINVAL);
796  goto free_and_end;
797  }
798  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
799  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
800  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
801  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
802  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
803  avctx->color_range = AVCOL_RANGE_JPEG;
804  }
805  if (avctx->codec->supported_samplerates) {
806  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
807  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
808  break;
809  if (avctx->codec->supported_samplerates[i] == 0) {
810  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
811  avctx->sample_rate);
812  ret = AVERROR(EINVAL);
813  goto free_and_end;
814  }
815  }
816  if (avctx->sample_rate < 0) {
817  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
818  avctx->sample_rate);
819  ret = AVERROR(EINVAL);
820  goto free_and_end;
821  }
822  if (avctx->codec->channel_layouts) {
823  if (!avctx->channel_layout) {
824  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
825  } else {
826  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
827  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
828  break;
829  if (avctx->codec->channel_layouts[i] == 0) {
830  char buf[512];
831  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
832  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
833  ret = AVERROR(EINVAL);
834  goto free_and_end;
835  }
836  }
837  }
838  if (avctx->channel_layout && avctx->channels) {
840  if (channels != avctx->channels) {
841  char buf[512];
842  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
843  av_log(avctx, AV_LOG_ERROR,
844  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
845  buf, channels, avctx->channels);
846  ret = AVERROR(EINVAL);
847  goto free_and_end;
848  }
849  } else if (avctx->channel_layout) {
851  }
852  if (avctx->channels < 0) {
853  av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
854  avctx->channels);
855  ret = AVERROR(EINVAL);
856  goto free_and_end;
857  }
858  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
859  pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
860  if ( avctx->bits_per_raw_sample < 0
861  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
862  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
863  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
864  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
865  }
866  if (avctx->width <= 0 || avctx->height <= 0) {
867  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
868  ret = AVERROR(EINVAL);
869  goto free_and_end;
870  }
871  }
872  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
873  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
874  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
875  }
876 
877  if (!avctx->rc_initial_buffer_occupancy)
878  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
879 
880  if (avctx->ticks_per_frame && avctx->time_base.num &&
881  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
882  av_log(avctx, AV_LOG_ERROR,
883  "ticks_per_frame %d too large for the timebase %d/%d.",
884  avctx->ticks_per_frame,
885  avctx->time_base.num,
886  avctx->time_base.den);
887  goto free_and_end;
888  }
889 
890  if (avctx->hw_frames_ctx) {
891  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
892  if (frames_ctx->format != avctx->pix_fmt) {
893  av_log(avctx, AV_LOG_ERROR,
894  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
895  ret = AVERROR(EINVAL);
896  goto free_and_end;
897  }
898  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
899  avctx->sw_pix_fmt != frames_ctx->sw_format) {
900  av_log(avctx, AV_LOG_ERROR,
901  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
902  "and AVHWFramesContext.sw_format (%s)\n",
904  av_get_pix_fmt_name(frames_ctx->sw_format));
905  ret = AVERROR(EINVAL);
906  goto free_and_end;
907  }
908  avctx->sw_pix_fmt = frames_ctx->sw_format;
909  }
910  }
911 
914  avctx->pts_correction_last_pts =
915  avctx->pts_correction_last_dts = INT64_MIN;
916 
917  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
919  av_log(avctx, AV_LOG_WARNING,
920  "gray decoding requested but not enabled at configuration time\n");
921  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
923  }
924 
925  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
926  || avci->frame_thread_encoder)) {
927  ret = avctx->codec->init(avctx);
928  if (ret < 0) {
929  goto free_and_end;
930  }
931  codec_init_ok = 1;
932  }
933 
934  ret=0;
935 
936  if (av_codec_is_decoder(avctx->codec)) {
937  if (!avctx->bit_rate)
938  avctx->bit_rate = get_bit_rate(avctx);
939  /* validate channel layout from the decoder */
940  if (avctx->channel_layout) {
942  if (!avctx->channels)
943  avctx->channels = channels;
944  else if (channels != avctx->channels) {
945  char buf[512];
946  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
947  av_log(avctx, AV_LOG_WARNING,
948  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
949  "ignoring specified channel layout\n",
950  buf, channels, avctx->channels);
951  avctx->channel_layout = 0;
952  }
953  }
954  if (avctx->channels && avctx->channels < 0 ||
955  avctx->channels > FF_SANE_NB_CHANNELS) {
956  ret = AVERROR(EINVAL);
957  goto free_and_end;
958  }
959  if (avctx->bits_per_coded_sample < 0) {
960  ret = AVERROR(EINVAL);
961  goto free_and_end;
962  }
963  if (avctx->sub_charenc) {
964  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
965  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
966  "supported with subtitles codecs\n");
967  ret = AVERROR(EINVAL);
968  goto free_and_end;
969  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
970  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
971  "subtitles character encoding will be ignored\n",
972  avctx->codec_descriptor->name);
974  } else {
975  /* input character encoding is set for a text based subtitle
976  * codec at this point */
979 
981 #if CONFIG_ICONV
982  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
983  if (cd == (iconv_t)-1) {
984  ret = AVERROR(errno);
985  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
986  "with input character encoding \"%s\"\n", avctx->sub_charenc);
987  goto free_and_end;
988  }
989  iconv_close(cd);
990 #else
991  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
992  "conversion needs a libavcodec built with iconv support "
993  "for this codec\n");
994  ret = AVERROR(ENOSYS);
995  goto free_and_end;
996 #endif
997  }
998  }
999  }
1000 
1001 #if FF_API_AVCTX_TIMEBASE
1002  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1003  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1004 #endif
1005  }
1006  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1007  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1008  }
1009 
1010 end:
1011  ff_unlock_avcodec(codec);
1012  if (options) {
1014  *options = tmp;
1015  }
1016 
1017  return ret;
1018 free_and_end:
1019  if (avctx->codec && avctx->codec->close &&
1020  (codec_init_ok ||
1022  avctx->codec->close(avctx);
1023 
1024  if (HAVE_THREADS && avci->thread_ctx)
1025  ff_thread_free(avctx);
1026 
1027  if (codec->priv_class && codec->priv_data_size)
1028  av_opt_free(avctx->priv_data);
1029  av_opt_free(avctx);
1030 
1031 #if FF_API_CODED_FRAME
1033  av_frame_free(&avctx->coded_frame);
1035 #endif
1036 
1037  av_dict_free(&tmp);
1038  av_freep(&avctx->priv_data);
1039  av_freep(&avctx->subtitle_header);
1040  if (avci) {
1041  av_frame_free(&avci->to_free);
1043  av_frame_free(&avci->buffer_frame);
1044  av_packet_free(&avci->buffer_pkt);
1046 
1047  av_packet_free(&avci->ds.in_pkt);
1048  av_bsf_free(&avci->bsf);
1049 
1050  av_buffer_unref(&avci->pool);
1051  }
1052  av_freep(&avci);
1053  avctx->internal = NULL;
1054  avctx->codec = NULL;
1055  goto end;
1056 }
1057 
1059 {
1060  AVCodecInternal *avci = avctx->internal;
1061 
1062  if (av_codec_is_encoder(avctx->codec)) {
1063  int caps = avctx->codec->capabilities;
1064 
1065  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
1066  // Only encoders that explicitly declare support for it can be
1067  // flushed. Otherwise, this is a no-op.
1068  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
1069  "that doesn't support it\n");
1070  return;
1071  }
1072 
1073  // We haven't implemented flushing for frame-threaded encoders.
1075  }
1076 
1077  avci->draining = 0;
1078  avci->draining_done = 0;
1079  avci->nb_draining_errors = 0;
1082  av_packet_unref(avci->buffer_pkt);
1083  avci->buffer_pkt_valid = 0;
1084 
1085  av_packet_unref(avci->ds.in_pkt);
1086 
1088  ff_thread_flush(avctx);
1089  else if (avctx->codec->flush)
1090  avctx->codec->flush(avctx);
1091 
1092  avctx->pts_correction_last_pts =
1093  avctx->pts_correction_last_dts = INT64_MIN;
1094 
1095  if (av_codec_is_decoder(avctx->codec))
1096  av_bsf_flush(avci->bsf);
1097 
1098  if (!avctx->refcounted_frames)
1099  av_frame_unref(avci->to_free);
1100 }
1101 
1103 {
1104  int i;
1105 
1106  for (i = 0; i < sub->num_rects; i++) {
1107  av_freep(&sub->rects[i]->data[0]);
1108  av_freep(&sub->rects[i]->data[1]);
1109  av_freep(&sub->rects[i]->data[2]);
1110  av_freep(&sub->rects[i]->data[3]);
1111  av_freep(&sub->rects[i]->text);
1112  av_freep(&sub->rects[i]->ass);
1113  av_freep(&sub->rects[i]);
1114  }
1115 
1116  av_freep(&sub->rects);
1117 
1118  memset(sub, 0, sizeof(*sub));
1119 }
1120 
1122 {
1123  int i;
1124 
1125  if (!avctx)
1126  return 0;
1127 
1128  if (avcodec_is_open(avctx)) {
1130  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1132  }
1133  if (HAVE_THREADS && avctx->internal->thread_ctx)
1134  ff_thread_free(avctx);
1135  if (avctx->codec && avctx->codec->close)
1136  avctx->codec->close(avctx);
1137  avctx->internal->byte_buffer_size = 0;
1138  av_freep(&avctx->internal->byte_buffer);
1139  av_frame_free(&avctx->internal->to_free);
1144 
1145  av_packet_free(&avctx->internal->ds.in_pkt);
1146 
1147  av_buffer_unref(&avctx->internal->pool);
1148 
1149  if (avctx->hwaccel && avctx->hwaccel->uninit)
1150  avctx->hwaccel->uninit(avctx);
1152 
1153  av_bsf_free(&avctx->internal->bsf);
1154 
1155  av_freep(&avctx->internal);
1156  }
1157 
1158  for (i = 0; i < avctx->nb_coded_side_data; i++)
1159  av_freep(&avctx->coded_side_data[i].data);
1160  av_freep(&avctx->coded_side_data);
1161  avctx->nb_coded_side_data = 0;
1162 
1163  av_buffer_unref(&avctx->hw_frames_ctx);
1164  av_buffer_unref(&avctx->hw_device_ctx);
1165 
1166  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1167  av_opt_free(avctx->priv_data);
1168  av_opt_free(avctx);
1169  av_freep(&avctx->priv_data);
1170  if (av_codec_is_encoder(avctx->codec)) {
1171  av_freep(&avctx->extradata);
1172 #if FF_API_CODED_FRAME
1174  av_frame_free(&avctx->coded_frame);
1176 #endif
1177  }
1178  avctx->codec = NULL;
1179  avctx->active_thread_type = 0;
1180 
1181  return 0;
1182 }
1183 
1184 const char *avcodec_get_name(enum AVCodecID id)
1185 {
1186  const AVCodecDescriptor *cd;
1187  AVCodec *codec;
1188 
1189  if (id == AV_CODEC_ID_NONE)
1190  return "none";
1191  cd = avcodec_descriptor_get(id);
1192  if (cd)
1193  return cd->name;
1194  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1195  codec = avcodec_find_decoder(id);
1196  if (codec)
1197  return codec->name;
1198  codec = avcodec_find_encoder(id);
1199  if (codec)
1200  return codec->name;
1201  return "unknown_codec";
1202 }
1203 
1204 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1205 {
1206  int i, len, ret = 0;
1207 
1208 #define TAG_PRINT(x) \
1209  (((x) >= '0' && (x) <= '9') || \
1210  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
1211  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1212 
1213  for (i = 0; i < 4; i++) {
1214  len = snprintf(buf, buf_size,
1215  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1216  buf += len;
1217  buf_size = buf_size > len ? buf_size - len : 0;
1218  ret += len;
1219  codec_tag >>= 8;
1220  }
1221  return ret;
1222 }
1223 
1224 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1225 {
1226  const char *codec_type;
1227  const char *codec_name;
1228  const char *profile = NULL;
1229  int64_t bitrate;
1230  int new_line = 0;
1231  AVRational display_aspect_ratio;
1232  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1233 
1234  if (!buf || buf_size <= 0)
1235  return;
1237  codec_name = avcodec_get_name(enc->codec_id);
1239 
1240  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1241  codec_name);
1242  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1243 
1244  if (enc->codec && strcmp(enc->codec->name, codec_name))
1245  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1246 
1247  if (profile)
1248  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1249  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
1251  && enc->refs)
1252  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1253  ", %d reference frame%s",
1254  enc->refs, enc->refs > 1 ? "s" : "");
1255 
1256  if (enc->codec_tag)
1257  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1258  av_fourcc2str(enc->codec_tag), enc->codec_tag);
1259 
1260  switch (enc->codec_type) {
1261  case AVMEDIA_TYPE_VIDEO:
1262  {
1263  char detail[256] = "(";
1264 
1265  av_strlcat(buf, separator, buf_size);
1266 
1267  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1268  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1270  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1272  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1274  av_strlcatf(detail, sizeof(detail), "%s, ",
1276 
1277  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1279  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1280  if (enc->colorspace != (int)enc->color_primaries ||
1281  enc->colorspace != (int)enc->color_trc) {
1282  new_line = 1;
1283  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1287  } else
1288  av_strlcatf(detail, sizeof(detail), "%s, ",
1290  }
1291 
1292  if (enc->field_order != AV_FIELD_UNKNOWN) {
1293  const char *field_order = "progressive";
1294  if (enc->field_order == AV_FIELD_TT)
1295  field_order = "top first";
1296  else if (enc->field_order == AV_FIELD_BB)
1297  field_order = "bottom first";
1298  else if (enc->field_order == AV_FIELD_TB)
1299  field_order = "top coded first (swapped)";
1300  else if (enc->field_order == AV_FIELD_BT)
1301  field_order = "bottom coded first (swapped)";
1302 
1303  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1304  }
1305 
1306  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1308  av_strlcatf(detail, sizeof(detail), "%s, ",
1310 
1311  if (strlen(detail) > 1) {
1312  detail[strlen(detail) - 2] = 0;
1313  av_strlcatf(buf, buf_size, "%s)", detail);
1314  }
1315  }
1316 
1317  if (enc->width) {
1318  av_strlcat(buf, new_line ? separator : ", ", buf_size);
1319 
1320  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1321  "%dx%d",
1322  enc->width, enc->height);
1323 
1324  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1325  (enc->width != enc->coded_width ||
1326  enc->height != enc->coded_height))
1327  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1328  " (%dx%d)", enc->coded_width, enc->coded_height);
1329 
1330  if (enc->sample_aspect_ratio.num) {
1331  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1332  enc->width * (int64_t)enc->sample_aspect_ratio.num,
1333  enc->height * (int64_t)enc->sample_aspect_ratio.den,
1334  1024 * 1024);
1335  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1336  " [SAR %d:%d DAR %d:%d]",
1338  display_aspect_ratio.num, display_aspect_ratio.den);
1339  }
1340  if (av_log_get_level() >= AV_LOG_DEBUG) {
1341  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1342  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1343  ", %d/%d",
1344  enc->time_base.num / g, enc->time_base.den / g);
1345  }
1346  }
1347  if (encode) {
1348  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1349  ", q=%d-%d", enc->qmin, enc->qmax);
1350  } else {
1352  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1353  ", Closed Captions");
1355  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1356  ", lossless");
1357  }
1358  break;
1359  case AVMEDIA_TYPE_AUDIO:
1360  av_strlcat(buf, separator, buf_size);
1361 
1362  if (enc->sample_rate) {
1363  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1364  "%d Hz, ", enc->sample_rate);
1365  }
1366  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1367  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1368  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1369  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1370  }
1371  if ( enc->bits_per_raw_sample > 0
1373  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1374  " (%d bit)", enc->bits_per_raw_sample);
1375  if (av_log_get_level() >= AV_LOG_VERBOSE) {
1376  if (enc->initial_padding)
1377  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1378  ", delay %d", enc->initial_padding);
1379  if (enc->trailing_padding)
1380  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1381  ", padding %d", enc->trailing_padding);
1382  }
1383  break;
1384  case AVMEDIA_TYPE_DATA:
1385  if (av_log_get_level() >= AV_LOG_DEBUG) {
1386  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1387  if (g)
1388  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1389  ", %d/%d",
1390  enc->time_base.num / g, enc->time_base.den / g);
1391  }
1392  break;
1393  case AVMEDIA_TYPE_SUBTITLE:
1394  if (enc->width)
1395  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1396  ", %dx%d", enc->width, enc->height);
1397  break;
1398  default:
1399  return;
1400  }
1401  if (encode) {
1402  if (enc->flags & AV_CODEC_FLAG_PASS1)
1403  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1404  ", pass 1");
1405  if (enc->flags & AV_CODEC_FLAG_PASS2)
1406  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1407  ", pass 2");
1408  }
1409  bitrate = get_bit_rate(enc);
1410  if (bitrate != 0) {
1411  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1412  ", %"PRId64" kb/s", bitrate / 1000);
1413  } else if (enc->rc_max_rate > 0) {
1414  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1415  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
1416  }
1417 }
1418 
1419 const char *av_get_profile_name(const AVCodec *codec, int profile)
1420 {
1421  const AVProfile *p;
1422  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1423  return NULL;
1424 
1425  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1426  if (p->profile == profile)
1427  return p->name;
1428 
1429  return NULL;
1430 }
1431 
1433 {
1435  const AVProfile *p;
1436 
1437  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1438  return NULL;
1439 
1440  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1441  if (p->profile == profile)
1442  return p->name;
1443 
1444  return NULL;
1445 }
1446 
1447 unsigned avcodec_version(void)
1448 {
1451  av_assert0(AV_CODEC_ID_SRT==94216);
1453 
1454  return LIBAVCODEC_VERSION_INT;
1455 }
1456 
1457 const char *avcodec_configuration(void)
1458 {
1459  return FFMPEG_CONFIGURATION;
1460 }
1461 
1462 const char *avcodec_license(void)
1463 {
1464 #define LICENSE_PREFIX "libavcodec license: "
1465  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
1466 }
1467 
1469 {
1470  switch (codec_id) {
1471  case AV_CODEC_ID_8SVX_EXP:
1472  case AV_CODEC_ID_8SVX_FIB:
1473  case AV_CODEC_ID_ADPCM_CT:
1482  return 4;
1483  case AV_CODEC_ID_DSD_LSBF:
1484  case AV_CODEC_ID_DSD_MSBF:
1487  case AV_CODEC_ID_PCM_ALAW:
1488  case AV_CODEC_ID_PCM_MULAW:
1489  case AV_CODEC_ID_PCM_VIDC:
1490  case AV_CODEC_ID_PCM_S8:
1492  case AV_CODEC_ID_PCM_U8:
1493  case AV_CODEC_ID_SDX2_DPCM:
1494  case AV_CODEC_ID_DERF_DPCM:
1495  return 8;
1496  case AV_CODEC_ID_PCM_S16BE:
1498  case AV_CODEC_ID_PCM_S16LE:
1500  case AV_CODEC_ID_PCM_U16BE:
1501  case AV_CODEC_ID_PCM_U16LE:
1502  return 16;
1504  case AV_CODEC_ID_PCM_S24BE:
1505  case AV_CODEC_ID_PCM_S24LE:
1507  case AV_CODEC_ID_PCM_U24BE:
1508  case AV_CODEC_ID_PCM_U24LE:
1509  return 24;
1510  case AV_CODEC_ID_PCM_S32BE:
1511  case AV_CODEC_ID_PCM_S32LE:
1513  case AV_CODEC_ID_PCM_U32BE:
1514  case AV_CODEC_ID_PCM_U32LE:
1515  case AV_CODEC_ID_PCM_F32BE:
1516  case AV_CODEC_ID_PCM_F32LE:
1517  case AV_CODEC_ID_PCM_F24LE:
1518  case AV_CODEC_ID_PCM_F16LE:
1519  return 32;
1520  case AV_CODEC_ID_PCM_F64BE:
1521  case AV_CODEC_ID_PCM_F64LE:
1522  case AV_CODEC_ID_PCM_S64BE:
1523  case AV_CODEC_ID_PCM_S64LE:
1524  return 64;
1525  default:
1526  return 0;
1527  }
1528 }
1529 
1531 {
1532  static const enum AVCodecID map[][2] = {
1544  };
1545  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
1546  return AV_CODEC_ID_NONE;
1547  if (be < 0 || be > 1)
1548  be = AV_NE(1, 0);
1549  return map[fmt][be];
1550 }
1551 
1553 {
1554  switch (codec_id) {
1556  return 2;
1558  return 3;
1562  case AV_CODEC_ID_ADPCM_SWF:
1563  case AV_CODEC_ID_ADPCM_MS:
1564  return 4;
1565  default:
1567  }
1568 }
1569 
1570 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1571  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
1572  uint8_t * extradata, int frame_size, int frame_bytes)
1573 {
1575  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
1576 
1577  /* codecs with an exact constant bits per sample */
1578  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
1579  return (frame_bytes * 8LL) / (bps * ch);
1580  bps = bits_per_coded_sample;
1581 
1582  /* codecs with a fixed packet duration */
1583  switch (id) {
1584  case AV_CODEC_ID_ADPCM_ADX: return 32;
1585  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
1586  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
1587  case AV_CODEC_ID_AMR_NB:
1588  case AV_CODEC_ID_EVRC:
1589  case AV_CODEC_ID_GSM:
1590  case AV_CODEC_ID_QCELP:
1591  case AV_CODEC_ID_RA_288: return 160;
1592  case AV_CODEC_ID_AMR_WB:
1593  case AV_CODEC_ID_GSM_MS: return 320;
1594  case AV_CODEC_ID_MP1: return 384;
1595  case AV_CODEC_ID_ATRAC1: return 512;
1596  case AV_CODEC_ID_ATRAC9:
1597  case AV_CODEC_ID_ATRAC3: return 1024 * framecount;
1598  case AV_CODEC_ID_ATRAC3P: return 2048;
1599  case AV_CODEC_ID_MP2:
1600  case AV_CODEC_ID_MUSEPACK7: return 1152;
1601  case AV_CODEC_ID_AC3: return 1536;
1602  }
1603 
1604  if (sr > 0) {
1605  /* calc from sample rate */
1606  if (id == AV_CODEC_ID_TTA)
1607  return 256 * sr / 245;
1608  else if (id == AV_CODEC_ID_DST)
1609  return 588 * sr / 44100;
1610 
1611  if (ch > 0) {
1612  /* calc from sample rate and channels */
1613  if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1614  return (480 << (sr / 22050)) / ch;
1615  }
1616 
1617  if (id == AV_CODEC_ID_MP3)
1618  return sr <= 24000 ? 576 : 1152;
1619  }
1620 
1621  if (ba > 0) {
1622  /* calc from block_align */
1623  if (id == AV_CODEC_ID_SIPR) {
1624  switch (ba) {
1625  case 20: return 160;
1626  case 19: return 144;
1627  case 29: return 288;
1628  case 37: return 480;
1629  }
1630  } else if (id == AV_CODEC_ID_ILBC) {
1631  switch (ba) {
1632  case 38: return 160;
1633  case 50: return 240;
1634  }
1635  }
1636  }
1637 
1638  if (frame_bytes > 0) {
1639  /* calc from frame_bytes only */
1640  if (id == AV_CODEC_ID_TRUESPEECH)
1641  return 240 * (frame_bytes / 32);
1642  if (id == AV_CODEC_ID_NELLYMOSER)
1643  return 256 * (frame_bytes / 64);
1644  if (id == AV_CODEC_ID_RA_144)
1645  return 160 * (frame_bytes / 20);
1646 
1647  if (bps > 0) {
1648  /* calc from frame_bytes and bits_per_coded_sample */
1650  return frame_bytes * 8 / bps;
1651  }
1652 
1653  if (ch > 0 && ch < INT_MAX/16) {
1654  /* calc from frame_bytes and channels */
1655  switch (id) {
1656  case AV_CODEC_ID_ADPCM_AFC:
1657  return frame_bytes / (9 * ch) * 16;
1658  case AV_CODEC_ID_ADPCM_PSX:
1659  case AV_CODEC_ID_ADPCM_DTK:
1660  return frame_bytes / (16 * ch) * 28;
1661  case AV_CODEC_ID_ADPCM_4XM:
1664  return (frame_bytes - 4 * ch) * 2 / ch;
1666  return (frame_bytes - 4) * 2 / ch;
1668  return (frame_bytes - 8) * 2 / ch;
1669  case AV_CODEC_ID_ADPCM_THP:
1671  if (extradata)
1672  return frame_bytes * 14 / (8 * ch);
1673  break;
1674  case AV_CODEC_ID_ADPCM_XA:
1675  return (frame_bytes / 128) * 224 / ch;
1677  return (frame_bytes - 6 - ch) / ch;
1678  case AV_CODEC_ID_ROQ_DPCM:
1679  return (frame_bytes - 8) / ch;
1680  case AV_CODEC_ID_XAN_DPCM:
1681  return (frame_bytes - 2 * ch) / ch;
1682  case AV_CODEC_ID_MACE3:
1683  return 3 * frame_bytes / ch;
1684  case AV_CODEC_ID_MACE6:
1685  return 6 * frame_bytes / ch;
1686  case AV_CODEC_ID_PCM_LXF:
1687  return 2 * (frame_bytes / (5 * ch));
1688  case AV_CODEC_ID_IAC:
1689  case AV_CODEC_ID_IMC:
1690  return 4 * frame_bytes / ch;
1691  }
1692 
1693  if (tag) {
1694  /* calc from frame_bytes, channels, and codec_tag */
1695  if (id == AV_CODEC_ID_SOL_DPCM) {
1696  if (tag == 3)
1697  return frame_bytes / ch;
1698  else
1699  return frame_bytes * 2 / ch;
1700  }
1701  }
1702 
1703  if (ba > 0) {
1704  /* calc from frame_bytes, channels, and block_align */
1705  int blocks = frame_bytes / ba;
1706  switch (id) {
1708  if (bps < 2 || bps > 5)
1709  return 0;
1710  return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
1712  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1714  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1716  return blocks * ((ba - 4 * ch) * 2 / ch);
1717  case AV_CODEC_ID_ADPCM_MS:
1718  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1720  return blocks * (ba - 16) * 2 / ch;
1721  }
1722  }
1723 
1724  if (bps > 0) {
1725  /* calc from frame_bytes, channels, and bits_per_coded_sample */
1726  switch (id) {
1727  case AV_CODEC_ID_PCM_DVD:
1728  if(bps<4 || frame_bytes<3)
1729  return 0;
1730  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
1732  if(bps<4 || frame_bytes<4)
1733  return 0;
1734  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
1735  case AV_CODEC_ID_S302M:
1736  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1737  }
1738  }
1739  }
1740  }
1741 
1742  /* Fall back on using frame_size */
1743  if (frame_size > 1 && frame_bytes)
1744  return frame_size;
1745 
1746  //For WMA we currently have no other means to calculate duration thus we
1747  //do it here by assuming CBR, which is true for all known cases.
1748  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
1749  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
1750  return (frame_bytes * 8LL * sr) / bitrate;
1751  }
1752 
1753  return 0;
1754 }
1755 
1756 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1757 {
1758  return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1759  avctx->channels, avctx->block_align,
1760  avctx->codec_tag, avctx->bits_per_coded_sample,
1761  avctx->bit_rate, avctx->extradata, avctx->frame_size,
1762  frame_bytes);
1763 }
1764 
1766 {
1767  return get_audio_frame_duration(par->codec_id, par->sample_rate,
1768  par->channels, par->block_align,
1769  par->codec_tag, par->bits_per_coded_sample,
1770  par->bit_rate, par->extradata, par->frame_size,
1771  frame_bytes);
1772 }
1773 
1774 #if !HAVE_THREADS
1776 {
1777  return -1;
1778 }
1779 
1780 #endif
1781 
1782 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1783 {
1784  unsigned int n = 0;
1785 
1786  while (v >= 0xff) {
1787  *s++ = 0xff;
1788  v -= 0xff;
1789  n++;
1790  }
1791  *s = v;
1792  n++;
1793  return n;
1794 }
1795 
1796 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1797 {
1798  int i;
1799  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1800  return i;
1801 }
1802 
1804 {
1805  int i;
1806  if (!codec->hw_configs || index < 0)
1807  return NULL;
1808  for (i = 0; i <= index; i++)
1809  if (!codec->hw_configs[i])
1810  return NULL;
1811  return &codec->hw_configs[index]->public;
1812 }
1813 
1814 #if FF_API_USER_VISIBLE_AVHWACCEL
1816 {
1817  return NULL;
1818 }
1819 
1821 {
1822 }
1823 #endif
1824 
1825 #if FF_API_LOCKMGR
1826 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1827 {
1828  return 0;
1829 }
1830 #endif
1831 
1832 unsigned int avpriv_toupper4(unsigned int x)
1833 {
1834  return av_toupper(x & 0xFF) +
1835  (av_toupper((x >> 8) & 0xFF) << 8) +
1836  (av_toupper((x >> 16) & 0xFF) << 16) +
1837 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
1838 }
1839 
1841 {
1842  int ret;
1843 
1844  dst->owner[0] = src->owner[0];
1845  dst->owner[1] = src->owner[1];
1846 
1847  ret = av_frame_ref(dst->f, src->f);
1848  if (ret < 0)
1849  return ret;
1850 
1851  av_assert0(!dst->progress);
1852 
1853  if (src->progress &&
1854  !(dst->progress = av_buffer_ref(src->progress))) {
1855  ff_thread_release_buffer(dst->owner[0], dst);
1856  return AVERROR(ENOMEM);
1857  }
1858 
1859  return 0;
1860 }
1861 
1862 #if !HAVE_THREADS
1863 
1865 {
1866  return ff_get_format(avctx, fmt);
1867 }
1868 
1870 {
1871  f->owner[0] = f->owner[1] = avctx;
1872  return ff_get_buffer(avctx, f->f, flags);
1873 }
1874 
1876 {
1877  if (f->f)
1878  av_frame_unref(f->f);
1879 }
1880 
1882 {
1883 }
1884 
1886 {
1887 }
1888 
1889 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1890 {
1891 }
1892 
1894 {
1895  return 1;
1896 }
1897 
1898 int ff_alloc_entries(AVCodecContext *avctx, int count)
1899 {
1900  return 0;
1901 }
1902 
1904 {
1905 }
1906 
1907 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1908 {
1909 }
1910 
1911 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1912 {
1913 }
1914 
1915 #endif
1916 
1918 {
1919  return !!s->internal;
1920 }
1921 
1922 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
1923 {
1924  int ret;
1925  char *str;
1926 
1927  ret = av_bprint_finalize(buf, &str);
1928  if (ret < 0)
1929  return ret;
1930  if (!av_bprint_is_complete(buf)) {
1931  av_free(str);
1932  return AVERROR(ENOMEM);
1933  }
1934 
1935  avctx->extradata = str;
1936  /* Note: the string is NUL terminated (so extradata can be read as a
1937  * string), but the ending character is not accounted in the size (in
1938  * binary formats you are likely not supposed to mux that character). When
1939  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
1940  * zeros. */
1941  avctx->extradata_size = buf->len;
1942  return 0;
1943 }
1944 
1946  const uint8_t *end,
1947  uint32_t *av_restrict state)
1948 {
1949  int i;
1950 
1951  av_assert0(p <= end);
1952  if (p >= end)
1953  return end;
1954 
1955  for (i = 0; i < 3; i++) {
1956  uint32_t tmp = *state << 8;
1957  *state = tmp + *(p++);
1958  if (tmp == 0x100 || p == end)
1959  return p;
1960  }
1961 
1962  while (p < end) {
1963  if (p[-1] > 1 ) p += 3;
1964  else if (p[-2] ) p += 2;
1965  else if (p[-3]|(p[-1]-1)) p++;
1966  else {
1967  p++;
1968  break;
1969  }
1970  }
1971 
1972  p = FFMIN(p, end) - 4;
1973  *state = AV_RB32(p);
1974 
1975  return p + 4;
1976 }
1977 
1979 {
1980  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1981  if (!props)
1982  return NULL;
1983 
1984  if (size)
1985  *size = sizeof(*props);
1986 
1987  props->vbv_delay = UINT64_MAX;
1988 
1989  return props;
1990 }
1991 
1993 {
1995  AVCPBProperties *props;
1996  size_t size;
1997  int i;
1998 
1999  for (i = 0; i < avctx->nb_coded_side_data; i++)
2001  return (AVCPBProperties *)avctx->coded_side_data[i].data;
2002 
2003  props = av_cpb_properties_alloc(&size);
2004  if (!props)
2005  return NULL;
2006 
2007  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
2008  if (!tmp) {
2009  av_freep(&props);
2010  return NULL;
2011  }
2012 
2013  avctx->coded_side_data = tmp;
2014  avctx->nb_coded_side_data++;
2015 
2017  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
2018  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
2019 
2020  return props;
2021 }
2022 
2024 {
2025  av_freep(&par->extradata);
2026 
2027  memset(par, 0, sizeof(*par));
2028 
2030  par->codec_id = AV_CODEC_ID_NONE;
2031  par->format = -1;
2038  par->sample_aspect_ratio = (AVRational){ 0, 1 };
2039  par->profile = FF_PROFILE_UNKNOWN;
2040  par->level = FF_LEVEL_UNKNOWN;
2041 }
2042 
2044 {
2045  AVCodecParameters *par = av_mallocz(sizeof(*par));
2046 
2047  if (!par)
2048  return NULL;
2050  return par;
2051 }
2052 
2054 {
2055  AVCodecParameters *par = *ppar;
2056 
2057  if (!par)
2058  return;
2060 
2061  av_freep(ppar);
2062 }
2063 
2065 {
2067  memcpy(dst, src, sizeof(*dst));
2068 
2069  dst->extradata = NULL;
2070  dst->extradata_size = 0;
2071  if (src->extradata) {
2072  dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
2073  if (!dst->extradata)
2074  return AVERROR(ENOMEM);
2075  memcpy(dst->extradata, src->extradata, src->extradata_size);
2076  dst->extradata_size = src->extradata_size;
2077  }
2078 
2079  return 0;
2080 }
2081 
2083  const AVCodecContext *codec)
2084 {
2086 
2087  par->codec_type = codec->codec_type;
2088  par->codec_id = codec->codec_id;
2089  par->codec_tag = codec->codec_tag;
2090 
2091  par->bit_rate = codec->bit_rate;
2094  par->profile = codec->profile;
2095  par->level = codec->level;
2096 
2097  switch (par->codec_type) {
2098  case AVMEDIA_TYPE_VIDEO:
2099  par->format = codec->pix_fmt;
2100  par->width = codec->width;
2101  par->height = codec->height;
2102  par->field_order = codec->field_order;
2103  par->color_range = codec->color_range;
2104  par->color_primaries = codec->color_primaries;
2105  par->color_trc = codec->color_trc;
2106  par->color_space = codec->colorspace;
2109  par->video_delay = codec->has_b_frames;
2110  break;
2111  case AVMEDIA_TYPE_AUDIO:
2112  par->format = codec->sample_fmt;
2113  par->channel_layout = codec->channel_layout;
2114  par->channels = codec->channels;
2115  par->sample_rate = codec->sample_rate;
2116  par->block_align = codec->block_align;
2117  par->frame_size = codec->frame_size;
2118  par->initial_padding = codec->initial_padding;
2119  par->trailing_padding = codec->trailing_padding;
2120  par->seek_preroll = codec->seek_preroll;
2121  break;
2122  case AVMEDIA_TYPE_SUBTITLE:
2123  par->width = codec->width;
2124  par->height = codec->height;
2125  break;
2126  }
2127 
2128  if (codec->extradata) {
2130  if (!par->extradata)
2131  return AVERROR(ENOMEM);
2132  memcpy(par->extradata, codec->extradata, codec->extradata_size);
2133  par->extradata_size = codec->extradata_size;
2134  }
2135 
2136  return 0;
2137 }
2138 
2140  const AVCodecParameters *par)
2141 {
2142  codec->codec_type = par->codec_type;
2143  codec->codec_id = par->codec_id;
2144  codec->codec_tag = par->codec_tag;
2145 
2146  codec->bit_rate = par->bit_rate;
2149  codec->profile = par->profile;
2150  codec->level = par->level;
2151 
2152  switch (par->codec_type) {
2153  case AVMEDIA_TYPE_VIDEO:
2154  codec->pix_fmt = par->format;
2155  codec->width = par->width;
2156  codec->height = par->height;
2157  codec->field_order = par->field_order;
2158  codec->color_range = par->color_range;
2159  codec->color_primaries = par->color_primaries;
2160  codec->color_trc = par->color_trc;
2161  codec->colorspace = par->color_space;
2164  codec->has_b_frames = par->video_delay;
2165  break;
2166  case AVMEDIA_TYPE_AUDIO:
2167  codec->sample_fmt = par->format;
2168  codec->channel_layout = par->channel_layout;
2169  codec->channels = par->channels;
2170  codec->sample_rate = par->sample_rate;
2171  codec->block_align = par->block_align;
2172  codec->frame_size = par->frame_size;
2173  codec->delay =
2174  codec->initial_padding = par->initial_padding;
2175  codec->trailing_padding = par->trailing_padding;
2176  codec->seek_preroll = par->seek_preroll;
2177  break;
2178  case AVMEDIA_TYPE_SUBTITLE:
2179  codec->width = par->width;
2180  codec->height = par->height;
2181  break;
2182  }
2183 
2184  if (par->extradata) {
2185  av_freep(&codec->extradata);
2187  if (!codec->extradata)
2188  return AVERROR(ENOMEM);
2189  memcpy(codec->extradata, par->extradata, par->extradata_size);
2190  codec->extradata_size = par->extradata_size;
2191  }
2192 
2193  return 0;
2194 }
2195 
2196 int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
2197  void **data, size_t *sei_size)
2198 {
2199  AVFrameSideData *side_data = NULL;
2200  uint8_t *sei_data;
2201 
2202  if (frame)
2204 
2205  if (!side_data) {
2206  *data = NULL;
2207  return 0;
2208  }
2209 
2210  *sei_size = side_data->size + 11;
2211  *data = av_mallocz(*sei_size + prefix_len);
2212  if (!*data)
2213  return AVERROR(ENOMEM);
2214  sei_data = (uint8_t*)*data + prefix_len;
2215 
2216  // country code
2217  sei_data[0] = 181;
2218  sei_data[1] = 0;
2219  sei_data[2] = 49;
2220 
2221  /**
2222  * 'GA94' is standard in North America for ATSC, but hard coding
2223  * this style may not be the right thing to do -- other formats
2224  * do exist. This information is not available in the side_data
2225  * so we are going with this right now.
2226  */
2227  AV_WL32(sei_data + 3, MKTAG('G', 'A', '9', '4'));
2228  sei_data[7] = 3;
2229  sei_data[8] = ((side_data->size/3) & 0x1f) | 0x40;
2230  sei_data[9] = 0;
2231 
2232  memcpy(sei_data + 10, side_data->data, side_data->size);
2233 
2234  sei_data[side_data->size+10] = 255;
2235 
2236  return 0;
2237 }
2238 
2240 {
2241  AVRational framerate = avctx->framerate;
2242  int bits_per_coded_sample = avctx->bits_per_coded_sample;
2243  int64_t bitrate;
2244 
2245  if (!(framerate.num && framerate.den))
2246  framerate = av_inv_q(avctx->time_base);
2247  if (!(framerate.num && framerate.den))
2248  return 0;
2249 
2250  if (!bits_per_coded_sample) {
2252  bits_per_coded_sample = av_get_bits_per_pixel(desc);
2253  }
2254  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
2255  framerate.num / framerate.den;
2256 
2257  return bitrate;
2258 }
2259 
2260 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
2261  const int * array_valid_values, int default_value)
2262 {
2263  int i = 0, ref_val;
2264 
2265  while (1) {
2266  ref_val = array_valid_values[i];
2267  if (ref_val == INT_MAX)
2268  break;
2269  if (val == ref_val)
2270  return val;
2271  i++;
2272  }
2273  /* val is not a valid value */
2275  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
2276  return default_value;
2277 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:301
AVSubtitle
Definition: avcodec.h:2694
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: utils.c:1121
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
hwconfig.h
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
AV_CODEC_ID_MACE6
@ AV_CODEC_ID_MACE6
Definition: codec_id.h:420
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1690
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
AVCodec
AVCodec.
Definition: codec.h:190
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
av_codec_get_codec_properties
unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
Definition: utils.c:485
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:182
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:40
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:321
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch const uint8_t **in ch off *out planar
Definition: audioconvert.c:226
AV_CODEC_ID_DSD_LSBF
@ AV_CODEC_ID_DSD_LSBF
Definition: codec_id.h:484
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
AV_CODEC_ID_ADPCM_MS
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:346
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_CODEC_ID_ADPCM_IMA_QT
@ AV_CODEC_ID_ADPCM_IMA_QT
Definition: codec_id.h:340
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
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:413
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2699
opt.h
av_xiphlacing
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1782
AV_CODEC_ID_PCM_BLURAY
@ AV_CODEC_ID_PCM_BLURAY
Definition: codec_id.h:325
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
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:1357
mem_internal.h
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
av_restrict
#define av_restrict
Definition: config.h:10
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1279
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: utils.c:1869
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1594
AV_CODEC_ID_ADPCM_DTK
@ AV_CODEC_ID_ADPCM_DTK
Definition: codec_id.h:374
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
PixelFormatTag
Definition: raw.h:34
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:739
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:216
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:174
ff_thread_report_progress2
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1911
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:149
avpriv_bprint_to_extradata
int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:1922
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
thread.h
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:178
ff_unlock_avcodec
static void ff_unlock_avcodec(const AVCodec *codec)
Definition: utils.c:530
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
ff_thread_flush
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:876
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
AV_CODEC_ID_8SVX_EXP
@ AV_CODEC_ID_8SVX_EXP
Definition: codec_id.h:464
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:249
avcodec_parameters_from_context
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2082
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
ff_thread_await_progress2
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:1907
avcodec_string
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1224
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1832
ff_decode_bsfs_init
int ff_decode_bsfs_init(AVCodecContext *avctx)
Called during avcodec_open2() to initialize avctx->internal->bsf.
Definition: decode.c:204
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:727
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:2201
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: utils.c:1893
av_samples_fill_arrays
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
Definition: samplefmt.c:151
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2698
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:211
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
AV_CODEC_ID_PCM_S32LE_PLANAR
@ AV_CODEC_ID_PCM_S32LE_PLANAR
Definition: codec_id.h:330
profile
mfxU16 profile
Definition: qsvenc.c:45
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:396
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:211
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AV_PIX_FMT_YUVA444P10BE
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:188
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
AV_PIX_FMT_YUV440P12BE
@ AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:278
AVPacketSideData
Definition: packet.h:298
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:209
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
internal.h
ff_fast_malloc
static int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
Definition: mem_internal.h:27
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:331
av_codec_get_max_lowres
int av_codec_get_max_lowres(const AVCodec *codec)
Definition: utils.c:490
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: utils.c:1826
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:140
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:1183
AVCodecParameters::seek_preroll
int seek_preroll
Audio only.
Definition: codec_par.h:200
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:152
TAG_PRINT
#define TAG_PRINT(x)
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:483
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
data
const char data[16]
Definition: mxf.c:91
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:315
AV_PIX_FMT_YUV420P14BE
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:244
avcodec_align_dimensions
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
Definition: utils.c:338
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:392
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:131
AVLockOp
AVLockOp
Lock operation used by lockmgr.
Definition: avcodec.h:4084
AV_CODEC_ID_ADPCM_AICA
@ AV_CODEC_ID_ADPCM_AICA
Definition: codec_id.h:379
AV_CODEC_ID_ADPCM_IMA_OKI
@ AV_CODEC_ID_ADPCM_IMA_OKI
Definition: codec_id.h:373
AVCodec::decode
int(* decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt)
Definition: codec.h:282
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2014
version.h
AV_CODEC_ID_SOL_DPCM
@ AV_CODEC_ID_SOL_DPCM
Definition: codec_id.h:403
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:190
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
float.h
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:418
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:368
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:256
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:1432
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2501
ff_frame_thread_encoder_init
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
Definition: frame_thread_encoder.c:118
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
mpegvideo.h
FF_LEVEL_UNKNOWN
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1983
mathematics.h
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:2127
AVDictionary
Definition: dict.c:30
AV_CODEC_ID_IMC
@ AV_CODEC_ID_IMC
Definition: codec_id.h:437
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:182
AV_PIX_FMT_YUV422P9BE
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:166
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1917
AVCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:305
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1375
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
FF_SUB_CHARENC_MODE_AUTOMATIC
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:2126
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
AVCodecContext::delay
int delay
Codec delay.
Definition: avcodec.h:682
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:64
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
av_chroma_location_name
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:2966
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1593
FFMPEG_CONFIGURATION
#define FFMPEG_CONFIGURATION
Definition: config.h:4
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:133
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:319
AV_CODEC_ID_ADPCM_THP_LE
@ AV_CODEC_ID_ADPCM_THP_LE
Definition: codec_id.h:377
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:393
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:135
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:516
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:333
AVProfile
AVProfile.
Definition: codec.h:176
ff_mutex_unlock
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:288
crc.h
AV_CODEC_ID_DSD_MSBF_PLANAR
@ AV_CODEC_ID_DSD_MSBF_PLANAR
Definition: codec_id.h:487
AV_CODEC_ID_ADPCM_CT
@ AV_CODEC_ID_ADPCM_CT
Definition: codec_id.h:352
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2069
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
framerate
int framerate
Definition: h264_levels.c:65
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:215
avcodec_enum_to_chroma_pos
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: utils.c:353
av_get_colorspace_name
const char * av_get_colorspace_name(enum AVColorSpace val)
Get the name of a colorspace.
Definition: frame.c:123
AVHWAccel
Definition: avcodec.h:2410
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
ff_lock_avcodec
static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
Definition: utils.c:524
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:2942
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AV_CODEC_ID_IFF_ILBM
@ AV_CODEC_ID_IFF_ILBM
Definition: codec_id.h:185
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:535
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:243
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:302
AV_FRAME_DATA_MATRIXENCODING
@ AV_FRAME_DATA_MATRIXENCODING
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
Definition: frame.h:67
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:108
AVCodecParameters::bits_per_raw_sample
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: codec_par.h:115
AVCodec::sample_fmts
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:213
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1785
MAKE_ACCESSORS
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:91
AV_CODEC_ID_XAN_DPCM
@ AV_CODEC_ID_XAN_DPCM
Definition: codec_id.h:402
AV_CODEC_ID_MSZH
@ AV_CODEC_ID_MSZH
Definition: codec_id.h:102
AVCodec::encode_sub
int(* encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: codec.h:268
samplefmt.h
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *av_restrict p, const uint8_t *end, uint32_t *av_restrict state)
Definition: utils.c:1945
x
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
Definition: fate.txt:150
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:2060
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:11135
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1114
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:914
ThreadFrame::owner
AVCodecContext * owner[2]
Definition: thread.h:36
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:2125
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:72
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:714
ff_thread_get_format
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: utils.c:1864
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:171
AV_CODEC_ID_SMC
@ AV_CODEC_ID_SMC
Definition: codec_id.h:98
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
AV_FIELD_TB
@ AV_FIELD_TB
Definition: codec_par.h:41
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:194
AV_CODEC_ID_8SVX_FIB
@ AV_CODEC_ID_8SVX_FIB
Definition: codec_id.h:465
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_PIX_FMT_YUV444P10BE
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:164
AVSubtitleRect::ass
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2689
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: utils.c:454
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:253
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:159
AV_CODEC_ID_ATRAC3
@ AV_CODEC_ID_ATRAC3
Definition: codec_id.h:441
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1102
av_get_planar_sample_fmt
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
Definition: samplefmt.c:84
PixelFormatTag::pix_fmt
enum AVPixelFormat pix_fmt
Definition: raw.h:35
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: internal.h:60
raw.h
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
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:1457
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:451
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:148
AV_CODEC_ID_ADPCM_SBPRO_2
@ AV_CODEC_ID_ADPCM_SBPRO_2
Definition: codec_id.h:357
AV_PIX_FMT_YUV422P12BE
@ AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:246
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:253
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:417
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:305
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
AVCodec::supported_samplerates
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0
Definition: codec.h:212
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AV_CODEC_ID_MACE3
@ AV_CODEC_ID_MACE3
Definition: codec_id.h:419
AV_CODEC_ID_ATRAC3P
@ AV_CODEC_ID_ATRAC3P
Definition: codec_id.h:449
codec_mutex
static AVMutex codec_mutex
Definition: utils.c:68
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:98
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::pts_correction_num_faulty_pts
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
Definition: avcodec.h:2106
FF_CODEC_PROPERTY_LOSSLESS
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:2192
AV_CODEC_ID_TTA
@ AV_CODEC_ID_TTA
Definition: codec_id.h:432
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1432
avpriv_find_pix_fmt
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:467
LIBAVCODEC_VERSION_MICRO
#define LIBAVCODEC_VERSION_MICRO
Definition: version.h:32
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:181
AVMutex
#define AVMutex
Definition: thread.h:164
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:428
AV_CODEC_ID_S302M
@ AV_CODEC_ID_S302M
Definition: codec_id.h:327
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:1655
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
AVCodecInternal::to_free
AVFrame * to_free
Definition: internal.h:131
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:216
ff_frame_thread_encoder_free
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:243
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:351
emms_c
#define emms_c()
Definition: internal.h:55
FFMAX3
#define FFMAX3(a, b, c)
Definition: common.h:95
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:175
AV_CODEC_ID_PCM_LXF
@ AV_CODEC_ID_PCM_LXF
Definition: codec_id.h:326
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:172
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVCodecInternal::compat_decode_frame
AVFrame * compat_decode_frame
Definition: internal.h:183
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
height
static int height
Definition: utils.c:158
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
AV_CODEC_ID_ADPCM_AFC
@ AV_CODEC_ID_ADPCM_AFC
Definition: codec_id.h:372
AVHWAccel::uninit
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2548
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition: codec_id.h:363
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
g
const char * g
Definition: vf_curves.c:115
frame_size
int frame_size
Definition: mxfenc.c:2139
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
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:410
AV_CODEC_ID_ADPCM_IMA_DK3
@ AV_CODEC_ID_ADPCM_IMA_DK3
Definition: codec_id.h:342
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:255
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2064
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
AV_CODEC_ID_ADPCM_IMA_APC
@ AV_CODEC_ID_ADPCM_IMA_APC
Definition: codec_id.h:369
AVCodecDescriptor::type
enum AVMediaType type
Definition: codec_desc.h:40
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1840
AV_CODEC_ID_ATRAC9
@ AV_CODEC_ID_ATRAC9
Definition: codec_id.h:499
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:1757
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:190
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ff_side_data_update_matrix_encoding
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:134
AVPacketSideData::data
uint8_t * data
Definition: packet.h:299
AV_CODEC_ID_ADPCM_IMA_ISS
@ AV_CODEC_ID_ADPCM_IMA_ISS
Definition: codec_id.h:367
AV_CODEC_ID_BINKAUDIO_DCT
@ AV_CODEC_ID_BINKAUDIO_DCT
Definition: codec_id.h:458
ctx
AVFormatContext * ctx
Definition: movenc.c:48
avcodec_fill_audio_frame
int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, enum AVSampleFormat sample_fmt, const uint8_t *buf, int buf_size, int align)
Fill AVFrame audio data and linesize pointers.
Definition: utils.c:376
ff_alloc_entries
int ff_alloc_entries(AVCodecContext *avctx, int count)
Definition: utils.c:1898
AV_CODEC_ID_PCM_F24LE
@ AV_CODEC_ID_PCM_F24LE
Definition: codec_id.h:336
channels
channels
Definition: aptx.h:33
decode.h
limits.h
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_align_dimensions2
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS])
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
Definition: utils.c:154
AV_CODEC_ID_DERF_DPCM
@ AV_CODEC_ID_DERF_DPCM
Definition: codec_id.h:407
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:307
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2256
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:304
AV_CODEC_ID_ADPCM_IMA_SMJPEG
@ AV_CODEC_ID_ADPCM_IMA_SMJPEG
Definition: codec_id.h:345
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:173
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:320
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
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:137
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:458
AVSubtitleRect::text
char * text
0 terminated plain UTF-8 text
Definition: avcodec.h:2682
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:448
AV_FIELD_BT
@ AV_FIELD_BT
Definition: codec_par.h:42
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
av_get_codec_tag_string
size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
Put a string representing the codec tag codec_tag in buf.
Definition: utils.c:1204
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
ff_thread_free
void ff_thread_free(AVCodecContext *avctx)
Definition: pthread.c:82
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:536
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:165
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
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:187
ThreadFrame::progress
AVBufferRef * progress
Definition: thread.h:39
if
if(ret)
Definition: filter_design.txt:179
AVMatrixEncoding
AVMatrixEncoding
Definition: channel_layout.h:114
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1389
AVCodecContext::sub_charenc
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:2116
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2875
ch
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:162
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:308
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:160
LIBAVCODEC_VERSION_INT
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:133
AV_CODEC_ID_ADPCM_EA_XAS
@ AV_CODEC_ID_ADPCM_EA_XAS
Definition: codec_id.h:365
ff_match_2uint16
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
Definition: utils.c:1796
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:287
NULL
#define NULL
Definition: coverity.c:32
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:1875
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:222
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:449
AV_CODEC_ID_DST
@ AV_CODEC_ID_DST
Definition: codec_id.h:492
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
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
AV_CODEC_ID_INTERPLAY_VIDEO
@ AV_CODEC_ID_INTERPLAY_VIDEO
Definition: codec_id.h:88
AV_CODEC_ID_ADPCM_YAMAHA
@ AV_CODEC_ID_ADPCM_YAMAHA
Definition: codec_id.h:354
AV_CODEC_ID_ADPCM_IMA_WS
@ AV_CODEC_ID_ADPCM_IMA_WS
Definition: codec_id.h:344
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:316
AVCodec::type
enum AVMediaType type
Definition: codec.h:203
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_CODEC_ID_INTERPLAY_DPCM
@ AV_CODEC_ID_INTERPLAY_DPCM
Definition: codec_id.h:401
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:312
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:2202
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:561
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
AV_CODEC_ID_ADPCM_IMA_DK4
@ AV_CODEC_ID_ADPCM_IMA_DK4
Definition: codec_id.h:343
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:301
AV_PIX_FMT_YUVA422P12LE
@ AV_PIX_FMT_YUVA422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:344
AV_CODEC_ID_CINEPAK
@ AV_CODEC_ID_CINEPAK
Definition: codec_id.h:92
AVSubtitleRect::data
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:2677
src
#define src
Definition: vp8dsp.c:254
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:334
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
AV_CODEC_ID_ZLIB
@ AV_CODEC_ID_ZLIB
Definition: codec_id.h:103
AV_PIX_FMT_YUVA444P12BE
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:345
AVCodec::profiles
const AVProfile * profiles
array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
Definition: codec.h:217
AVCodecContext::trailing_padding
int trailing_padding
Audio only.
Definition: avcodec.h:2248
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:183
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2894
avcodec_license
const char * avcodec_license(void)
Return the libavcodec license.
Definition: utils.c:1462
ff_alloc_a53_sei
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
Definition: utils.c:2196
AV_CODEC_ID_ADPCM_IMA_AMV
@ AV_CODEC_ID_ADPCM_IMA_AMV
Definition: codec_id.h:359
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1610
lowres
static int lowres
Definition: ffplay.c:336
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:191
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:548
avcodec_version
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: utils.c:1447
AV_CODEC_ID_ROQ_DPCM
@ AV_CODEC_ID_ROQ_DPCM
Definition: codec_id.h:400
AV_PIX_FMT_YUV440P10LE
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:275
AVProfile::profile
int profile
Definition: codec.h:177
AVCodecInternal::skip_samples_multiplier
int skip_samples_multiplier
Definition: internal.h:187
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:179
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:175
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:155
av_cpb_properties_alloc
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
Definition: utils.c:1978
AV_SAMPLE_FMT_U8
AV_SAMPLE_FMT_U8
Definition: audio_convert.c:194
AVCodecContext::level
int level
level
Definition: avcodec.h:1982
AV_RB32
#define AV_RB32
Definition: intreadwrite.h:130
AVCodecInternal::bsf
AVBSFContext * bsf
Definition: internal.h:138
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:533
AVCodecParameters::level
int level
Definition: codec_par.h:121
ff_color_frame
void ff_color_frame(AVFrame *frame, const int c[4])
Definition: utils.c:412
index
int index
Definition: gxfenc.c:89
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
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
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:220
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:144
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:245
AV_CODEC_ID_PCM_S24LE_PLANAR
@ AV_CODEC_ID_PCM_S24LE_PLANAR
Definition: codec_id.h:329
AV_CODEC_ID_ADPCM_XA
@ AV_CODEC_ID_ADPCM_XA
Definition: codec_id.h:348
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2043
AV_CODEC_ID_GSM
@ AV_CODEC_ID_GSM
as in Berlin toast format
Definition: codec_id.h:428
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AV_CODEC_ID_PCM_VIDC
@ AV_CODEC_ID_PCM_VIDC
Definition: codec_id.h:337
AV_PIX_FMT_YUV444P14BE
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:252
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
HAVE_THREADS
#define HAVE_THREADS
Definition: config.h:273
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:156
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:62
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:649
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1765
AV_CODEC_ID_QCELP
@ AV_CODEC_ID_QCELP
Definition: codec_id.h:434
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:1552
AV_CODEC_CAP_AUTO_THREADS
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: codec.h:118
desc
const char * desc
Definition: nvenc.c:79
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:313
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:613
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:277
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:349
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:444
AVCodec::send_frame
int(* send_frame)(struct AVCodecContext *avctx, const struct AVFrame *frame)
Encode API with decoupled packet/frame dataflow.
Definition: codec.h:292
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:66
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:162
AVCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec.h:283
AV_CODEC_ID_ADPCM_IMA_RAD
@ AV_CODEC_ID_ADPCM_IMA_RAD
Definition: codec_id.h:375
AV_PIX_FMT_YUV420P12BE
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:242
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:161
AV_CODEC_ID_DSD_MSBF
@ AV_CODEC_ID_DSD_MSBF
Definition: codec_id.h:485
av_get_profile_name
const char * av_get_profile_name(const AVCodec *codec, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1419
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
AV_CODEC_ID_DXV
@ AV_CODEC_ID_DXV
Definition: codec_id.h:240
AV_PIX_FMT_YUV422P14BE
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:248
bps
unsigned bps
Definition: movenc.c:1533
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
ffversion.h
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
AV_MUTEX_INITIALIZER
#define AV_MUTEX_INITIALIZER
Definition: thread.h:165
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:353
size
int size
Definition: twinvq_data.h:11134
avpriv_codec_get_cap_skip_frame_fill_param
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:496
AVCodec::encode2
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:280
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:301
state
static struct @314 state
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:170
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1992
AVFrameSideData::data
uint8_t * data
Definition: frame.h:208
AVCodecInternal::byte_buffer
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:149
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:120
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:555
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:158
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
frame.h
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:171
AV_NE
#define AV_NE(be, le)
Definition: common.h:50
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
AVCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:300
AVCodecContext::pts_correction_num_faulty_dts
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:2107
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AVCodecContext::pts_correction_last_pts
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:2108
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
AVPacketSideData::size
int size
Definition: packet.h:300
avcodec_default_execute
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: utils.c:441
attributes.h
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:53
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
ff_reset_entries
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:1903
AVCodecInternal
Definition: internal.h:116
CONFIG_FRAME_THREAD_ENCODER
#define CONFIG_FRAME_THREAD_ENCODER
Definition: config.h:631
AVCodecInternal::byte_buffer_size
unsigned int byte_buffer_size
Definition: internal.h:150
bitrate
int64_t bitrate
Definition: h264_levels.c:131
ff_int_from_list_or_default
int ff_int_from_list_or_default(void *ctx, const char *val_name, int val, const int *array_valid_values, int default_value)
Check if a value is in the list.
Definition: utils.c:2260
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:185
av_hwaccel_next
AVHWAccel * av_hwaccel_next(const AVHWAccel *hwaccel)
If hwaccel is NULL, returns the first registered hardware accelerator, if hwaccel is non-NULL,...
Definition: utils.c:1815
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:71
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
ff_thread_await_progress
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: utils.c:1889
r
#define r
Definition: input.c:40
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:554
AVCodec::id
enum AVCodecID id
Definition: codec.h:204
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:186
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:94
AV_CODEC_ID_VP5
@ AV_CODEC_ID_VP5
Definition: codec_id.h:139
AVCPBProperties::vbv_delay
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
Definition: avcodec.h:490
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1184
AV_FIELD_BB
@ AV_FIELD_BB
Definition: codec_par.h:40
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
AV_PIX_FMT_YUVA444P12LE
@ AV_PIX_FMT_YUVA444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:346
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:180
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:456
AV_CODEC_ID_RA_288
@ AV_CODEC_ID_RA_288
Definition: codec_id.h:397
ff_thread_finish_setup
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
Definition: utils.c:1881
AV_CODEC_ID_ADPCM_MTAF
@ AV_CODEC_ID_ADPCM_MTAF
Definition: codec_id.h:381
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2191
width
static int width
Definition: utils.c:158
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:627
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:48
internal.h
AV_CODEC_ID_EVRC
@ AV_CODEC_ID_EVRC
Definition: codec_id.h:482
AVCodecParameters::height
int height
Definition: codec_par.h:127
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2139
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
AV_CODEC_ID_DSD_LSBF_PLANAR
@ AV_CODEC_ID_DSD_LSBF_PLANAR
Definition: codec_id.h:486
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:323
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:385
AVCodecContext::pts_correction_last_dts
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:2109
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:231
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:2176
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:310
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1756
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
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:2278
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:145
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:146
AV_CODEC_ID_PCM_F16LE
@ AV_CODEC_ID_PCM_F16LE
Definition: codec_id.h:335
AV_CODEC_ID_ADPCM_IMA_DAT4
@ AV_CODEC_ID_ADPCM_IMA_DAT4
Definition: codec_id.h:380
len
int len
Definition: vorbis_enc_data.h:452
av_register_hwaccel
void av_register_hwaccel(AVHWAccel *hwaccel)
Register the hardware accelerator hwaccel.
Definition: utils.c:1820
av_samples_get_buffer_size
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:119
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:512
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:136
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
AVCodecInternal::nb_draining_errors
int nb_draining_errors
Definition: internal.h:190
AVCodec::priv_data_size
int priv_data_size
Definition: codec.h:238
ff_guess_coded_bitrate
int64_t ff_guess_coded_bitrate(AVCodecContext *avctx)
Get an estimated video bitrate based on frame size, frame rate and coded bits per pixel.
Definition: utils.c:2239
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
av_get_exact_bits_per_sample
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1468
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:2226
avcodec.h
AV_CODEC_ID_IAC
@ AV_CODEC_ID_IAC
Definition: codec_id.h:468
AVCodecContext::sub_charenc_mode
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2124
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:217
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AV_CODEC_ID_GSM_MS
@ AV_CODEC_ID_GSM_MS
Definition: codec_id.h:440
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:210
tag
uint32_t tag
Definition: movenc.c:1532
ret
ret
Definition: filter_design.txt:187
AVCodec::caps_internal
int caps_internal
Internal codec capabilities.
Definition: codec.h:310
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:1223
get_audio_frame_duration
static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba, uint32_t tag, int bits_per_coded_sample, int64_t bitrate, uint8_t *extradata, int frame_size, int frame_bytes)
Definition: utils.c:1570
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: utils.c:1058
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCodec::hw_configs
const struct AVCodecHWConfigInternal ** hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: codec.h:325
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:919
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1589
pos
unsigned int pos
Definition: spdifenc.c:410
dict.h
AV_CODEC_ID_JV
@ AV_CODEC_ID_JV
Definition: codec_id.h:198
codec_parameters_reset
static void codec_parameters_reset(AVCodecParameters *par)
Definition: utils.c:2023
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:1357
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
AV_PIX_FMT_YUV444P12BE
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:250
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
av_bsf_flush
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state / flush internal buffers.
Definition: bsf.c:185
AVCodecParameters::trailing_padding
int trailing_padding
Audio only.
Definition: codec_par.h:196
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:76
AVCodecContext::coded_frame
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1776
AVCodecContext
main external API structure.
Definition: avcodec.h:526
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
AVCodecContext::codec_descriptor
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:2090
c2
static const uint64_t c2
Definition: murmur3.c:50
ThreadFrame
Definition: thread.h:34
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:376
channel_layout.h
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1368
av_get_pcm_codec
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:1530
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
config.h
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1859
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:163
av_fast_padded_mallocz
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call.
Definition: utils.c:82
LICENSE_PREFIX
#define LICENSE_PREFIX
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:311
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
FFMPEG_VERSION
#define FFMPEG_VERSION
Definition: ffversion.h:4
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:2354
av_get_audio_frame_duration2
int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
This function is the same as av_get_audio_frame_duration(), except it works with AVCodecParameters in...
Definition: utils.c:1765
avcodec_chroma_pos_to_enum
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
Converts swscale x/y chroma position to AVChromaLocation.
Definition: utils.c:365
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2193
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AV_PIX_FMT_YUVA420P10BE
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:184
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1803
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:174
AV_PIX_FMT_YUV420P16BE
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:132
AVCodecInternal::draining
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:167
AV_CODEC_ID_TRUESPEECH
@ AV_CODEC_ID_TRUESPEECH
Definition: codec_id.h:431
shift
static int shift(int a, int b)
Definition: sonic.c:82
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
AV_CODEC_ID_ADPCM_THP
@ AV_CODEC_ID_ADPCM_THP
Definition: codec_id.h:358
AV_PIX_FMT_YUV422P16BE
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:134
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:534
AVCodecContext::seek_preroll
int seek_preroll
Number of samples to skip after a discontinuity.
Definition: avcodec.h:2149
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:309
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:403
AV_CODEC_ID_ADPCM_SBPRO_4
@ AV_CODEC_ID_ADPCM_SBPRO_4
Definition: codec_id.h:355
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:306
AV_CODEC_ID_RPZA
@ AV_CODEC_ID_RPZA
Definition: codec_id.h:91
AV_CODEC_ID_SDX2_DPCM
@ AV_CODEC_ID_SDX2_DPCM
Definition: codec_id.h:405
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:104
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:119
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:155
AVCodecInternal::buffer_pkt_valid
int buffer_pkt_valid
Definition: internal.h:173
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:189
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:206
AVCodecParameters::format
int format
Definition: codec_par.h:84
AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_PCM_S24DAUD
Definition: codec_id.h:317
AV_CODEC_ID_ADPCM_IMA_SSI
@ AV_CODEC_ID_ADPCM_IMA_SSI
Definition: codec_id.h:384
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:85
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:324
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:380
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:551
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
FF_MAX_EXTRADATA_SIZE
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:223
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: utils.c:2053
AVFrameSideData::size
int size
Definition: frame.h:209
AV_CODEC_ID_ADPCM_IMA_WAV
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition: codec_id.h:341
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_codec_ffversion
const char av_codec_ffversion[]
Definition: utils.c:66
get_bit_rate
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: utils.c:500
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_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
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
AV_PIX_FMT_YUV440P10BE
@ AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:276
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:192
avcodec_configuration
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: utils.c:1457
AVCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec.h:267
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:167
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:193
PixelFormatTag::fourcc
unsigned int fourcc
Definition: raw.h:36
AV_CODEC_ID_ILBC
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:469
codec_string
Definition: dashenc.c:201
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:257
AVCodecInternal::thread_ctx
void * thread_ctx
Definition: internal.h:135
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:328
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
bytestream.h
convert_header.str
string str
Definition: convert_header.py:20
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:303
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
hwcontext.h
AVCHROMA_LOC_NB
@ AVCHROMA_LOC_NB
Not part of ABI.
Definition: pixfmt.h:562
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:322
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
DecodeSimpleContext::in_pkt
AVPacket * in_pkt
Definition: internal.h:112
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
FFMPEG_LICENSE
#define FFMPEG_LICENSE
Definition: config.h:5
CONFIG_GRAY
#define CONFIG_GRAY
Definition: config.h:549
AVCodecHWConfig
Definition: codec.h:425
AV_CODEC_ID_ADPCM_4XM
@ AV_CODEC_ID_ADPCM_4XM
Definition: codec_id.h:347
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3394
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2076
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:287
avstring.h
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:195
AV_CODEC_ID_MUSEPACK7
@ AV_CODEC_ID_MUSEPACK7
Definition: codec_id.h:438
AV_CODEC_ID_ADPCM_PSX
@ AV_CODEC_ID_ADPCM_PSX
Definition: codec_id.h:378
FF_SANE_NB_CHANNELS
#define FF_SANE_NB_CHANNELS
Definition: internal.h:97
AVCodecContext::codec_whitelist
char * codec_whitelist
',' separated list of allowed decoders.
Definition: avcodec.h:2184
AV_PIX_FMT_YUVA422P12BE
@ AV_PIX_FMT_YUVA422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:343
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: utils.c:1885
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
fourcc
uint32_t fourcc
Definition: vaapi_decode.c:239
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: codec_id.h:58
snprintf
#define snprintf
Definition: snprintf.h:34
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:452
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:247
AVCodecParameters::initial_padding
int initial_padding
Audio only.
Definition: codec_par.h:189
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:314
ff_thread_init
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:1775
AV_PIX_FMT_YUVA420P9BE
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:178
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2918
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:905
AVCodec::channel_layouts
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: codec.h:214
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
mutex
static AVMutex mutex
Definition: log.c:44
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:443
ff_codec_open2_recursive
int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Call avcodec_open2 recursively by decrementing counter, unlocking mutex, calling the function and the...
Definition: utils.c:536
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:2465
AV_PIX_FMT_UYYVYY411
@ AV_PIX_FMT_UYYVYY411
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Definition: pixfmt.h:82
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
AV_CODEC_ID_ADPCM_SBPRO_3
@ AV_CODEC_ID_ADPCM_SBPRO_3
Definition: codec_id.h:356
nb_channels
int nb_channels
Definition: channel_layout.c:76
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:181