FFmpeg
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 "hwaccel.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;
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  }
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 ||
287  w_align = 4;
288  h_align = 4;
289  }
290  if (s->codec_id == AV_CODEC_ID_JV ||
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 ||
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 {
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 
369  for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
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 
382  needed_size = av_samples_get_buffer_size(NULL, nb_channels,
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);
389  if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
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, x;
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  for (y = 0; y < height; y++) {
425  if (desc->comp[0].depth >= 9) {
426  for (x = 0; x<bytes; x++)
427  ((uint16_t*)dst)[x] = c[p];
428  }else
429  memset(dst, c[p], bytes);
430  dst += frame->linesize[p];
431  }
432  }
433 }
434 
435 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
436 {
437  int i;
438 
439  for (i = 0; i < count; i++) {
440  int r = func(c, (char *)arg + i * size);
441  if (ret)
442  ret[i] = r;
443  }
444  emms_c();
445  return 0;
446 }
447 
448 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
449 {
450  int i;
451 
452  for (i = 0; i < count; i++) {
453  int r = func(c, arg, i, 0);
454  if (ret)
455  ret[i] = r;
456  }
457  emms_c();
458  return 0;
459 }
460 
462  unsigned int fourcc)
463 {
464  while (tags->pix_fmt >= 0) {
465  if (tags->fourcc == fourcc)
466  return tags->pix_fmt;
467  tags++;
468  }
469  return AV_PIX_FMT_NONE;
470 }
471 
472 #if FF_API_CODEC_GET_SET
473 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
474 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
476 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
477 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
478 
480 {
481  return codec->properties;
482 }
483 
485 {
486  return codec->max_lowres;
487 }
488 #endif
489 
492 }
493 
495 {
496  int64_t bit_rate;
497  int bits_per_sample;
498 
499  switch (ctx->codec_type) {
500  case AVMEDIA_TYPE_VIDEO:
501  case AVMEDIA_TYPE_DATA:
504  bit_rate = ctx->bit_rate;
505  break;
506  case AVMEDIA_TYPE_AUDIO:
507  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
508  bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
509  break;
510  default:
511  bit_rate = 0;
512  break;
513  }
514  return bit_rate;
515 }
516 
517 
518 static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
519 {
520  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
522 }
523 
524 static void ff_unlock_avcodec(const AVCodec *codec)
525 {
526  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
528 }
529 
530 int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
531 {
532  int ret = 0;
533 
534  ff_unlock_avcodec(codec);
535 
536  ret = avcodec_open2(avctx, codec, options);
537 
538  ff_lock_avcodec(avctx, codec);
539  return ret;
540 }
541 
542 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
543 {
544  int ret = 0;
545  AVDictionary *tmp = NULL;
546  const AVPixFmtDescriptor *pixdesc;
547 
548  if (avcodec_is_open(avctx))
549  return 0;
550 
551  if ((!codec && !avctx->codec)) {
552  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
553  return AVERROR(EINVAL);
554  }
555  if ((codec && avctx->codec && codec != avctx->codec)) {
556  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
557  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
558  return AVERROR(EINVAL);
559  }
560  if (!codec)
561  codec = avctx->codec;
562 
563  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
564  return AVERROR(EINVAL);
565 
566  if (options)
567  av_dict_copy(&tmp, *options, 0);
568 
569  ff_lock_avcodec(avctx, codec);
570 
571  avctx->internal = av_mallocz(sizeof(*avctx->internal));
572  if (!avctx->internal) {
573  ret = AVERROR(ENOMEM);
574  goto end;
575  }
576 
577  avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
578  if (!avctx->internal->pool) {
579  ret = AVERROR(ENOMEM);
580  goto free_and_end;
581  }
582 
583  avctx->internal->to_free = av_frame_alloc();
584  if (!avctx->internal->to_free) {
585  ret = AVERROR(ENOMEM);
586  goto free_and_end;
587  }
588 
590  if (!avctx->internal->compat_decode_frame) {
591  ret = AVERROR(ENOMEM);
592  goto free_and_end;
593  }
594 
596  if (!avctx->internal->buffer_frame) {
597  ret = AVERROR(ENOMEM);
598  goto free_and_end;
599  }
600 
601  avctx->internal->buffer_pkt = av_packet_alloc();
602  if (!avctx->internal->buffer_pkt) {
603  ret = AVERROR(ENOMEM);
604  goto free_and_end;
605  }
606 
607  avctx->internal->ds.in_pkt = av_packet_alloc();
608  if (!avctx->internal->ds.in_pkt) {
609  ret = AVERROR(ENOMEM);
610  goto free_and_end;
611  }
612 
614  if (!avctx->internal->last_pkt_props) {
615  ret = AVERROR(ENOMEM);
616  goto free_and_end;
617  }
618 
619  avctx->internal->skip_samples_multiplier = 1;
620 
621  if (codec->priv_data_size > 0) {
622  if (!avctx->priv_data) {
623  avctx->priv_data = av_mallocz(codec->priv_data_size);
624  if (!avctx->priv_data) {
625  ret = AVERROR(ENOMEM);
626  goto end;
627  }
628  if (codec->priv_class) {
629  *(const AVClass **)avctx->priv_data = codec->priv_class;
631  }
632  }
633  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
634  goto free_and_end;
635  } else {
636  avctx->priv_data = NULL;
637  }
638  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
639  goto free_and_end;
640 
641  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
642  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
643  ret = AVERROR(EINVAL);
644  goto free_and_end;
645  }
646 
647  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
648  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
649  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
650  if (avctx->coded_width && avctx->coded_height)
651  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
652  else if (avctx->width && avctx->height)
653  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
654  if (ret < 0)
655  goto free_and_end;
656  }
657 
658  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
659  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
660  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
661  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
662  ff_set_dimensions(avctx, 0, 0);
663  }
664 
665  if (avctx->width > 0 && avctx->height > 0) {
666  if (av_image_check_sar(avctx->width, avctx->height,
667  avctx->sample_aspect_ratio) < 0) {
668  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
669  avctx->sample_aspect_ratio.num,
670  avctx->sample_aspect_ratio.den);
671  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
672  }
673  }
674 
675  /* if the decoder init function was already called previously,
676  * free the already allocated subtitle_header before overwriting it */
677  if (av_codec_is_decoder(codec))
678  av_freep(&avctx->subtitle_header);
679 
680  if (avctx->channels > FF_SANE_NB_CHANNELS) {
681  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d\n", avctx->channels);
682  ret = AVERROR(EINVAL);
683  goto free_and_end;
684  }
685 
686  avctx->codec = codec;
687  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
688  avctx->codec_id == AV_CODEC_ID_NONE) {
689  avctx->codec_type = codec->type;
690  avctx->codec_id = codec->id;
691  }
692  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
693  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
694  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
695  ret = AVERROR(EINVAL);
696  goto free_and_end;
697  }
698  avctx->frame_number = 0;
700 
701  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
703  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
704  AVCodec *codec2;
705  av_log(avctx, AV_LOG_ERROR,
706  "The %s '%s' is experimental but experimental codecs are not enabled, "
707  "add '-strict %d' if you want to use it.\n",
708  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
709  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
710  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
711  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
712  codec_string, codec2->name);
713  ret = AVERROR_EXPERIMENTAL;
714  goto free_and_end;
715  }
716 
717  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
718  (!avctx->time_base.num || !avctx->time_base.den)) {
719  avctx->time_base.num = 1;
720  avctx->time_base.den = avctx->sample_rate;
721  }
722 
723  if (!HAVE_THREADS)
724  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
725 
726  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
727  ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
728  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
729  ff_lock_avcodec(avctx, codec);
730  if (ret < 0)
731  goto free_and_end;
732  }
733 
734  if (av_codec_is_decoder(avctx->codec)) {
735  ret = ff_decode_bsfs_init(avctx);
736  if (ret < 0)
737  goto free_and_end;
738  }
739 
740  if (HAVE_THREADS
742  ret = ff_thread_init(avctx);
743  if (ret < 0) {
744  goto free_and_end;
745  }
746  }
747  if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
748  avctx->thread_count = 1;
749 
750  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
751  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
752  avctx->codec->max_lowres);
753  avctx->lowres = avctx->codec->max_lowres;
754  }
755 
756  if (av_codec_is_encoder(avctx->codec)) {
757  int i;
758 #if FF_API_CODED_FRAME
760  avctx->coded_frame = av_frame_alloc();
761  if (!avctx->coded_frame) {
762  ret = AVERROR(ENOMEM);
763  goto free_and_end;
764  }
766 #endif
767 
768  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
769  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
770  ret = AVERROR(EINVAL);
771  goto free_and_end;
772  }
773 
774  if (avctx->codec->sample_fmts) {
775  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
776  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
777  break;
778  if (avctx->channels == 1 &&
781  avctx->sample_fmt = avctx->codec->sample_fmts[i];
782  break;
783  }
784  }
785  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
786  char buf[128];
787  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
788  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
789  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
790  ret = AVERROR(EINVAL);
791  goto free_and_end;
792  }
793  }
794  if (avctx->codec->pix_fmts) {
795  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
796  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
797  break;
798  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
799  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
801  char buf[128];
802  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
803  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
804  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
805  ret = AVERROR(EINVAL);
806  goto free_and_end;
807  }
808  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
809  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
810  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
811  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
812  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
813  avctx->color_range = AVCOL_RANGE_JPEG;
814  }
815  if (avctx->codec->supported_samplerates) {
816  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
817  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
818  break;
819  if (avctx->codec->supported_samplerates[i] == 0) {
820  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
821  avctx->sample_rate);
822  ret = AVERROR(EINVAL);
823  goto free_and_end;
824  }
825  }
826  if (avctx->sample_rate < 0) {
827  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
828  avctx->sample_rate);
829  ret = AVERROR(EINVAL);
830  goto free_and_end;
831  }
832  if (avctx->codec->channel_layouts) {
833  if (!avctx->channel_layout) {
834  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
835  } else {
836  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
837  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
838  break;
839  if (avctx->codec->channel_layouts[i] == 0) {
840  char buf[512];
841  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
842  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
843  ret = AVERROR(EINVAL);
844  goto free_and_end;
845  }
846  }
847  }
848  if (avctx->channel_layout && avctx->channels) {
850  if (channels != avctx->channels) {
851  char buf[512];
852  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
853  av_log(avctx, AV_LOG_ERROR,
854  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
855  buf, channels, avctx->channels);
856  ret = AVERROR(EINVAL);
857  goto free_and_end;
858  }
859  } else if (avctx->channel_layout) {
861  }
862  if (avctx->channels < 0) {
863  av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
864  avctx->channels);
865  ret = AVERROR(EINVAL);
866  goto free_and_end;
867  }
868  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
869  pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
870  if ( avctx->bits_per_raw_sample < 0
871  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
872  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
873  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
874  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
875  }
876  if (avctx->width <= 0 || avctx->height <= 0) {
877  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
878  ret = AVERROR(EINVAL);
879  goto free_and_end;
880  }
881  }
882  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
883  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
884  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
885  }
886 
887  if (!avctx->rc_initial_buffer_occupancy)
888  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
889 
890  if (avctx->ticks_per_frame && avctx->time_base.num &&
891  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
892  av_log(avctx, AV_LOG_ERROR,
893  "ticks_per_frame %d too large for the timebase %d/%d.",
894  avctx->ticks_per_frame,
895  avctx->time_base.num,
896  avctx->time_base.den);
897  goto free_and_end;
898  }
899 
900  if (avctx->hw_frames_ctx) {
901  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
902  if (frames_ctx->format != avctx->pix_fmt) {
903  av_log(avctx, AV_LOG_ERROR,
904  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
905  ret = AVERROR(EINVAL);
906  goto free_and_end;
907  }
908  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
909  avctx->sw_pix_fmt != frames_ctx->sw_format) {
910  av_log(avctx, AV_LOG_ERROR,
911  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
912  "and AVHWFramesContext.sw_format (%s)\n",
914  av_get_pix_fmt_name(frames_ctx->sw_format));
915  ret = AVERROR(EINVAL);
916  goto free_and_end;
917  }
918  avctx->sw_pix_fmt = frames_ctx->sw_format;
919  }
920  }
921 
924  avctx->pts_correction_last_pts =
925  avctx->pts_correction_last_dts = INT64_MIN;
926 
927  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
929  av_log(avctx, AV_LOG_WARNING,
930  "gray decoding requested but not enabled at configuration time\n");
931 
932  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
933  || avctx->internal->frame_thread_encoder)) {
934  ret = avctx->codec->init(avctx);
935  if (ret < 0) {
936  goto free_and_end;
937  }
938  }
939 
940  ret=0;
941 
942  if (av_codec_is_decoder(avctx->codec)) {
943  if (!avctx->bit_rate)
944  avctx->bit_rate = get_bit_rate(avctx);
945  /* validate channel layout from the decoder */
946  if (avctx->channel_layout) {
948  if (!avctx->channels)
949  avctx->channels = channels;
950  else if (channels != avctx->channels) {
951  char buf[512];
952  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
953  av_log(avctx, AV_LOG_WARNING,
954  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
955  "ignoring specified channel layout\n",
956  buf, channels, avctx->channels);
957  avctx->channel_layout = 0;
958  }
959  }
960  if (avctx->channels && avctx->channels < 0 ||
961  avctx->channels > FF_SANE_NB_CHANNELS) {
962  ret = AVERROR(EINVAL);
963  goto free_and_end;
964  }
965  if (avctx->sub_charenc) {
966  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
967  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
968  "supported with subtitles codecs\n");
969  ret = AVERROR(EINVAL);
970  goto free_and_end;
971  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
972  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
973  "subtitles character encoding will be ignored\n",
974  avctx->codec_descriptor->name);
976  } else {
977  /* input character encoding is set for a text based subtitle
978  * codec at this point */
981 
983 #if CONFIG_ICONV
984  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
985  if (cd == (iconv_t)-1) {
986  ret = AVERROR(errno);
987  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
988  "with input character encoding \"%s\"\n", avctx->sub_charenc);
989  goto free_and_end;
990  }
991  iconv_close(cd);
992 #else
993  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
994  "conversion needs a libavcodec built with iconv support "
995  "for this codec\n");
996  ret = AVERROR(ENOSYS);
997  goto free_and_end;
998 #endif
999  }
1000  }
1001  }
1002 
1003 #if FF_API_AVCTX_TIMEBASE
1004  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1005  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1006 #endif
1007  }
1008  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1009  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1010  }
1011 
1012 end:
1013  ff_unlock_avcodec(codec);
1014  if (options) {
1015  av_dict_free(options);
1016  *options = tmp;
1017  }
1018 
1019  return ret;
1020 free_and_end:
1021  if (avctx->codec &&
1023  avctx->codec->close(avctx);
1024 
1025  if (codec->priv_class && codec->priv_data_size)
1026  av_opt_free(avctx->priv_data);
1027  av_opt_free(avctx);
1028 
1029 #if FF_API_CODED_FRAME
1031  av_frame_free(&avctx->coded_frame);
1033 #endif
1034 
1035  av_dict_free(&tmp);
1036  av_freep(&avctx->priv_data);
1037  if (avctx->internal) {
1038  av_frame_free(&avctx->internal->to_free);
1043 
1044  av_packet_free(&avctx->internal->ds.in_pkt);
1045  ff_decode_bsfs_uninit(avctx);
1046 
1047  av_freep(&avctx->internal->pool);
1048  }
1049  av_freep(&avctx->internal);
1050  avctx->codec = NULL;
1051  goto end;
1052 }
1053 
1055 {
1056  int i;
1057 
1058  for (i = 0; i < sub->num_rects; i++) {
1059  av_freep(&sub->rects[i]->data[0]);
1060  av_freep(&sub->rects[i]->data[1]);
1061  av_freep(&sub->rects[i]->data[2]);
1062  av_freep(&sub->rects[i]->data[3]);
1063  av_freep(&sub->rects[i]->text);
1064  av_freep(&sub->rects[i]->ass);
1065  av_freep(&sub->rects[i]);
1066  }
1067 
1068  av_freep(&sub->rects);
1069 
1070  memset(sub, 0, sizeof(*sub));
1071 }
1072 
1074 {
1075  int i;
1076 
1077  if (!avctx)
1078  return 0;
1079 
1080  if (avcodec_is_open(avctx)) {
1081  FramePool *pool = avctx->internal->pool;
1082  if (CONFIG_FRAME_THREAD_ENCODER &&
1083  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1085  }
1086  if (HAVE_THREADS && avctx->internal->thread_ctx)
1087  ff_thread_free(avctx);
1088  if (avctx->codec && avctx->codec->close)
1089  avctx->codec->close(avctx);
1090  avctx->internal->byte_buffer_size = 0;
1091  av_freep(&avctx->internal->byte_buffer);
1092  av_frame_free(&avctx->internal->to_free);
1097 
1098  av_packet_free(&avctx->internal->ds.in_pkt);
1099 
1100  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1101  av_buffer_pool_uninit(&pool->pools[i]);
1102  av_freep(&avctx->internal->pool);
1103 
1104  if (avctx->hwaccel && avctx->hwaccel->uninit)
1105  avctx->hwaccel->uninit(avctx);
1107 
1108  ff_decode_bsfs_uninit(avctx);
1109 
1110  av_freep(&avctx->internal);
1111  }
1112 
1113  for (i = 0; i < avctx->nb_coded_side_data; i++)
1114  av_freep(&avctx->coded_side_data[i].data);
1115  av_freep(&avctx->coded_side_data);
1116  avctx->nb_coded_side_data = 0;
1117 
1118  av_buffer_unref(&avctx->hw_frames_ctx);
1119  av_buffer_unref(&avctx->hw_device_ctx);
1120 
1121  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1122  av_opt_free(avctx->priv_data);
1123  av_opt_free(avctx);
1124  av_freep(&avctx->priv_data);
1125  if (av_codec_is_encoder(avctx->codec)) {
1126  av_freep(&avctx->extradata);
1127 #if FF_API_CODED_FRAME
1129  av_frame_free(&avctx->coded_frame);
1131 #endif
1132  }
1133  avctx->codec = NULL;
1134  avctx->active_thread_type = 0;
1135 
1136  return 0;
1137 }
1138 
1139 const char *avcodec_get_name(enum AVCodecID id)
1140 {
1141  const AVCodecDescriptor *cd;
1142  AVCodec *codec;
1143 
1144  if (id == AV_CODEC_ID_NONE)
1145  return "none";
1146  cd = avcodec_descriptor_get(id);
1147  if (cd)
1148  return cd->name;
1149  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1150  codec = avcodec_find_decoder(id);
1151  if (codec)
1152  return codec->name;
1153  codec = avcodec_find_encoder(id);
1154  if (codec)
1155  return codec->name;
1156  return "unknown_codec";
1157 }
1158 
1159 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1160 {
1161  int i, len, ret = 0;
1162 
1163 #define TAG_PRINT(x) \
1164  (((x) >= '0' && (x) <= '9') || \
1165  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
1166  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1167 
1168  for (i = 0; i < 4; i++) {
1169  len = snprintf(buf, buf_size,
1170  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1171  buf += len;
1172  buf_size = buf_size > len ? buf_size - len : 0;
1173  ret += len;
1174  codec_tag >>= 8;
1175  }
1176  return ret;
1177 }
1178 
1179 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1180 {
1181  const char *codec_type;
1182  const char *codec_name;
1183  const char *profile = NULL;
1184  int64_t bitrate;
1185  int new_line = 0;
1186  AVRational display_aspect_ratio;
1187  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1188 
1189  if (!buf || buf_size <= 0)
1190  return;
1191  codec_type = av_get_media_type_string(enc->codec_type);
1192  codec_name = avcodec_get_name(enc->codec_id);
1193  profile = avcodec_profile_name(enc->codec_id, enc->profile);
1194 
1195  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1196  codec_name);
1197  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1198 
1199  if (enc->codec && strcmp(enc->codec->name, codec_name))
1200  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1201 
1202  if (profile)
1203  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1204  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
1206  && enc->refs)
1207  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1208  ", %d reference frame%s",
1209  enc->refs, enc->refs > 1 ? "s" : "");
1210 
1211  if (enc->codec_tag)
1212  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1213  av_fourcc2str(enc->codec_tag), enc->codec_tag);
1214 
1215  switch (enc->codec_type) {
1216  case AVMEDIA_TYPE_VIDEO:
1217  {
1218  char detail[256] = "(";
1219 
1220  av_strlcat(buf, separator, buf_size);
1221 
1222  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1223  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1225  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1227  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1229  av_strlcatf(detail, sizeof(detail), "%s, ",
1231 
1232  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1234  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1235  if (enc->colorspace != (int)enc->color_primaries ||
1236  enc->colorspace != (int)enc->color_trc) {
1237  new_line = 1;
1238  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1242  } else
1243  av_strlcatf(detail, sizeof(detail), "%s, ",
1245  }
1246 
1247  if (enc->field_order != AV_FIELD_UNKNOWN) {
1248  const char *field_order = "progressive";
1249  if (enc->field_order == AV_FIELD_TT)
1250  field_order = "top first";
1251  else if (enc->field_order == AV_FIELD_BB)
1252  field_order = "bottom first";
1253  else if (enc->field_order == AV_FIELD_TB)
1254  field_order = "top coded first (swapped)";
1255  else if (enc->field_order == AV_FIELD_BT)
1256  field_order = "bottom coded first (swapped)";
1257 
1258  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1259  }
1260 
1261  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1263  av_strlcatf(detail, sizeof(detail), "%s, ",
1265 
1266  if (strlen(detail) > 1) {
1267  detail[strlen(detail) - 2] = 0;
1268  av_strlcatf(buf, buf_size, "%s)", detail);
1269  }
1270  }
1271 
1272  if (enc->width) {
1273  av_strlcat(buf, new_line ? separator : ", ", buf_size);
1274 
1275  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1276  "%dx%d",
1277  enc->width, enc->height);
1278 
1279  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1280  (enc->width != enc->coded_width ||
1281  enc->height != enc->coded_height))
1282  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1283  " (%dx%d)", enc->coded_width, enc->coded_height);
1284 
1285  if (enc->sample_aspect_ratio.num) {
1286  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1287  enc->width * (int64_t)enc->sample_aspect_ratio.num,
1288  enc->height * (int64_t)enc->sample_aspect_ratio.den,
1289  1024 * 1024);
1290  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1291  " [SAR %d:%d DAR %d:%d]",
1293  display_aspect_ratio.num, display_aspect_ratio.den);
1294  }
1295  if (av_log_get_level() >= AV_LOG_DEBUG) {
1296  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1297  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1298  ", %d/%d",
1299  enc->time_base.num / g, enc->time_base.den / g);
1300  }
1301  }
1302  if (encode) {
1303  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1304  ", q=%d-%d", enc->qmin, enc->qmax);
1305  } else {
1307  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1308  ", Closed Captions");
1310  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1311  ", lossless");
1312  }
1313  break;
1314  case AVMEDIA_TYPE_AUDIO:
1315  av_strlcat(buf, separator, buf_size);
1316 
1317  if (enc->sample_rate) {
1318  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1319  "%d Hz, ", enc->sample_rate);
1320  }
1321  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1322  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1323  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1324  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1325  }
1326  if ( enc->bits_per_raw_sample > 0
1328  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1329  " (%d bit)", enc->bits_per_raw_sample);
1330  if (av_log_get_level() >= AV_LOG_VERBOSE) {
1331  if (enc->initial_padding)
1332  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1333  ", delay %d", enc->initial_padding);
1334  if (enc->trailing_padding)
1335  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1336  ", padding %d", enc->trailing_padding);
1337  }
1338  break;
1339  case AVMEDIA_TYPE_DATA:
1340  if (av_log_get_level() >= AV_LOG_DEBUG) {
1341  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1342  if (g)
1343  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1344  ", %d/%d",
1345  enc->time_base.num / g, enc->time_base.den / g);
1346  }
1347  break;
1348  case AVMEDIA_TYPE_SUBTITLE:
1349  if (enc->width)
1350  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1351  ", %dx%d", enc->width, enc->height);
1352  break;
1353  default:
1354  return;
1355  }
1356  if (encode) {
1357  if (enc->flags & AV_CODEC_FLAG_PASS1)
1358  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1359  ", pass 1");
1360  if (enc->flags & AV_CODEC_FLAG_PASS2)
1361  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1362  ", pass 2");
1363  }
1364  bitrate = get_bit_rate(enc);
1365  if (bitrate != 0) {
1366  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1367  ", %"PRId64" kb/s", bitrate / 1000);
1368  } else if (enc->rc_max_rate > 0) {
1369  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1370  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
1371  }
1372 }
1373 
1374 const char *av_get_profile_name(const AVCodec *codec, int profile)
1375 {
1376  const AVProfile *p;
1377  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1378  return NULL;
1379 
1380  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1381  if (p->profile == profile)
1382  return p->name;
1383 
1384  return NULL;
1385 }
1386 
1388 {
1389  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
1390  const AVProfile *p;
1391 
1392  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1393  return NULL;
1394 
1395  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1396  if (p->profile == profile)
1397  return p->name;
1398 
1399  return NULL;
1400 }
1401 
1402 unsigned avcodec_version(void)
1403 {
1406  av_assert0(AV_CODEC_ID_SRT==94216);
1408 
1409  return LIBAVCODEC_VERSION_INT;
1410 }
1411 
1412 const char *avcodec_configuration(void)
1413 {
1414  return FFMPEG_CONFIGURATION;
1415 }
1416 
1417 const char *avcodec_license(void)
1418 {
1419 #define LICENSE_PREFIX "libavcodec license: "
1420  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
1421 }
1422 
1424 {
1425  switch (codec_id) {
1426  case AV_CODEC_ID_8SVX_EXP:
1427  case AV_CODEC_ID_8SVX_FIB:
1428  case AV_CODEC_ID_ADPCM_CT:
1436  return 4;
1437  case AV_CODEC_ID_DSD_LSBF:
1438  case AV_CODEC_ID_DSD_MSBF:
1441  case AV_CODEC_ID_PCM_ALAW:
1442  case AV_CODEC_ID_PCM_MULAW:
1443  case AV_CODEC_ID_PCM_VIDC:
1444  case AV_CODEC_ID_PCM_S8:
1446  case AV_CODEC_ID_PCM_U8:
1447  case AV_CODEC_ID_PCM_ZORK:
1448  case AV_CODEC_ID_SDX2_DPCM:
1449  return 8;
1450  case AV_CODEC_ID_PCM_S16BE:
1452  case AV_CODEC_ID_PCM_S16LE:
1454  case AV_CODEC_ID_PCM_U16BE:
1455  case AV_CODEC_ID_PCM_U16LE:
1456  return 16;
1458  case AV_CODEC_ID_PCM_S24BE:
1459  case AV_CODEC_ID_PCM_S24LE:
1461  case AV_CODEC_ID_PCM_U24BE:
1462  case AV_CODEC_ID_PCM_U24LE:
1463  return 24;
1464  case AV_CODEC_ID_PCM_S32BE:
1465  case AV_CODEC_ID_PCM_S32LE:
1467  case AV_CODEC_ID_PCM_U32BE:
1468  case AV_CODEC_ID_PCM_U32LE:
1469  case AV_CODEC_ID_PCM_F32BE:
1470  case AV_CODEC_ID_PCM_F32LE:
1471  case AV_CODEC_ID_PCM_F24LE:
1472  case AV_CODEC_ID_PCM_F16LE:
1473  return 32;
1474  case AV_CODEC_ID_PCM_F64BE:
1475  case AV_CODEC_ID_PCM_F64LE:
1476  case AV_CODEC_ID_PCM_S64BE:
1477  case AV_CODEC_ID_PCM_S64LE:
1478  return 64;
1479  default:
1480  return 0;
1481  }
1482 }
1483 
1485 {
1486  static const enum AVCodecID map[AV_SAMPLE_FMT_NB][2] = {
1492  [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
1493  [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
1494  [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
1496  [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
1497  [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
1498  };
1499  if (fmt < 0 || fmt >= AV_SAMPLE_FMT_NB)
1500  return AV_CODEC_ID_NONE;
1501  if (be < 0 || be > 1)
1502  be = AV_NE(1, 0);
1503  return map[fmt][be];
1504 }
1505 
1507 {
1508  switch (codec_id) {
1510  return 2;
1512  return 3;
1516  case AV_CODEC_ID_ADPCM_SWF:
1517  case AV_CODEC_ID_ADPCM_MS:
1518  return 4;
1519  default:
1520  return av_get_exact_bits_per_sample(codec_id);
1521  }
1522 }
1523 
1524 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1525  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
1526  uint8_t * extradata, int frame_size, int frame_bytes)
1527 {
1529  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
1530 
1531  /* codecs with an exact constant bits per sample */
1532  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
1533  return (frame_bytes * 8LL) / (bps * ch);
1534  bps = bits_per_coded_sample;
1535 
1536  /* codecs with a fixed packet duration */
1537  switch (id) {
1538  case AV_CODEC_ID_ADPCM_ADX: return 32;
1539  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
1540  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
1541  case AV_CODEC_ID_AMR_NB:
1542  case AV_CODEC_ID_EVRC:
1543  case AV_CODEC_ID_GSM:
1544  case AV_CODEC_ID_QCELP:
1545  case AV_CODEC_ID_RA_288: return 160;
1546  case AV_CODEC_ID_AMR_WB:
1547  case AV_CODEC_ID_GSM_MS: return 320;
1548  case AV_CODEC_ID_MP1: return 384;
1549  case AV_CODEC_ID_ATRAC1: return 512;
1550  case AV_CODEC_ID_ATRAC9:
1551  case AV_CODEC_ID_ATRAC3: return 1024 * framecount;
1552  case AV_CODEC_ID_ATRAC3P: return 2048;
1553  case AV_CODEC_ID_MP2:
1554  case AV_CODEC_ID_MUSEPACK7: return 1152;
1555  case AV_CODEC_ID_AC3: return 1536;
1556  }
1557 
1558  if (sr > 0) {
1559  /* calc from sample rate */
1560  if (id == AV_CODEC_ID_TTA)
1561  return 256 * sr / 245;
1562  else if (id == AV_CODEC_ID_DST)
1563  return 588 * sr / 44100;
1564 
1565  if (ch > 0) {
1566  /* calc from sample rate and channels */
1567  if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1568  return (480 << (sr / 22050)) / ch;
1569  }
1570 
1571  if (id == AV_CODEC_ID_MP3)
1572  return sr <= 24000 ? 576 : 1152;
1573  }
1574 
1575  if (ba > 0) {
1576  /* calc from block_align */
1577  if (id == AV_CODEC_ID_SIPR) {
1578  switch (ba) {
1579  case 20: return 160;
1580  case 19: return 144;
1581  case 29: return 288;
1582  case 37: return 480;
1583  }
1584  } else if (id == AV_CODEC_ID_ILBC) {
1585  switch (ba) {
1586  case 38: return 160;
1587  case 50: return 240;
1588  }
1589  }
1590  }
1591 
1592  if (frame_bytes > 0) {
1593  /* calc from frame_bytes only */
1594  if (id == AV_CODEC_ID_TRUESPEECH)
1595  return 240 * (frame_bytes / 32);
1596  if (id == AV_CODEC_ID_NELLYMOSER)
1597  return 256 * (frame_bytes / 64);
1598  if (id == AV_CODEC_ID_RA_144)
1599  return 160 * (frame_bytes / 20);
1600 
1601  if (bps > 0) {
1602  /* calc from frame_bytes and bits_per_coded_sample */
1604  return frame_bytes * 8 / bps;
1605  }
1606 
1607  if (ch > 0 && ch < INT_MAX/16) {
1608  /* calc from frame_bytes and channels */
1609  switch (id) {
1610  case AV_CODEC_ID_ADPCM_AFC:
1611  return frame_bytes / (9 * ch) * 16;
1612  case AV_CODEC_ID_ADPCM_PSX:
1613  case AV_CODEC_ID_ADPCM_DTK:
1614  return frame_bytes / (16 * ch) * 28;
1615  case AV_CODEC_ID_ADPCM_4XM:
1618  return (frame_bytes - 4 * ch) * 2 / ch;
1620  return (frame_bytes - 4) * 2 / ch;
1622  return (frame_bytes - 8) * 2 / ch;
1623  case AV_CODEC_ID_ADPCM_THP:
1625  if (extradata)
1626  return frame_bytes * 14 / (8 * ch);
1627  break;
1628  case AV_CODEC_ID_ADPCM_XA:
1629  return (frame_bytes / 128) * 224 / ch;
1631  return (frame_bytes - 6 - ch) / ch;
1632  case AV_CODEC_ID_ROQ_DPCM:
1633  return (frame_bytes - 8) / ch;
1634  case AV_CODEC_ID_XAN_DPCM:
1635  return (frame_bytes - 2 * ch) / ch;
1636  case AV_CODEC_ID_MACE3:
1637  return 3 * frame_bytes / ch;
1638  case AV_CODEC_ID_MACE6:
1639  return 6 * frame_bytes / ch;
1640  case AV_CODEC_ID_PCM_LXF:
1641  return 2 * (frame_bytes / (5 * ch));
1642  case AV_CODEC_ID_IAC:
1643  case AV_CODEC_ID_IMC:
1644  return 4 * frame_bytes / ch;
1645  }
1646 
1647  if (tag) {
1648  /* calc from frame_bytes, channels, and codec_tag */
1649  if (id == AV_CODEC_ID_SOL_DPCM) {
1650  if (tag == 3)
1651  return frame_bytes / ch;
1652  else
1653  return frame_bytes * 2 / ch;
1654  }
1655  }
1656 
1657  if (ba > 0) {
1658  /* calc from frame_bytes, channels, and block_align */
1659  int blocks = frame_bytes / ba;
1660  switch (id) {
1662  if (bps < 2 || bps > 5)
1663  return 0;
1664  return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
1666  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1668  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1670  return blocks * ((ba - 4 * ch) * 2 / ch);
1671  case AV_CODEC_ID_ADPCM_MS:
1672  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1674  return blocks * (ba - 16) * 2 / ch;
1675  }
1676  }
1677 
1678  if (bps > 0) {
1679  /* calc from frame_bytes, channels, and bits_per_coded_sample */
1680  switch (id) {
1681  case AV_CODEC_ID_PCM_DVD:
1682  if(bps<4 || frame_bytes<3)
1683  return 0;
1684  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
1686  if(bps<4 || frame_bytes<4)
1687  return 0;
1688  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
1689  case AV_CODEC_ID_S302M:
1690  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1691  }
1692  }
1693  }
1694  }
1695 
1696  /* Fall back on using frame_size */
1697  if (frame_size > 1 && frame_bytes)
1698  return frame_size;
1699 
1700  //For WMA we currently have no other means to calculate duration thus we
1701  //do it here by assuming CBR, which is true for all known cases.
1702  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
1703  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
1704  return (frame_bytes * 8LL * sr) / bitrate;
1705  }
1706 
1707  return 0;
1708 }
1709 
1710 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1711 {
1712  return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1713  avctx->channels, avctx->block_align,
1714  avctx->codec_tag, avctx->bits_per_coded_sample,
1715  avctx->bit_rate, avctx->extradata, avctx->frame_size,
1716  frame_bytes);
1717 }
1718 
1720 {
1721  return get_audio_frame_duration(par->codec_id, par->sample_rate,
1722  par->channels, par->block_align,
1723  par->codec_tag, par->bits_per_coded_sample,
1724  par->bit_rate, par->extradata, par->frame_size,
1725  frame_bytes);
1726 }
1727 
1728 #if !HAVE_THREADS
1730 {
1731  return -1;
1732 }
1733 
1734 #endif
1735 
1736 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1737 {
1738  unsigned int n = 0;
1739 
1740  while (v >= 0xff) {
1741  *s++ = 0xff;
1742  v -= 0xff;
1743  n++;
1744  }
1745  *s = v;
1746  n++;
1747  return n;
1748 }
1749 
1750 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1751 {
1752  int i;
1753  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1754  return i;
1755 }
1756 
1758 {
1759  int i;
1760  if (!codec->hw_configs || index < 0)
1761  return NULL;
1762  for (i = 0; i <= index; i++)
1763  if (!codec->hw_configs[i])
1764  return NULL;
1765  return &codec->hw_configs[index]->public;
1766 }
1767 
1768 #if FF_API_USER_VISIBLE_AVHWACCEL
1770 {
1771  return NULL;
1772 }
1773 
1775 {
1776 }
1777 #endif
1778 
1779 #if FF_API_LOCKMGR
1780 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1781 {
1782  return 0;
1783 }
1784 #endif
1785 
1786 unsigned int avpriv_toupper4(unsigned int x)
1787 {
1788  return av_toupper(x & 0xFF) +
1789  (av_toupper((x >> 8) & 0xFF) << 8) +
1790  (av_toupper((x >> 16) & 0xFF) << 16) +
1791 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
1792 }
1793 
1795 {
1796  int ret;
1797 
1798  dst->owner[0] = src->owner[0];
1799  dst->owner[1] = src->owner[1];
1800 
1801  ret = av_frame_ref(dst->f, src->f);
1802  if (ret < 0)
1803  return ret;
1804 
1805  av_assert0(!dst->progress);
1806 
1807  if (src->progress &&
1808  !(dst->progress = av_buffer_ref(src->progress))) {
1809  ff_thread_release_buffer(dst->owner[0], dst);
1810  return AVERROR(ENOMEM);
1811  }
1812 
1813  return 0;
1814 }
1815 
1816 #if !HAVE_THREADS
1817 
1819 {
1820  return ff_get_format(avctx, fmt);
1821 }
1822 
1824 {
1825  f->owner[0] = f->owner[1] = avctx;
1826  return ff_get_buffer(avctx, f->f, flags);
1827 }
1828 
1830 {
1831  if (f->f)
1832  av_frame_unref(f->f);
1833 }
1834 
1836 {
1837 }
1838 
1840 {
1841 }
1842 
1843 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1844 {
1845 }
1846 
1848 {
1849  return 1;
1850 }
1851 
1853 {
1854  return 0;
1855 }
1856 
1858 {
1859 }
1860 
1861 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1862 {
1863 }
1864 
1865 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1866 {
1867 }
1868 
1869 #endif
1870 
1872 {
1873  return !!s->internal;
1874 }
1875 
1876 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
1877 {
1878  int ret;
1879  char *str;
1880 
1881  ret = av_bprint_finalize(buf, &str);
1882  if (ret < 0)
1883  return ret;
1884  if (!av_bprint_is_complete(buf)) {
1885  av_free(str);
1886  return AVERROR(ENOMEM);
1887  }
1888 
1889  avctx->extradata = str;
1890  /* Note: the string is NUL terminated (so extradata can be read as a
1891  * string), but the ending character is not accounted in the size (in
1892  * binary formats you are likely not supposed to mux that character). When
1893  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
1894  * zeros. */
1895  avctx->extradata_size = buf->len;
1896  return 0;
1897 }
1898 
1899 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
1900  const uint8_t *end,
1901  uint32_t *av_restrict state)
1902 {
1903  int i;
1904 
1905  av_assert0(p <= end);
1906  if (p >= end)
1907  return end;
1908 
1909  for (i = 0; i < 3; i++) {
1910  uint32_t tmp = *state << 8;
1911  *state = tmp + *(p++);
1912  if (tmp == 0x100 || p == end)
1913  return p;
1914  }
1915 
1916  while (p < end) {
1917  if (p[-1] > 1 ) p += 3;
1918  else if (p[-2] ) p += 2;
1919  else if (p[-3]|(p[-1]-1)) p++;
1920  else {
1921  p++;
1922  break;
1923  }
1924  }
1925 
1926  p = FFMIN(p, end) - 4;
1927  *state = AV_RB32(p);
1928 
1929  return p + 4;
1930 }
1931 
1933 {
1934  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1935  if (!props)
1936  return NULL;
1937 
1938  if (size)
1939  *size = sizeof(*props);
1940 
1941  props->vbv_delay = UINT64_MAX;
1942 
1943  return props;
1944 }
1945 
1947 {
1949  AVCPBProperties *props;
1950  size_t size;
1951 
1952  props = av_cpb_properties_alloc(&size);
1953  if (!props)
1954  return NULL;
1955 
1956  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
1957  if (!tmp) {
1958  av_freep(&props);
1959  return NULL;
1960  }
1961 
1962  avctx->coded_side_data = tmp;
1963  avctx->nb_coded_side_data++;
1964 
1966  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
1967  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
1968 
1969  return props;
1970 }
1971 
1973 {
1974  av_freep(&par->extradata);
1975 
1976  memset(par, 0, sizeof(*par));
1977 
1979  par->codec_id = AV_CODEC_ID_NONE;
1980  par->format = -1;
1987  par->sample_aspect_ratio = (AVRational){ 0, 1 };
1988  par->profile = FF_PROFILE_UNKNOWN;
1989  par->level = FF_LEVEL_UNKNOWN;
1990 }
1991 
1993 {
1994  AVCodecParameters *par = av_mallocz(sizeof(*par));
1995 
1996  if (!par)
1997  return NULL;
1999  return par;
2000 }
2001 
2003 {
2004  AVCodecParameters *par = *ppar;
2005 
2006  if (!par)
2007  return;
2009 
2010  av_freep(ppar);
2011 }
2012 
2014 {
2016  memcpy(dst, src, sizeof(*dst));
2017 
2018  dst->extradata = NULL;
2019  dst->extradata_size = 0;
2020  if (src->extradata) {
2022  if (!dst->extradata)
2023  return AVERROR(ENOMEM);
2024  memcpy(dst->extradata, src->extradata, src->extradata_size);
2025  dst->extradata_size = src->extradata_size;
2026  }
2027 
2028  return 0;
2029 }
2030 
2032  const AVCodecContext *codec)
2033 {
2035 
2036  par->codec_type = codec->codec_type;
2037  par->codec_id = codec->codec_id;
2038  par->codec_tag = codec->codec_tag;
2039 
2040  par->bit_rate = codec->bit_rate;
2043  par->profile = codec->profile;
2044  par->level = codec->level;
2045 
2046  switch (par->codec_type) {
2047  case AVMEDIA_TYPE_VIDEO:
2048  par->format = codec->pix_fmt;
2049  par->width = codec->width;
2050  par->height = codec->height;
2051  par->field_order = codec->field_order;
2052  par->color_range = codec->color_range;
2053  par->color_primaries = codec->color_primaries;
2054  par->color_trc = codec->color_trc;
2055  par->color_space = codec->colorspace;
2058  par->video_delay = codec->has_b_frames;
2059  break;
2060  case AVMEDIA_TYPE_AUDIO:
2061  par->format = codec->sample_fmt;
2062  par->channel_layout = codec->channel_layout;
2063  par->channels = codec->channels;
2064  par->sample_rate = codec->sample_rate;
2065  par->block_align = codec->block_align;
2066  par->frame_size = codec->frame_size;
2067  par->initial_padding = codec->initial_padding;
2068  par->trailing_padding = codec->trailing_padding;
2069  par->seek_preroll = codec->seek_preroll;
2070  break;
2071  case AVMEDIA_TYPE_SUBTITLE:
2072  par->width = codec->width;
2073  par->height = codec->height;
2074  break;
2075  }
2076 
2077  if (codec->extradata) {
2079  if (!par->extradata)
2080  return AVERROR(ENOMEM);
2081  memcpy(par->extradata, codec->extradata, codec->extradata_size);
2082  par->extradata_size = codec->extradata_size;
2083  }
2084 
2085  return 0;
2086 }
2087 
2089  const AVCodecParameters *par)
2090 {
2091  codec->codec_type = par->codec_type;
2092  codec->codec_id = par->codec_id;
2093  codec->codec_tag = par->codec_tag;
2094 
2095  codec->bit_rate = par->bit_rate;
2098  codec->profile = par->profile;
2099  codec->level = par->level;
2100 
2101  switch (par->codec_type) {
2102  case AVMEDIA_TYPE_VIDEO:
2103  codec->pix_fmt = par->format;
2104  codec->width = par->width;
2105  codec->height = par->height;
2106  codec->field_order = par->field_order;
2107  codec->color_range = par->color_range;
2108  codec->color_primaries = par->color_primaries;
2109  codec->color_trc = par->color_trc;
2110  codec->colorspace = par->color_space;
2113  codec->has_b_frames = par->video_delay;
2114  break;
2115  case AVMEDIA_TYPE_AUDIO:
2116  codec->sample_fmt = par->format;
2117  codec->channel_layout = par->channel_layout;
2118  codec->channels = par->channels;
2119  codec->sample_rate = par->sample_rate;
2120  codec->block_align = par->block_align;
2121  codec->frame_size = par->frame_size;
2122  codec->delay =
2123  codec->initial_padding = par->initial_padding;
2124  codec->trailing_padding = par->trailing_padding;
2125  codec->seek_preroll = par->seek_preroll;
2126  break;
2127  case AVMEDIA_TYPE_SUBTITLE:
2128  codec->width = par->width;
2129  codec->height = par->height;
2130  break;
2131  }
2132 
2133  if (par->extradata) {
2134  av_freep(&codec->extradata);
2136  if (!codec->extradata)
2137  return AVERROR(ENOMEM);
2138  memcpy(codec->extradata, par->extradata, par->extradata_size);
2139  codec->extradata_size = par->extradata_size;
2140  }
2141 
2142  return 0;
2143 }
2144 
2145 int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
2146  void **data, size_t *sei_size)
2147 {
2148  AVFrameSideData *side_data = NULL;
2149  uint8_t *sei_data;
2150 
2151  if (frame)
2152  side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC);
2153 
2154  if (!side_data) {
2155  *data = NULL;
2156  return 0;
2157  }
2158 
2159  *sei_size = side_data->size + 11;
2160  *data = av_mallocz(*sei_size + prefix_len);
2161  if (!*data)
2162  return AVERROR(ENOMEM);
2163  sei_data = (uint8_t*)*data + prefix_len;
2164 
2165  // country code
2166  sei_data[0] = 181;
2167  sei_data[1] = 0;
2168  sei_data[2] = 49;
2169 
2170  /**
2171  * 'GA94' is standard in North America for ATSC, but hard coding
2172  * this style may not be the right thing to do -- other formats
2173  * do exist. This information is not available in the side_data
2174  * so we are going with this right now.
2175  */
2176  AV_WL32(sei_data + 3, MKTAG('G', 'A', '9', '4'));
2177  sei_data[7] = 3;
2178  sei_data[8] = ((side_data->size/3) & 0x1f) | 0x40;
2179  sei_data[9] = 0;
2180 
2181  memcpy(sei_data + 10, side_data->data, side_data->size);
2182 
2183  sei_data[side_data->size+10] = 255;
2184 
2185  return 0;
2186 }
2187 
2189 {
2190  AVRational framerate = avctx->framerate;
2191  int bits_per_coded_sample = avctx->bits_per_coded_sample;
2192  int64_t bitrate;
2193 
2194  if (!(framerate.num && framerate.den))
2195  framerate = av_inv_q(avctx->time_base);
2196  if (!(framerate.num && framerate.den))
2197  return 0;
2198 
2199  if (!bits_per_coded_sample) {
2201  bits_per_coded_sample = av_get_bits_per_pixel(desc);
2202  }
2203  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
2204  framerate.num / framerate.den;
2205 
2206  return bitrate;
2207 }
2208 
2209 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
2210  const int * array_valid_values, int default_value)
2211 {
2212  int i = 0, ref_val;
2213 
2214  while (1) {
2215  ref_val = array_valid_values[i];
2216  if (ref_val == INT_MAX)
2217  break;
2218  if (val == ref_val)
2219  return val;
2220  i++;
2221  }
2222  /* val is not a valid value */
2223  av_log(ctx, AV_LOG_DEBUG,
2224  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
2225  return default_value;
2226 }
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:2188
#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
#define FF_SANE_NB_CHANNELS
Definition: internal.h:86
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2629
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwaccel.h:34
enum AVChromaLocation chroma_location
Definition: avcodec.h:4043
float, planar
Definition: samplefmt.h:69
#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:3159
#define NULL
Definition: coverity.c:32
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1371
const struct AVCodec * codec
Definition: avcodec.h:1574
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:166
AVRational framerate
Definition: avcodec.h:3101
const char const char void * val
Definition: avisynth_c.h:863
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4034
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: utils.c:494
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:3122
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:275
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:252
enum AVColorTransferCharacteristic color_trc
Definition: avcodec.h:4041
Number of sample formats. DO NOT USE if linking dynamically.
Definition: samplefmt.h:74
#define AV_NUM_DATA_POINTERS
Definition: frame.h:269
static int shift(int a, int b)
Definition: sonic.c:82
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:245
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
Definition: avcodec.h:3158
static AVMutex mutex
Definition: log.c:44
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:3139
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
unsigned int fourcc
Definition: raw.h:36
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:885
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:249
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:159
const struct AVCodecHWConfigInternal ** hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: avcodec.h:3618
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1753
const char * fmt
Definition: avisynth_c.h:861
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:172
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVFrame * f
Definition: thread.h:35
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian ...
Definition: pixfmt.h:346
AVFrame * to_free
Definition: internal.h:159
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
#define LIBAVCODEC_VERSION_MICRO
Definition: version.h:32
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:162
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:2474
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4029
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2467
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:250
channels
Definition: aptx.c:30
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1305
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: utils.c:1412
uint32_t fourcc
Definition: vaapi_decode.c:238
enum AVCodecID codec_id
Definition: qsv.c:72
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2196
int ff_decode_bsfs_init(AVCodecContext *avctx)
Definition: decode.c:185
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int num
Numerator.
Definition: rational.h:59
static int ff_mutex_lock(AVMutex *mutex)
Definition: thread.h:155
#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:3157
static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
Definition: utils.c:518
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/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_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 *(INT64_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 *(INT64_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 &&1) 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
const char * avcodec_license(void)
Return the libavcodec license.
Definition: utils.c:1417
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:1944
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:189
double, planar
Definition: samplefmt.h:70
enum AVMediaType codec_type
Definition: rtp.c:37
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:36
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
enum AVPixelFormat pix_fmt
Definition: raw.h:35
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:208
unsigned num_rects
Definition: avcodec.h:3933
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:490
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
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:255
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:156
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1029
mpegvideo header.
enum AVMediaType type
Definition: avcodec.h:3490
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
AVBufferPool * pools[4]
Pools for each data plane.
Definition: internal.h:105
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2792
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: utils.c:1818
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:1780
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
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: avcodec.h:1049
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2725
int trailing_padding
Audio only.
Definition: avcodec.h:4089
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2894
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AVCodec.
Definition: avcodec.h:3477
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:131
int framerate
Definition: h264_levels.c:65
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2258
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3945
AVLockOp
Lock operation used by lockmgr.
Definition: avcodec.h:6125
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
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
char * text
0 terminated plain UTF-8 text
Definition: avcodec.h:3917
enum AVColorSpace color_space
Definition: avcodec.h:4042
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2915
Macro definitions for various function/variable attributes.
void ff_decode_bsfs_uninit(AVCodecContext *avctx)
Definition: decode.c:2053
int frame_size
Audio only.
Definition: avcodec.h:4074
static AVMutex codec_mutex
Definition: utils.c:68
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:734
AVSubtitleRect ** rects
Definition: avcodec.h:3934
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:3783
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:1861
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
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:94
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:1170
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian ...
Definition: pixfmt.h:179
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
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:3015
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:216
Public dictionary API.
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:190
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
#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
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:62
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian ...
Definition: pixfmt.h:344
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2229
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
AV_SAMPLE_FMT_U8
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4019
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:1992
#define f(width, name)
Definition: cbs_vp9.c:255
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2848
void * thread_ctx
Definition: internal.h:163
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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
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
int trailing_padding
Audio only.
Definition: avcodec.h:3280
Multithreading support functions.
#define AV_NE(be, le)
Definition: common.h:50
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:443
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:3224
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
#define LICENSE_PREFIX
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
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:2088
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:191
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1946
Public header for CRC hash function implementation.
void * frame_thread_encoder
Definition: internal.h:180
int initial_padding
Audio only.
Definition: avcodec.h:4082
Structure to hold side data for an AVFrame.
Definition: frame.h:201
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
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:530
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:276
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:174
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
Definition: pixfmt.h:100
uint32_t tag
Definition: movenc.c:1496
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:194
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
uint8_t * data
Definition: avcodec.h:1421
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:1524
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2800
int av_codec_get_max_lowres(const AVCodec *codec)
Definition: utils.c:484
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
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:1750
ptrdiff_t size
Definition: opengl_enc.c:100
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
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2785
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:278
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
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
signed 32 bits
Definition: samplefmt.h:62
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
Definition: utils.c:1932
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2203
static void codec_parameters_reset(AVCodecParameters *par)
Definition: utils.c:1972
#define FFALIGN(x, a)
Definition: macros.h:48
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4055
#define av_log(a,...)
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
FramePool * pool
Definition: internal.h:161
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3982
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2628
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
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
void av_register_hwaccel(AVHWAccel *hwaccel)
Register the hardware accelerator hwaccel.
Definition: utils.c:1774
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
Libavcodec version macros.
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:1073
enum AVCodecID id
Definition: avcodec.h:3491
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: avcodec.h:3501
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:170
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:165
const char * av_chroma_location_name(enum AVChromaLocation location)
Definition: pixdesc.c:2939
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
Definition: utils.c:479
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2013
int width
Definition: frame.h:326
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1855
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1506
#define AVMutex
Definition: thread.h:151
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
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:2209
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:91
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:136
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1786
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
int(* send_frame)(AVCodecContext *avctx, const AVFrame *frame)
Encode API with decoupled packet/frame dataflow.
Definition: avcodec.h:3585
int qmax
maximum quantizer
Definition: avcodec.h:2410
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
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
Definition: avcodec.h:3140
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2839
enum AVColorPrimaries color_primaries
Definition: avcodec.h:4040
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1871
int video_delay
Video only.
Definition: avcodec.h:4048
const char * r
Definition: vf_curves.c:114
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:443
AVFrame * buffer_frame
Definition: internal.h:202
int capabilities
Codec capabilities.
Definition: avcodec.h:3496
int initial_padding
Audio only.
Definition: avcodec.h:3092
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:1729
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:182
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
const char * arg
Definition: jacosubdec.c:66
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:161
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
simple assert() macros that are a bit more flexible than ISO C assert().
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:248
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
Definition: mathematics.c:37
enum AVPacketSideDataType type
Definition: avcodec.h:1423
int av_log_get_level(void)
Get the current log level.
Definition: log.c:380
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:134
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
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3288
const struct AVProfile * profiles
If non-NULL, an array of profiles recognized for this codec.
Definition: avcodec.h:743
GLsizei count
Definition: opengl_enc.c:108
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:183
void ff_thread_free(AVCodecContext *avctx)
Definition: pthread.c:82
#define FFMAX(a, b)
Definition: common.h:94
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:2002
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:1719
const char av_codec_ffversion[]
Definition: utils.c:66
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:156
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2867
reference-counted frame API
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2272
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3971
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:184
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2424
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:732
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
common internal API header
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
Definition: internal.h:253
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
int refs
number of reference frames
Definition: avcodec.h:2149
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:287
int block_align
Audio only.
Definition: avcodec.h:4070
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define b
Definition: input.c:41
#define AV_MUTEX_INITIALIZER
Definition: thread.h:152
audio channel layout utility functions
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3498
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2831
#define FFMIN(a, b)
Definition: common.h:96
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:3233
Raw Video Codec.
signed 32 bits, planar
Definition: samplefmt.h:68
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1423
AVFrame * compat_decode_frame
Definition: internal.h:213
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1865
int width
picture width / height.
Definition: avcodec.h:1738
static void ff_unlock_avcodec(const AVCodec *codec)
Definition: utils.c:524
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3258
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2895
int priv_data_size
Definition: avcodec.h:3525
int profile
Definition: avcodec.h:3411
AVPacket * in_pkt
Definition: internal.h:120
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:871
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2175
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:188
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:210
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
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:3014
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:1835
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:180
const AVProfile * profiles
array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN} ...
Definition: avcodec.h:3504
int n
Definition: avisynth_c.h:760
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
unsigned 8 bits, planar
Definition: samplefmt.h:66
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1697
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:243
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:158
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4039
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
Opaque data information usually sparse.
Definition: avutil.h:205
const char * av_get_colorspace_name(enum AVColorSpace val)
Get the name of a colorspace.
Definition: frame.c:122
DecodeSimpleContext ds
Definition: internal.h:165
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:461
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:3148
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:167
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:3912
#define FF_ARRAY_ELEMS(a)
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
Definition: error.h:72
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1139
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2820
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:522
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:3156
if(ret)
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.
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:288
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:341
const AVS_VideoInfo int align
Definition: avisynth_c.h:887
AVBufferRef * progress
Definition: thread.h:39
const char * av_get_profile_name(const AVCodec *codec, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1374
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2241
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1128
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
static int width
Definition: utils.c:158
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:132
int frame_size
Definition: mxfenc.c:2216
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:1769
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:1573
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:1484
enum AVCodecID codec_id
Definition: avcodec.h:1575
int seek_preroll
Number of samples to skip after a discontinuity.
Definition: avcodec.h:3181
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1603
int sample_rate
samples per second
Definition: avcodec.h:2221
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1757
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
main external API structure.
Definition: avcodec.h:1565
int(* receive_frame)(AVCodecContext *avctx, AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: avcodec.h:3593
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:890
int skip_samples_multiplier
Definition: internal.h:217
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:192
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
uint8_t * data
The data buffer.
Definition: buffer.h:89
int qmin
minimum quantizer
Definition: avcodec.h:2403
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1054
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1590
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
uint8_t * data
Definition: frame.h:203
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:277
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: avcodec.h:775
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:257
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1667
int(* close)(AVCodecContext *)
Definition: avcodec.h:3576
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1736
int nb_coded_side_data
Definition: avcodec.h:3234
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:193
AVCodecContext * owner[2]
Definition: thread.h:36
int coded_height
Definition: avcodec.h:1753
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
Describe the class of an AVClass context structure.
Definition: log.h:67
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:3225
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:195
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:722
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:231
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
int index
Definition: gxfenc.c:89
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:275
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
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2189
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2182
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:1829
const char * name
short name for the profile
Definition: avcodec.h:3412
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:2031
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:123
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:244
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian ...
Definition: pixfmt.h:345
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:256
char * codec_whitelist
&#39;,&#39; separated list of allowed decoders.
Definition: avcodec.h:3216
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:178
const VDPAUPixFmtMap * map
#define STRIDE_ALIGN
Definition: internal.h:97
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:724
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:542
#define snprintf
Definition: snprintf.h:34
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1710
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
mfxU16 profile
Definition: qsvenc.c:44
int seek_preroll
Audio only.
Definition: avcodec.h:4093
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:716
int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:1876
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
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
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:187
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: avcodec.h:4008
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:3503
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:163
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:135
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
void ff_color_frame(AVFrame *frame, const int c[4])
Definition: utils.c:412
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: avcodec.h:4063
enum AVMediaType type
Definition: avcodec.h:718
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: avcodec.h:3502
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:200
int64_t bitrate
Definition: h264_levels.c:131
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:78
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:247
Y , 8bpp.
Definition: pixfmt.h:74
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1558
const OptionDef options[]
Definition: ffmpeg_opt.c:3362
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
Definition: avcodec.h:3575
common internal api header.
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
Converts swscale x/y chroma position to AVChromaLocation.
Definition: utils.c:365
#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
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
signed 16 bits
Definition: samplefmt.h:61
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:171
int(* init)(AVCodecContext *)
Definition: avcodec.h:3560
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: avcodec.h:4013
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2891
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:190
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
int(* encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: avcodec.h:3561
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AVProfile.
Definition: avcodec.h:3410
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:133
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: utils.c:1847
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2811
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:1839
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
static const uint64_t c2
Definition: murmur3.c:50
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:375
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
int caps_internal
Internal codec capabilities.
Definition: avcodec.h:3603
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3223
int den
Denominator.
Definition: rational.h:60
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:448
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
unsigned bps
Definition: movenc.c:1497
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:185
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1179
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:875
static int lowres
Definition: ffplay.c:335
void * priv_data
Definition: avcodec.h:1592
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:1159
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
#define av_free(p)
uint8_t * dump_separator
dump format separator.
Definition: avcodec.h:3208
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int(* encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: avcodec.h:3573
#define TAG_PRINT(x)
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:253
as in Berlin toast format
Definition: avcodec.h:582
int len
int channels
number of audio channels
Definition: avcodec.h:2222
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: avcodec.h:3499
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1600
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: utils.c:1402
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:51
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:3924
This side data corresponds to the AVCPBProperties struct.
Definition: avcodec.h:1289
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
Not part of ABI.
Definition: pixfmt.h:549
signed 64 bits, planar
Definition: samplefmt.h:72
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3995
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3967
static const struct twinvq_data tab
unsigned int byte_buffer_size
Definition: internal.h:178
int channels
Audio only.
Definition: avcodec.h:4059
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: utils.c:1843
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:186
static int height
Definition: utils.c:158
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int64_t pts_correction_last_dts
PTS of the last frame.
Definition: avcodec.h:3141
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2252
int height
Definition: frame.h:326
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
#define av_freep(p)
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
Definition: avcodec.h:3138
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:2218
signed 16 bits, planar
Definition: samplefmt.h:67
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:541
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1794
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:175
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3500
AVMatrixEncoding
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: utils.c:1823
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3957
int ff_alloc_entries(AVCodecContext *avctx, int count)
Definition: utils.c:1852
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:2145
int nb_channels
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:2438
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:181
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:1899
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:1857
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
int depth
Number of bits in the component.
Definition: pixdesc.h:58
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:315
#define MKTAG(a, b, c, d)
Definition: common.h:366
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:217
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:3310
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Definition: pixfmt.h:82
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:221
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:177
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1387
static int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
Definition: mem_internal.h:27
int delay
Codec delay.
Definition: avcodec.h:1721
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:334
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2624
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:242
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
Definition: frame.h:67
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:164
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3108
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:246
#define FFMAX3(a, b, c)
Definition: common.h:95
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:173
static struct @308 state
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: utils.c:435
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2439
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/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(INT64_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 *(INT64_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 *(INT64_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 &&1) 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:56
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian ...
Definition: pixfmt.h:343
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:3046
static uint8_t tmp[11]
Definition: aes_ctr.c:26
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:160