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;
416 
418 
419  for (p = 0; p<desc->nb_components; p++) {
420  uint8_t *dst = frame->data[p];
421  int is_chroma = p == 1 || p == 2;
422  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
423  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
424  if (desc->comp[0].depth >= 9) {
425  ((uint16_t*)dst)[0] = c[p];
426  av_memcpy_backptr(dst + 2, 2, bytes - 2);
427  dst += frame->linesize[p];
428  for (y = 1; y < height; y++) {
429  memcpy(dst, frame->data[p], 2*bytes);
430  dst += frame->linesize[p];
431  }
432  } else {
433  for (y = 0; y < height; y++) {
434  memset(dst, c[p], bytes);
435  dst += frame->linesize[p];
436  }
437  }
438  }
439 }
440 
441 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
442 {
443  int i;
444 
445  for (i = 0; i < count; i++) {
446  int r = func(c, (char *)arg + i * size);
447  if (ret)
448  ret[i] = r;
449  }
450  emms_c();
451  return 0;
452 }
453 
454 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
455 {
456  int i;
457 
458  for (i = 0; i < count; i++) {
459  int r = func(c, arg, i, 0);
460  if (ret)
461  ret[i] = r;
462  }
463  emms_c();
464  return 0;
465 }
466 
468  unsigned int fourcc)
469 {
470  while (tags->pix_fmt >= 0) {
471  if (tags->fourcc == fourcc)
472  return tags->pix_fmt;
473  tags++;
474  }
475  return AV_PIX_FMT_NONE;
476 }
477 
478 #if FF_API_CODEC_GET_SET
479 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
480 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
482 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
483 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
484 
486 {
487  return codec->properties;
488 }
489 
491 {
492  return codec->max_lowres;
493 }
494 #endif
495 
498 }
499 
501 {
502  int64_t bit_rate;
503  int bits_per_sample;
504 
505  switch (ctx->codec_type) {
506  case AVMEDIA_TYPE_VIDEO:
507  case AVMEDIA_TYPE_DATA:
510  bit_rate = ctx->bit_rate;
511  break;
512  case AVMEDIA_TYPE_AUDIO:
513  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
514  bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
515  break;
516  default:
517  bit_rate = 0;
518  break;
519  }
520  return bit_rate;
521 }
522 
523 
524 static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
525 {
526  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
528 }
529 
530 static void ff_unlock_avcodec(const AVCodec *codec)
531 {
532  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
534 }
535 
536 int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
537 {
538  int ret = 0;
539 
540  ff_unlock_avcodec(codec);
541 
542  ret = avcodec_open2(avctx, codec, options);
543 
544  ff_lock_avcodec(avctx, codec);
545  return ret;
546 }
547 
548 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
549 {
550  int ret = 0;
551  int codec_init_ok = 0;
552  AVDictionary *tmp = NULL;
553  const AVPixFmtDescriptor *pixdesc;
554  AVCodecInternal *avci;
555 
556  if (avcodec_is_open(avctx))
557  return 0;
558 
559  if (!codec && !avctx->codec) {
560  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
561  return AVERROR(EINVAL);
562  }
563  if (codec && avctx->codec && codec != avctx->codec) {
564  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
565  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
566  return AVERROR(EINVAL);
567  }
568  if (!codec)
569  codec = avctx->codec;
570 
571  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
572  return AVERROR(EINVAL);
573 
574  if (options)
575  av_dict_copy(&tmp, *options, 0);
576 
577  ff_lock_avcodec(avctx, codec);
578 
579  avci = av_mallocz(sizeof(*avci));
580  if (!avci) {
581  ret = AVERROR(ENOMEM);
582  goto end;
583  }
584  avctx->internal = avci;
585 
586  avci->pool = av_mallocz(sizeof(*avci->pool));
587  if (!avci->pool) {
588  ret = AVERROR(ENOMEM);
589  goto free_and_end;
590  }
591 
592  avci->to_free = av_frame_alloc();
593  if (!avci->to_free) {
594  ret = AVERROR(ENOMEM);
595  goto free_and_end;
596  }
597 
599  if (!avci->compat_decode_frame) {
600  ret = AVERROR(ENOMEM);
601  goto free_and_end;
602  }
603 
604  avci->buffer_frame = av_frame_alloc();
605  if (!avci->buffer_frame) {
606  ret = AVERROR(ENOMEM);
607  goto free_and_end;
608  }
609 
610  avci->buffer_pkt = av_packet_alloc();
611  if (!avci->buffer_pkt) {
612  ret = AVERROR(ENOMEM);
613  goto free_and_end;
614  }
615 
616  avci->ds.in_pkt = av_packet_alloc();
617  if (!avci->ds.in_pkt) {
618  ret = AVERROR(ENOMEM);
619  goto free_and_end;
620  }
621 
623  if (!avci->last_pkt_props) {
624  ret = AVERROR(ENOMEM);
625  goto free_and_end;
626  }
627 
628  avci->skip_samples_multiplier = 1;
629 
630  if (codec->priv_data_size > 0) {
631  if (!avctx->priv_data) {
632  avctx->priv_data = av_mallocz(codec->priv_data_size);
633  if (!avctx->priv_data) {
634  ret = AVERROR(ENOMEM);
635  goto end;
636  }
637  if (codec->priv_class) {
638  *(const AVClass **)avctx->priv_data = codec->priv_class;
640  }
641  }
642  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
643  goto free_and_end;
644  } else {
645  avctx->priv_data = NULL;
646  }
647  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
648  goto free_and_end;
649 
650  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
651  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
652  ret = AVERROR(EINVAL);
653  goto free_and_end;
654  }
655 
656  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
657  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
658  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
659  if (avctx->coded_width && avctx->coded_height)
660  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
661  else if (avctx->width && avctx->height)
662  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
663  if (ret < 0)
664  goto free_and_end;
665  }
666 
667  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
668  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
669  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
670  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
671  ff_set_dimensions(avctx, 0, 0);
672  }
673 
674  if (avctx->width > 0 && avctx->height > 0) {
675  if (av_image_check_sar(avctx->width, avctx->height,
676  avctx->sample_aspect_ratio) < 0) {
677  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
678  avctx->sample_aspect_ratio.num,
679  avctx->sample_aspect_ratio.den);
680  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
681  }
682  }
683 
684  /* if the decoder init function was already called previously,
685  * free the already allocated subtitle_header before overwriting it */
686  if (av_codec_is_decoder(codec))
687  av_freep(&avctx->subtitle_header);
688 
689  if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
690  av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
691  ret = AVERROR(EINVAL);
692  goto free_and_end;
693  }
694  if (avctx->sample_rate < 0) {
695  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
696  ret = AVERROR(EINVAL);
697  goto free_and_end;
698  }
699  if (avctx->block_align < 0) {
700  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
701  ret = AVERROR(EINVAL);
702  goto free_and_end;
703  }
704 
705  avctx->codec = codec;
706  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
707  avctx->codec_id == AV_CODEC_ID_NONE) {
708  avctx->codec_type = codec->type;
709  avctx->codec_id = codec->id;
710  }
711  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
712  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
713  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
714  ret = AVERROR(EINVAL);
715  goto free_and_end;
716  }
717  avctx->frame_number = 0;
719 
720  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
722  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
723  AVCodec *codec2;
724  av_log(avctx, AV_LOG_ERROR,
725  "The %s '%s' is experimental but experimental codecs are not enabled, "
726  "add '-strict %d' if you want to use it.\n",
727  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
728  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
729  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
730  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
731  codec_string, codec2->name);
732  ret = AVERROR_EXPERIMENTAL;
733  goto free_and_end;
734  }
735 
736  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
737  (!avctx->time_base.num || !avctx->time_base.den)) {
738  avctx->time_base.num = 1;
739  avctx->time_base.den = avctx->sample_rate;
740  }
741 
742  if (!HAVE_THREADS)
743  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
744 
745  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
746  ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
747  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
748  ff_lock_avcodec(avctx, codec);
749  if (ret < 0)
750  goto free_and_end;
751  }
752 
753  if (av_codec_is_decoder(avctx->codec)) {
754  ret = ff_decode_bsfs_init(avctx);
755  if (ret < 0)
756  goto free_and_end;
757  }
758 
759  if (HAVE_THREADS
760  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
761  ret = ff_thread_init(avctx);
762  if (ret < 0) {
763  goto free_and_end;
764  }
765  }
766  if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
767  avctx->thread_count = 1;
768 
769  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
770  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
771  avctx->codec->max_lowres);
772  avctx->lowres = avctx->codec->max_lowres;
773  }
774 
775  if (av_codec_is_encoder(avctx->codec)) {
776  int i;
777 #if FF_API_CODED_FRAME
779  avctx->coded_frame = av_frame_alloc();
780  if (!avctx->coded_frame) {
781  ret = AVERROR(ENOMEM);
782  goto free_and_end;
783  }
785 #endif
786 
787  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
788  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
789  ret = AVERROR(EINVAL);
790  goto free_and_end;
791  }
792 
793  if (avctx->codec->sample_fmts) {
794  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
795  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
796  break;
797  if (avctx->channels == 1 &&
800  avctx->sample_fmt = avctx->codec->sample_fmts[i];
801  break;
802  }
803  }
804  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
805  char buf[128];
806  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
807  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
808  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
809  ret = AVERROR(EINVAL);
810  goto free_and_end;
811  }
812  }
813  if (avctx->codec->pix_fmts) {
814  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
815  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
816  break;
817  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
818  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
820  char buf[128];
821  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
822  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
823  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
824  ret = AVERROR(EINVAL);
825  goto free_and_end;
826  }
827  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
828  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
829  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
830  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
831  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
832  avctx->color_range = AVCOL_RANGE_JPEG;
833  }
834  if (avctx->codec->supported_samplerates) {
835  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
836  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
837  break;
838  if (avctx->codec->supported_samplerates[i] == 0) {
839  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
840  avctx->sample_rate);
841  ret = AVERROR(EINVAL);
842  goto free_and_end;
843  }
844  }
845  if (avctx->sample_rate < 0) {
846  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
847  avctx->sample_rate);
848  ret = AVERROR(EINVAL);
849  goto free_and_end;
850  }
851  if (avctx->codec->channel_layouts) {
852  if (!avctx->channel_layout) {
853  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
854  } else {
855  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
856  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
857  break;
858  if (avctx->codec->channel_layouts[i] == 0) {
859  char buf[512];
860  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
861  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
862  ret = AVERROR(EINVAL);
863  goto free_and_end;
864  }
865  }
866  }
867  if (avctx->channel_layout && avctx->channels) {
869  if (channels != avctx->channels) {
870  char buf[512];
871  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
872  av_log(avctx, AV_LOG_ERROR,
873  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
874  buf, channels, avctx->channels);
875  ret = AVERROR(EINVAL);
876  goto free_and_end;
877  }
878  } else if (avctx->channel_layout) {
880  }
881  if (avctx->channels < 0) {
882  av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
883  avctx->channels);
884  ret = AVERROR(EINVAL);
885  goto free_and_end;
886  }
887  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
888  pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
889  if ( avctx->bits_per_raw_sample < 0
890  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
891  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
892  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
893  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
894  }
895  if (avctx->width <= 0 || avctx->height <= 0) {
896  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
897  ret = AVERROR(EINVAL);
898  goto free_and_end;
899  }
900  }
901  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
902  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
903  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
904  }
905 
906  if (!avctx->rc_initial_buffer_occupancy)
907  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
908 
909  if (avctx->ticks_per_frame && avctx->time_base.num &&
910  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
911  av_log(avctx, AV_LOG_ERROR,
912  "ticks_per_frame %d too large for the timebase %d/%d.",
913  avctx->ticks_per_frame,
914  avctx->time_base.num,
915  avctx->time_base.den);
916  goto free_and_end;
917  }
918 
919  if (avctx->hw_frames_ctx) {
920  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
921  if (frames_ctx->format != avctx->pix_fmt) {
922  av_log(avctx, AV_LOG_ERROR,
923  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
924  ret = AVERROR(EINVAL);
925  goto free_and_end;
926  }
927  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
928  avctx->sw_pix_fmt != frames_ctx->sw_format) {
929  av_log(avctx, AV_LOG_ERROR,
930  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
931  "and AVHWFramesContext.sw_format (%s)\n",
933  av_get_pix_fmt_name(frames_ctx->sw_format));
934  ret = AVERROR(EINVAL);
935  goto free_and_end;
936  }
937  avctx->sw_pix_fmt = frames_ctx->sw_format;
938  }
939  }
940 
943  avctx->pts_correction_last_pts =
944  avctx->pts_correction_last_dts = INT64_MIN;
945 
946  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
948  av_log(avctx, AV_LOG_WARNING,
949  "gray decoding requested but not enabled at configuration time\n");
950  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
952  }
953 
954  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
955  || avci->frame_thread_encoder)) {
956  ret = avctx->codec->init(avctx);
957  if (ret < 0) {
958  goto free_and_end;
959  }
960  codec_init_ok = 1;
961  }
962 
963  ret=0;
964 
965  if (av_codec_is_decoder(avctx->codec)) {
966  if (!avctx->bit_rate)
967  avctx->bit_rate = get_bit_rate(avctx);
968  /* validate channel layout from the decoder */
969  if (avctx->channel_layout) {
971  if (!avctx->channels)
972  avctx->channels = channels;
973  else if (channels != avctx->channels) {
974  char buf[512];
975  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
976  av_log(avctx, AV_LOG_WARNING,
977  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
978  "ignoring specified channel layout\n",
979  buf, channels, avctx->channels);
980  avctx->channel_layout = 0;
981  }
982  }
983  if (avctx->channels && avctx->channels < 0 ||
984  avctx->channels > FF_SANE_NB_CHANNELS) {
985  ret = AVERROR(EINVAL);
986  goto free_and_end;
987  }
988  if (avctx->bits_per_coded_sample < 0) {
989  ret = AVERROR(EINVAL);
990  goto free_and_end;
991  }
992  if (avctx->sub_charenc) {
993  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
994  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
995  "supported with subtitles codecs\n");
996  ret = AVERROR(EINVAL);
997  goto free_and_end;
998  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
999  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1000  "subtitles character encoding will be ignored\n",
1001  avctx->codec_descriptor->name);
1003  } else {
1004  /* input character encoding is set for a text based subtitle
1005  * codec at this point */
1008 
1010 #if CONFIG_ICONV
1011  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1012  if (cd == (iconv_t)-1) {
1013  ret = AVERROR(errno);
1014  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1015  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1016  goto free_and_end;
1017  }
1018  iconv_close(cd);
1019 #else
1020  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1021  "conversion needs a libavcodec built with iconv support "
1022  "for this codec\n");
1023  ret = AVERROR(ENOSYS);
1024  goto free_and_end;
1025 #endif
1026  }
1027  }
1028  }
1029 
1030 #if FF_API_AVCTX_TIMEBASE
1031  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1032  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1033 #endif
1034  }
1035  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1036  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1037  }
1038 
1039 end:
1040  ff_unlock_avcodec(codec);
1041  if (options) {
1042  av_dict_free(options);
1043  *options = tmp;
1044  }
1045 
1046  return ret;
1047 free_and_end:
1048  if (avctx->codec && avctx->codec->close &&
1049  (codec_init_ok ||
1051  avctx->codec->close(avctx);
1052 
1053  if (HAVE_THREADS && avci->thread_ctx)
1054  ff_thread_free(avctx);
1055 
1056  if (codec->priv_class && codec->priv_data_size)
1057  av_opt_free(avctx->priv_data);
1058  av_opt_free(avctx);
1059 
1060 #if FF_API_CODED_FRAME
1062  av_frame_free(&avctx->coded_frame);
1064 #endif
1065 
1066  av_dict_free(&tmp);
1067  av_freep(&avctx->priv_data);
1068  av_freep(&avctx->subtitle_header);
1069  if (avci) {
1070  av_frame_free(&avci->to_free);
1072  av_frame_free(&avci->buffer_frame);
1073  av_packet_free(&avci->buffer_pkt);
1075 
1076  av_packet_free(&avci->ds.in_pkt);
1077  ff_decode_bsfs_uninit(avctx);
1078 
1079  av_freep(&avci->pool);
1080  }
1081  av_freep(&avci);
1082  avctx->internal = NULL;
1083  avctx->codec = NULL;
1084  goto end;
1085 }
1086 
1088 {
1089  int i;
1090 
1091  for (i = 0; i < sub->num_rects; i++) {
1092  av_freep(&sub->rects[i]->data[0]);
1093  av_freep(&sub->rects[i]->data[1]);
1094  av_freep(&sub->rects[i]->data[2]);
1095  av_freep(&sub->rects[i]->data[3]);
1096  av_freep(&sub->rects[i]->text);
1097  av_freep(&sub->rects[i]->ass);
1098  av_freep(&sub->rects[i]);
1099  }
1100 
1101  av_freep(&sub->rects);
1102 
1103  memset(sub, 0, sizeof(*sub));
1104 }
1105 
1107 {
1108  int i;
1109 
1110  if (!avctx)
1111  return 0;
1112 
1113  if (avcodec_is_open(avctx)) {
1114  FramePool *pool = avctx->internal->pool;
1115  if (CONFIG_FRAME_THREAD_ENCODER &&
1116  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1118  }
1119  if (HAVE_THREADS && avctx->internal->thread_ctx)
1120  ff_thread_free(avctx);
1121  if (avctx->codec && avctx->codec->close)
1122  avctx->codec->close(avctx);
1123  avctx->internal->byte_buffer_size = 0;
1124  av_freep(&avctx->internal->byte_buffer);
1125  av_frame_free(&avctx->internal->to_free);
1130 
1131  av_packet_free(&avctx->internal->ds.in_pkt);
1132 
1133  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1134  av_buffer_pool_uninit(&pool->pools[i]);
1135  av_freep(&avctx->internal->pool);
1136 
1137  if (avctx->hwaccel && avctx->hwaccel->uninit)
1138  avctx->hwaccel->uninit(avctx);
1140 
1141  ff_decode_bsfs_uninit(avctx);
1142 
1143  av_freep(&avctx->internal);
1144  }
1145 
1146  for (i = 0; i < avctx->nb_coded_side_data; i++)
1147  av_freep(&avctx->coded_side_data[i].data);
1148  av_freep(&avctx->coded_side_data);
1149  avctx->nb_coded_side_data = 0;
1150 
1151  av_buffer_unref(&avctx->hw_frames_ctx);
1152  av_buffer_unref(&avctx->hw_device_ctx);
1153 
1154  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1155  av_opt_free(avctx->priv_data);
1156  av_opt_free(avctx);
1157  av_freep(&avctx->priv_data);
1158  if (av_codec_is_encoder(avctx->codec)) {
1159  av_freep(&avctx->extradata);
1160 #if FF_API_CODED_FRAME
1162  av_frame_free(&avctx->coded_frame);
1164 #endif
1165  }
1166  avctx->codec = NULL;
1167  avctx->active_thread_type = 0;
1168 
1169  return 0;
1170 }
1171 
1172 const char *avcodec_get_name(enum AVCodecID id)
1173 {
1174  const AVCodecDescriptor *cd;
1175  AVCodec *codec;
1176 
1177  if (id == AV_CODEC_ID_NONE)
1178  return "none";
1179  cd = avcodec_descriptor_get(id);
1180  if (cd)
1181  return cd->name;
1182  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1183  codec = avcodec_find_decoder(id);
1184  if (codec)
1185  return codec->name;
1186  codec = avcodec_find_encoder(id);
1187  if (codec)
1188  return codec->name;
1189  return "unknown_codec";
1190 }
1191 
1192 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1193 {
1194  int i, len, ret = 0;
1195 
1196 #define TAG_PRINT(x) \
1197  (((x) >= '0' && (x) <= '9') || \
1198  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
1199  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1200 
1201  for (i = 0; i < 4; i++) {
1202  len = snprintf(buf, buf_size,
1203  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1204  buf += len;
1205  buf_size = buf_size > len ? buf_size - len : 0;
1206  ret += len;
1207  codec_tag >>= 8;
1208  }
1209  return ret;
1210 }
1211 
1212 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1213 {
1214  const char *codec_type;
1215  const char *codec_name;
1216  const char *profile = NULL;
1217  int64_t bitrate;
1218  int new_line = 0;
1219  AVRational display_aspect_ratio;
1220  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1221 
1222  if (!buf || buf_size <= 0)
1223  return;
1224  codec_type = av_get_media_type_string(enc->codec_type);
1225  codec_name = avcodec_get_name(enc->codec_id);
1226  profile = avcodec_profile_name(enc->codec_id, enc->profile);
1227 
1228  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1229  codec_name);
1230  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1231 
1232  if (enc->codec && strcmp(enc->codec->name, codec_name))
1233  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1234 
1235  if (profile)
1236  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1237  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
1239  && enc->refs)
1240  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1241  ", %d reference frame%s",
1242  enc->refs, enc->refs > 1 ? "s" : "");
1243 
1244  if (enc->codec_tag)
1245  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1246  av_fourcc2str(enc->codec_tag), enc->codec_tag);
1247 
1248  switch (enc->codec_type) {
1249  case AVMEDIA_TYPE_VIDEO:
1250  {
1251  char detail[256] = "(";
1252 
1253  av_strlcat(buf, separator, buf_size);
1254 
1255  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1256  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1258  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1260  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1262  av_strlcatf(detail, sizeof(detail), "%s, ",
1264 
1265  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1267  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1268  if (enc->colorspace != (int)enc->color_primaries ||
1269  enc->colorspace != (int)enc->color_trc) {
1270  new_line = 1;
1271  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1275  } else
1276  av_strlcatf(detail, sizeof(detail), "%s, ",
1278  }
1279 
1280  if (enc->field_order != AV_FIELD_UNKNOWN) {
1281  const char *field_order = "progressive";
1282  if (enc->field_order == AV_FIELD_TT)
1283  field_order = "top first";
1284  else if (enc->field_order == AV_FIELD_BB)
1285  field_order = "bottom first";
1286  else if (enc->field_order == AV_FIELD_TB)
1287  field_order = "top coded first (swapped)";
1288  else if (enc->field_order == AV_FIELD_BT)
1289  field_order = "bottom coded first (swapped)";
1290 
1291  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1292  }
1293 
1294  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1296  av_strlcatf(detail, sizeof(detail), "%s, ",
1298 
1299  if (strlen(detail) > 1) {
1300  detail[strlen(detail) - 2] = 0;
1301  av_strlcatf(buf, buf_size, "%s)", detail);
1302  }
1303  }
1304 
1305  if (enc->width) {
1306  av_strlcat(buf, new_line ? separator : ", ", buf_size);
1307 
1308  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1309  "%dx%d",
1310  enc->width, enc->height);
1311 
1312  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1313  (enc->width != enc->coded_width ||
1314  enc->height != enc->coded_height))
1315  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1316  " (%dx%d)", enc->coded_width, enc->coded_height);
1317 
1318  if (enc->sample_aspect_ratio.num) {
1319  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1320  enc->width * (int64_t)enc->sample_aspect_ratio.num,
1321  enc->height * (int64_t)enc->sample_aspect_ratio.den,
1322  1024 * 1024);
1323  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1324  " [SAR %d:%d DAR %d:%d]",
1326  display_aspect_ratio.num, display_aspect_ratio.den);
1327  }
1328  if (av_log_get_level() >= AV_LOG_DEBUG) {
1329  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1330  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1331  ", %d/%d",
1332  enc->time_base.num / g, enc->time_base.den / g);
1333  }
1334  }
1335  if (encode) {
1336  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1337  ", q=%d-%d", enc->qmin, enc->qmax);
1338  } else {
1340  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1341  ", Closed Captions");
1343  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1344  ", lossless");
1345  }
1346  break;
1347  case AVMEDIA_TYPE_AUDIO:
1348  av_strlcat(buf, separator, buf_size);
1349 
1350  if (enc->sample_rate) {
1351  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1352  "%d Hz, ", enc->sample_rate);
1353  }
1354  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1355  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1356  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1357  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1358  }
1359  if ( enc->bits_per_raw_sample > 0
1361  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1362  " (%d bit)", enc->bits_per_raw_sample);
1363  if (av_log_get_level() >= AV_LOG_VERBOSE) {
1364  if (enc->initial_padding)
1365  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1366  ", delay %d", enc->initial_padding);
1367  if (enc->trailing_padding)
1368  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1369  ", padding %d", enc->trailing_padding);
1370  }
1371  break;
1372  case AVMEDIA_TYPE_DATA:
1373  if (av_log_get_level() >= AV_LOG_DEBUG) {
1374  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1375  if (g)
1376  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1377  ", %d/%d",
1378  enc->time_base.num / g, enc->time_base.den / g);
1379  }
1380  break;
1381  case AVMEDIA_TYPE_SUBTITLE:
1382  if (enc->width)
1383  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1384  ", %dx%d", enc->width, enc->height);
1385  break;
1386  default:
1387  return;
1388  }
1389  if (encode) {
1390  if (enc->flags & AV_CODEC_FLAG_PASS1)
1391  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1392  ", pass 1");
1393  if (enc->flags & AV_CODEC_FLAG_PASS2)
1394  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1395  ", pass 2");
1396  }
1397  bitrate = get_bit_rate(enc);
1398  if (bitrate != 0) {
1399  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1400  ", %"PRId64" kb/s", bitrate / 1000);
1401  } else if (enc->rc_max_rate > 0) {
1402  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1403  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
1404  }
1405 }
1406 
1407 const char *av_get_profile_name(const AVCodec *codec, int profile)
1408 {
1409  const AVProfile *p;
1410  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1411  return NULL;
1412 
1413  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1414  if (p->profile == profile)
1415  return p->name;
1416 
1417  return NULL;
1418 }
1419 
1421 {
1422  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
1423  const AVProfile *p;
1424 
1425  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1426  return NULL;
1427 
1428  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1429  if (p->profile == profile)
1430  return p->name;
1431 
1432  return NULL;
1433 }
1434 
1435 unsigned avcodec_version(void)
1436 {
1439  av_assert0(AV_CODEC_ID_SRT==94216);
1441 
1442  return LIBAVCODEC_VERSION_INT;
1443 }
1444 
1445 const char *avcodec_configuration(void)
1446 {
1447  return FFMPEG_CONFIGURATION;
1448 }
1449 
1450 const char *avcodec_license(void)
1451 {
1452 #define LICENSE_PREFIX "libavcodec license: "
1453  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
1454 }
1455 
1457 {
1458  switch (codec_id) {
1459  case AV_CODEC_ID_8SVX_EXP:
1460  case AV_CODEC_ID_8SVX_FIB:
1461  case AV_CODEC_ID_ADPCM_CT:
1469  return 4;
1470  case AV_CODEC_ID_DSD_LSBF:
1471  case AV_CODEC_ID_DSD_MSBF:
1474  case AV_CODEC_ID_PCM_ALAW:
1475  case AV_CODEC_ID_PCM_MULAW:
1476  case AV_CODEC_ID_PCM_VIDC:
1477  case AV_CODEC_ID_PCM_S8:
1479  case AV_CODEC_ID_PCM_U8:
1480  case AV_CODEC_ID_SDX2_DPCM:
1481  case AV_CODEC_ID_DERF_DPCM:
1482  return 8;
1483  case AV_CODEC_ID_PCM_S16BE:
1485  case AV_CODEC_ID_PCM_S16LE:
1487  case AV_CODEC_ID_PCM_U16BE:
1488  case AV_CODEC_ID_PCM_U16LE:
1489  return 16;
1491  case AV_CODEC_ID_PCM_S24BE:
1492  case AV_CODEC_ID_PCM_S24LE:
1494  case AV_CODEC_ID_PCM_U24BE:
1495  case AV_CODEC_ID_PCM_U24LE:
1496  return 24;
1497  case AV_CODEC_ID_PCM_S32BE:
1498  case AV_CODEC_ID_PCM_S32LE:
1500  case AV_CODEC_ID_PCM_U32BE:
1501  case AV_CODEC_ID_PCM_U32LE:
1502  case AV_CODEC_ID_PCM_F32BE:
1503  case AV_CODEC_ID_PCM_F32LE:
1504  case AV_CODEC_ID_PCM_F24LE:
1505  case AV_CODEC_ID_PCM_F16LE:
1506  return 32;
1507  case AV_CODEC_ID_PCM_F64BE:
1508  case AV_CODEC_ID_PCM_F64LE:
1509  case AV_CODEC_ID_PCM_S64BE:
1510  case AV_CODEC_ID_PCM_S64LE:
1511  return 64;
1512  default:
1513  return 0;
1514  }
1515 }
1516 
1518 {
1519  static const enum AVCodecID map[][2] = {
1525  [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
1526  [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
1527  [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
1529  [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
1530  [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
1531  };
1532  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
1533  return AV_CODEC_ID_NONE;
1534  if (be < 0 || be > 1)
1535  be = AV_NE(1, 0);
1536  return map[fmt][be];
1537 }
1538 
1540 {
1541  switch (codec_id) {
1543  return 2;
1545  return 3;
1549  case AV_CODEC_ID_ADPCM_SWF:
1550  case AV_CODEC_ID_ADPCM_MS:
1551  return 4;
1552  default:
1553  return av_get_exact_bits_per_sample(codec_id);
1554  }
1555 }
1556 
1557 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1558  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
1559  uint8_t * extradata, int frame_size, int frame_bytes)
1560 {
1562  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
1563 
1564  /* codecs with an exact constant bits per sample */
1565  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
1566  return (frame_bytes * 8LL) / (bps * ch);
1567  bps = bits_per_coded_sample;
1568 
1569  /* codecs with a fixed packet duration */
1570  switch (id) {
1571  case AV_CODEC_ID_ADPCM_ADX: return 32;
1572  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
1573  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
1574  case AV_CODEC_ID_AMR_NB:
1575  case AV_CODEC_ID_EVRC:
1576  case AV_CODEC_ID_GSM:
1577  case AV_CODEC_ID_QCELP:
1578  case AV_CODEC_ID_RA_288: return 160;
1579  case AV_CODEC_ID_AMR_WB:
1580  case AV_CODEC_ID_GSM_MS: return 320;
1581  case AV_CODEC_ID_MP1: return 384;
1582  case AV_CODEC_ID_ATRAC1: return 512;
1583  case AV_CODEC_ID_ATRAC9:
1584  case AV_CODEC_ID_ATRAC3: return 1024 * framecount;
1585  case AV_CODEC_ID_ATRAC3P: return 2048;
1586  case AV_CODEC_ID_MP2:
1587  case AV_CODEC_ID_MUSEPACK7: return 1152;
1588  case AV_CODEC_ID_AC3: return 1536;
1589  }
1590 
1591  if (sr > 0) {
1592  /* calc from sample rate */
1593  if (id == AV_CODEC_ID_TTA)
1594  return 256 * sr / 245;
1595  else if (id == AV_CODEC_ID_DST)
1596  return 588 * sr / 44100;
1597 
1598  if (ch > 0) {
1599  /* calc from sample rate and channels */
1600  if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1601  return (480 << (sr / 22050)) / ch;
1602  }
1603 
1604  if (id == AV_CODEC_ID_MP3)
1605  return sr <= 24000 ? 576 : 1152;
1606  }
1607 
1608  if (ba > 0) {
1609  /* calc from block_align */
1610  if (id == AV_CODEC_ID_SIPR) {
1611  switch (ba) {
1612  case 20: return 160;
1613  case 19: return 144;
1614  case 29: return 288;
1615  case 37: return 480;
1616  }
1617  } else if (id == AV_CODEC_ID_ILBC) {
1618  switch (ba) {
1619  case 38: return 160;
1620  case 50: return 240;
1621  }
1622  }
1623  }
1624 
1625  if (frame_bytes > 0) {
1626  /* calc from frame_bytes only */
1627  if (id == AV_CODEC_ID_TRUESPEECH)
1628  return 240 * (frame_bytes / 32);
1629  if (id == AV_CODEC_ID_NELLYMOSER)
1630  return 256 * (frame_bytes / 64);
1631  if (id == AV_CODEC_ID_RA_144)
1632  return 160 * (frame_bytes / 20);
1633 
1634  if (bps > 0) {
1635  /* calc from frame_bytes and bits_per_coded_sample */
1637  return frame_bytes * 8 / bps;
1638  }
1639 
1640  if (ch > 0 && ch < INT_MAX/16) {
1641  /* calc from frame_bytes and channels */
1642  switch (id) {
1643  case AV_CODEC_ID_ADPCM_AFC:
1644  return frame_bytes / (9 * ch) * 16;
1645  case AV_CODEC_ID_ADPCM_PSX:
1646  case AV_CODEC_ID_ADPCM_DTK:
1647  return frame_bytes / (16 * ch) * 28;
1648  case AV_CODEC_ID_ADPCM_4XM:
1651  return (frame_bytes - 4 * ch) * 2 / ch;
1653  return (frame_bytes - 4) * 2 / ch;
1655  return (frame_bytes - 8) * 2 / ch;
1656  case AV_CODEC_ID_ADPCM_THP:
1658  if (extradata)
1659  return frame_bytes * 14 / (8 * ch);
1660  break;
1661  case AV_CODEC_ID_ADPCM_XA:
1662  return (frame_bytes / 128) * 224 / ch;
1664  return (frame_bytes - 6 - ch) / ch;
1665  case AV_CODEC_ID_ROQ_DPCM:
1666  return (frame_bytes - 8) / ch;
1667  case AV_CODEC_ID_XAN_DPCM:
1668  return (frame_bytes - 2 * ch) / ch;
1669  case AV_CODEC_ID_MACE3:
1670  return 3 * frame_bytes / ch;
1671  case AV_CODEC_ID_MACE6:
1672  return 6 * frame_bytes / ch;
1673  case AV_CODEC_ID_PCM_LXF:
1674  return 2 * (frame_bytes / (5 * ch));
1675  case AV_CODEC_ID_IAC:
1676  case AV_CODEC_ID_IMC:
1677  return 4 * frame_bytes / ch;
1678  }
1679 
1680  if (tag) {
1681  /* calc from frame_bytes, channels, and codec_tag */
1682  if (id == AV_CODEC_ID_SOL_DPCM) {
1683  if (tag == 3)
1684  return frame_bytes / ch;
1685  else
1686  return frame_bytes * 2 / ch;
1687  }
1688  }
1689 
1690  if (ba > 0) {
1691  /* calc from frame_bytes, channels, and block_align */
1692  int blocks = frame_bytes / ba;
1693  switch (id) {
1695  if (bps < 2 || bps > 5)
1696  return 0;
1697  return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
1699  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1701  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1703  return blocks * ((ba - 4 * ch) * 2 / ch);
1704  case AV_CODEC_ID_ADPCM_MS:
1705  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1707  return blocks * (ba - 16) * 2 / ch;
1708  }
1709  }
1710 
1711  if (bps > 0) {
1712  /* calc from frame_bytes, channels, and bits_per_coded_sample */
1713  switch (id) {
1714  case AV_CODEC_ID_PCM_DVD:
1715  if(bps<4 || frame_bytes<3)
1716  return 0;
1717  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
1719  if(bps<4 || frame_bytes<4)
1720  return 0;
1721  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
1722  case AV_CODEC_ID_S302M:
1723  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1724  }
1725  }
1726  }
1727  }
1728 
1729  /* Fall back on using frame_size */
1730  if (frame_size > 1 && frame_bytes)
1731  return frame_size;
1732 
1733  //For WMA we currently have no other means to calculate duration thus we
1734  //do it here by assuming CBR, which is true for all known cases.
1735  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
1736  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
1737  return (frame_bytes * 8LL * sr) / bitrate;
1738  }
1739 
1740  return 0;
1741 }
1742 
1743 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1744 {
1745  return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1746  avctx->channels, avctx->block_align,
1747  avctx->codec_tag, avctx->bits_per_coded_sample,
1748  avctx->bit_rate, avctx->extradata, avctx->frame_size,
1749  frame_bytes);
1750 }
1751 
1753 {
1754  return get_audio_frame_duration(par->codec_id, par->sample_rate,
1755  par->channels, par->block_align,
1756  par->codec_tag, par->bits_per_coded_sample,
1757  par->bit_rate, par->extradata, par->frame_size,
1758  frame_bytes);
1759 }
1760 
1761 #if !HAVE_THREADS
1763 {
1764  return -1;
1765 }
1766 
1767 #endif
1768 
1769 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1770 {
1771  unsigned int n = 0;
1772 
1773  while (v >= 0xff) {
1774  *s++ = 0xff;
1775  v -= 0xff;
1776  n++;
1777  }
1778  *s = v;
1779  n++;
1780  return n;
1781 }
1782 
1783 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1784 {
1785  int i;
1786  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1787  return i;
1788 }
1789 
1791 {
1792  int i;
1793  if (!codec->hw_configs || index < 0)
1794  return NULL;
1795  for (i = 0; i <= index; i++)
1796  if (!codec->hw_configs[i])
1797  return NULL;
1798  return &codec->hw_configs[index]->public;
1799 }
1800 
1801 #if FF_API_USER_VISIBLE_AVHWACCEL
1803 {
1804  return NULL;
1805 }
1806 
1808 {
1809 }
1810 #endif
1811 
1812 #if FF_API_LOCKMGR
1813 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1814 {
1815  return 0;
1816 }
1817 #endif
1818 
1819 unsigned int avpriv_toupper4(unsigned int x)
1820 {
1821  return av_toupper(x & 0xFF) +
1822  (av_toupper((x >> 8) & 0xFF) << 8) +
1823  (av_toupper((x >> 16) & 0xFF) << 16) +
1824 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
1825 }
1826 
1828 {
1829  int ret;
1830 
1831  dst->owner[0] = src->owner[0];
1832  dst->owner[1] = src->owner[1];
1833 
1834  ret = av_frame_ref(dst->f, src->f);
1835  if (ret < 0)
1836  return ret;
1837 
1838  av_assert0(!dst->progress);
1839 
1840  if (src->progress &&
1841  !(dst->progress = av_buffer_ref(src->progress))) {
1842  ff_thread_release_buffer(dst->owner[0], dst);
1843  return AVERROR(ENOMEM);
1844  }
1845 
1846  return 0;
1847 }
1848 
1849 #if !HAVE_THREADS
1850 
1852 {
1853  return ff_get_format(avctx, fmt);
1854 }
1855 
1857 {
1858  f->owner[0] = f->owner[1] = avctx;
1859  return ff_get_buffer(avctx, f->f, flags);
1860 }
1861 
1863 {
1864  if (f->f)
1865  av_frame_unref(f->f);
1866 }
1867 
1869 {
1870 }
1871 
1873 {
1874 }
1875 
1876 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1877 {
1878 }
1879 
1881 {
1882  return 1;
1883 }
1884 
1886 {
1887  return 0;
1888 }
1889 
1891 {
1892 }
1893 
1894 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1895 {
1896 }
1897 
1898 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1899 {
1900 }
1901 
1902 #endif
1903 
1905 {
1906  return !!s->internal;
1907 }
1908 
1909 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
1910 {
1911  int ret;
1912  char *str;
1913 
1914  ret = av_bprint_finalize(buf, &str);
1915  if (ret < 0)
1916  return ret;
1917  if (!av_bprint_is_complete(buf)) {
1918  av_free(str);
1919  return AVERROR(ENOMEM);
1920  }
1921 
1922  avctx->extradata = str;
1923  /* Note: the string is NUL terminated (so extradata can be read as a
1924  * string), but the ending character is not accounted in the size (in
1925  * binary formats you are likely not supposed to mux that character). When
1926  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
1927  * zeros. */
1928  avctx->extradata_size = buf->len;
1929  return 0;
1930 }
1931 
1932 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
1933  const uint8_t *end,
1934  uint32_t *av_restrict state)
1935 {
1936  int i;
1937 
1938  av_assert0(p <= end);
1939  if (p >= end)
1940  return end;
1941 
1942  for (i = 0; i < 3; i++) {
1943  uint32_t tmp = *state << 8;
1944  *state = tmp + *(p++);
1945  if (tmp == 0x100 || p == end)
1946  return p;
1947  }
1948 
1949  while (p < end) {
1950  if (p[-1] > 1 ) p += 3;
1951  else if (p[-2] ) p += 2;
1952  else if (p[-3]|(p[-1]-1)) p++;
1953  else {
1954  p++;
1955  break;
1956  }
1957  }
1958 
1959  p = FFMIN(p, end) - 4;
1960  *state = AV_RB32(p);
1961 
1962  return p + 4;
1963 }
1964 
1966 {
1967  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1968  if (!props)
1969  return NULL;
1970 
1971  if (size)
1972  *size = sizeof(*props);
1973 
1974  props->vbv_delay = UINT64_MAX;
1975 
1976  return props;
1977 }
1978 
1980 {
1982  AVCPBProperties *props;
1983  size_t size;
1984  int i;
1985 
1986  for (i = 0; i < avctx->nb_coded_side_data; i++)
1988  return (AVCPBProperties *)avctx->coded_side_data[i].data;
1989 
1990  props = av_cpb_properties_alloc(&size);
1991  if (!props)
1992  return NULL;
1993 
1994  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
1995  if (!tmp) {
1996  av_freep(&props);
1997  return NULL;
1998  }
1999 
2000  avctx->coded_side_data = tmp;
2001  avctx->nb_coded_side_data++;
2002 
2004  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
2005  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
2006 
2007  return props;
2008 }
2009 
2011 {
2012  av_freep(&par->extradata);
2013 
2014  memset(par, 0, sizeof(*par));
2015 
2017  par->codec_id = AV_CODEC_ID_NONE;
2018  par->format = -1;
2025  par->sample_aspect_ratio = (AVRational){ 0, 1 };
2026  par->profile = FF_PROFILE_UNKNOWN;
2027  par->level = FF_LEVEL_UNKNOWN;
2028 }
2029 
2031 {
2032  AVCodecParameters *par = av_mallocz(sizeof(*par));
2033 
2034  if (!par)
2035  return NULL;
2037  return par;
2038 }
2039 
2041 {
2042  AVCodecParameters *par = *ppar;
2043 
2044  if (!par)
2045  return;
2047 
2048  av_freep(ppar);
2049 }
2050 
2052 {
2054  memcpy(dst, src, sizeof(*dst));
2055 
2056  dst->extradata = NULL;
2057  dst->extradata_size = 0;
2058  if (src->extradata) {
2060  if (!dst->extradata)
2061  return AVERROR(ENOMEM);
2062  memcpy(dst->extradata, src->extradata, src->extradata_size);
2063  dst->extradata_size = src->extradata_size;
2064  }
2065 
2066  return 0;
2067 }
2068 
2070  const AVCodecContext *codec)
2071 {
2073 
2074  par->codec_type = codec->codec_type;
2075  par->codec_id = codec->codec_id;
2076  par->codec_tag = codec->codec_tag;
2077 
2078  par->bit_rate = codec->bit_rate;
2081  par->profile = codec->profile;
2082  par->level = codec->level;
2083 
2084  switch (par->codec_type) {
2085  case AVMEDIA_TYPE_VIDEO:
2086  par->format = codec->pix_fmt;
2087  par->width = codec->width;
2088  par->height = codec->height;
2089  par->field_order = codec->field_order;
2090  par->color_range = codec->color_range;
2091  par->color_primaries = codec->color_primaries;
2092  par->color_trc = codec->color_trc;
2093  par->color_space = codec->colorspace;
2096  par->video_delay = codec->has_b_frames;
2097  break;
2098  case AVMEDIA_TYPE_AUDIO:
2099  par->format = codec->sample_fmt;
2100  par->channel_layout = codec->channel_layout;
2101  par->channels = codec->channels;
2102  par->sample_rate = codec->sample_rate;
2103  par->block_align = codec->block_align;
2104  par->frame_size = codec->frame_size;
2105  par->initial_padding = codec->initial_padding;
2106  par->trailing_padding = codec->trailing_padding;
2107  par->seek_preroll = codec->seek_preroll;
2108  break;
2109  case AVMEDIA_TYPE_SUBTITLE:
2110  par->width = codec->width;
2111  par->height = codec->height;
2112  break;
2113  }
2114 
2115  if (codec->extradata) {
2117  if (!par->extradata)
2118  return AVERROR(ENOMEM);
2119  memcpy(par->extradata, codec->extradata, codec->extradata_size);
2120  par->extradata_size = codec->extradata_size;
2121  }
2122 
2123  return 0;
2124 }
2125 
2127  const AVCodecParameters *par)
2128 {
2129  codec->codec_type = par->codec_type;
2130  codec->codec_id = par->codec_id;
2131  codec->codec_tag = par->codec_tag;
2132 
2133  codec->bit_rate = par->bit_rate;
2136  codec->profile = par->profile;
2137  codec->level = par->level;
2138 
2139  switch (par->codec_type) {
2140  case AVMEDIA_TYPE_VIDEO:
2141  codec->pix_fmt = par->format;
2142  codec->width = par->width;
2143  codec->height = par->height;
2144  codec->field_order = par->field_order;
2145  codec->color_range = par->color_range;
2146  codec->color_primaries = par->color_primaries;
2147  codec->color_trc = par->color_trc;
2148  codec->colorspace = par->color_space;
2151  codec->has_b_frames = par->video_delay;
2152  break;
2153  case AVMEDIA_TYPE_AUDIO:
2154  codec->sample_fmt = par->format;
2155  codec->channel_layout = par->channel_layout;
2156  codec->channels = par->channels;
2157  codec->sample_rate = par->sample_rate;
2158  codec->block_align = par->block_align;
2159  codec->frame_size = par->frame_size;
2160  codec->delay =
2161  codec->initial_padding = par->initial_padding;
2162  codec->trailing_padding = par->trailing_padding;
2163  codec->seek_preroll = par->seek_preroll;
2164  break;
2165  case AVMEDIA_TYPE_SUBTITLE:
2166  codec->width = par->width;
2167  codec->height = par->height;
2168  break;
2169  }
2170 
2171  if (par->extradata) {
2172  av_freep(&codec->extradata);
2174  if (!codec->extradata)
2175  return AVERROR(ENOMEM);
2176  memcpy(codec->extradata, par->extradata, par->extradata_size);
2177  codec->extradata_size = par->extradata_size;
2178  }
2179 
2180  return 0;
2181 }
2182 
2183 int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
2184  void **data, size_t *sei_size)
2185 {
2186  AVFrameSideData *side_data = NULL;
2187  uint8_t *sei_data;
2188 
2189  if (frame)
2190  side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC);
2191 
2192  if (!side_data) {
2193  *data = NULL;
2194  return 0;
2195  }
2196 
2197  *sei_size = side_data->size + 11;
2198  *data = av_mallocz(*sei_size + prefix_len);
2199  if (!*data)
2200  return AVERROR(ENOMEM);
2201  sei_data = (uint8_t*)*data + prefix_len;
2202 
2203  // country code
2204  sei_data[0] = 181;
2205  sei_data[1] = 0;
2206  sei_data[2] = 49;
2207 
2208  /**
2209  * 'GA94' is standard in North America for ATSC, but hard coding
2210  * this style may not be the right thing to do -- other formats
2211  * do exist. This information is not available in the side_data
2212  * so we are going with this right now.
2213  */
2214  AV_WL32(sei_data + 3, MKTAG('G', 'A', '9', '4'));
2215  sei_data[7] = 3;
2216  sei_data[8] = ((side_data->size/3) & 0x1f) | 0x40;
2217  sei_data[9] = 0;
2218 
2219  memcpy(sei_data + 10, side_data->data, side_data->size);
2220 
2221  sei_data[side_data->size+10] = 255;
2222 
2223  return 0;
2224 }
2225 
2227 {
2228  AVRational framerate = avctx->framerate;
2229  int bits_per_coded_sample = avctx->bits_per_coded_sample;
2230  int64_t bitrate;
2231 
2232  if (!(framerate.num && framerate.den))
2233  framerate = av_inv_q(avctx->time_base);
2234  if (!(framerate.num && framerate.den))
2235  return 0;
2236 
2237  if (!bits_per_coded_sample) {
2239  bits_per_coded_sample = av_get_bits_per_pixel(desc);
2240  }
2241  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
2242  framerate.num / framerate.den;
2243 
2244  return bitrate;
2245 }
2246 
2247 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
2248  const int * array_valid_values, int default_value)
2249 {
2250  int i = 0, ref_val;
2251 
2252  while (1) {
2253  ref_val = array_valid_values[i];
2254  if (ref_val == INT_MAX)
2255  break;
2256  if (val == ref_val)
2257  return val;
2258  i++;
2259  }
2260  /* val is not a valid value */
2261  av_log(ctx, AV_LOG_DEBUG,
2262  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
2263  return default_value;
2264 }
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:2226
#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:92
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2689
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:4126
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:3219
#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:1370
const struct AVCodec * codec
Definition: avcodec.h:1630
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:3161
const char const char void * val
Definition: avisynth_c.h:863
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:4117
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: utils.c:500
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:3182
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:4124
#define AV_NUM_DATA_POINTERS
Definition: frame.h:296
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:3218
static AVMutex mutex
Definition: log.c:44
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:3199
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:126
unsigned int fourcc
Definition: raw.h:36
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:903
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:3696
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1809
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:178
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:1671
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:165
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:2501
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:4112
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2527
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:250
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1359
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: utils.c:1445
uint32_t fourcc
Definition: vaapi_decode.c:239
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2256
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:4036
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:168
#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:3217
static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
Definition: utils.c:524
const char * avcodec_license(void)
Return the libavcodec license.
Definition: utils.c:1450
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:2000
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:1831
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:209
unsigned num_rects
Definition: avcodec.h:4016
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:496
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:1047
mpegvideo header.
enum AVMediaType type
Definition: avcodec.h:3568
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:111
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2852
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: utils.c:1851
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:1813
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:1067
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2785
int trailing_padding
Audio only.
Definition: avcodec.h:4172
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2954
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AVCodec.
Definition: avcodec.h:3555
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:2318
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:4028
AVLockOp
Lock operation used by lockmgr.
Definition: avcodec.h:6211
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:4000
enum AVColorSpace color_space
Definition: avcodec.h:4125
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2942
Macro definitions for various function/variable attributes.
void ff_decode_bsfs_uninit(AVCodecContext *avctx)
Definition: decode.c:2060
int frame_size
Audio only.
Definition: avcodec.h:4157
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:1744
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:739
AVSubtitleRect ** rects
Definition: avcodec.h:4017
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:99
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:3866
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:1894
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:1200
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:3075
#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:215
#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
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
Definition: avcodec.h:3446
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:2289
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:190
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4102
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:1118
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:2030
#define f(width, name)
Definition: cbs_vp9.c:255
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2875
void * thread_ctx
Definition: internal.h:169
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:3340
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:444
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:3284
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1722
#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:2126
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:1979
Public header for CRC hash function implementation.
void * frame_thread_encoder
Definition: internal.h:186
int initial_padding
Audio only.
Definition: avcodec.h:4165
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:536
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:1533
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
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:426
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
uint8_t * data
Definition: avcodec.h:1477
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:1557
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2860
int av_codec_get_max_lowres(const AVCodec *codec)
Definition: utils.c:490
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:1783
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:2845
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:901
channels
Definition: aptx.h:33
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:1965
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2263
static void codec_parameters_reset(AVCodecParameters *par)
Definition: utils.c:2010
#define FFALIGN(x, a)
Definition: macros.h:48
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4138
#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:167
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:4065
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2688
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:1807
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:1106
enum AVCodecID id
Definition: avcodec.h:3569
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: avcodec.h:3579
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:2966
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:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:217
unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
Definition: utils.c:485
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2051
int width
Definition: frame.h:353
#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:1911
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1539
#define AVMutex
Definition: thread.h:164
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:2247
#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:1819
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int(* send_frame)(AVCodecContext *avctx, const AVFrame *frame)
Encode API with decoupled packet/frame dataflow.
Definition: avcodec.h:3663
int qmax
maximum quantizer
Definition: avcodec.h:2470
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:3200
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2899
enum AVColorPrimaries color_primaries
Definition: avcodec.h:4123
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1904
int video_delay
Video only.
Definition: avcodec.h:4131
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:449
AVFrame * buffer_frame
Definition: internal.h:208
int capabilities
Codec capabilities.
Definition: avcodec.h:3574
int initial_padding
Audio only.
Definition: avcodec.h:3152
unsigned int pos
Definition: spdifenc.c:410
#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:1762
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:578
#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:4032
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:1701
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:1479
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
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:3348
const struct AVProfile * profiles
If non-NULL, an array of profiles recognized for this codec.
Definition: avcodec.h:761
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:2040
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:1752
const char av_codec_ffversion[]
Definition: utils.c:66
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2894
reference-counted frame API
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3364
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2332
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4054
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:2484
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:750
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:259
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
int refs
number of reference frames
Definition: avcodec.h:2209
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:287
int block_align
Audio only.
Definition: avcodec.h:4153
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:165
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:3576
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2891
#define FFMIN(a, b)
Definition: common.h:96
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:3293
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:1456
AVFrame * compat_decode_frame
Definition: internal.h:219
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1898
int width
picture width / height.
Definition: avcodec.h:1794
static void ff_unlock_avcodec(const AVCodec *codec)
Definition: utils.c:530
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3318
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2955
int priv_data_size
Definition: avcodec.h:3603
int profile
Definition: avcodec.h:3489
AVPacket * in_pkt
Definition: internal.h:126
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:889
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2235
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:3074
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:1868
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:3582
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:1753
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 AVCodecID codec_id
Definition: vaapi_decode.c:369
enum AVColorRange color_range
Video only.
Definition: avcodec.h:4122
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:123
DecodeSimpleContext ds
Definition: internal.h:171
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:467
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:3208
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:3995
#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:1172
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2880
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:3216
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:368
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:1407
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2301
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1158
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:2140
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:1802
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:1629
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:1517
enum AVCodecID codec_id
Definition: avcodec.h:1631
int seek_preroll
Number of samples to skip after a discontinuity.
Definition: avcodec.h:3241
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1657
int sample_rate
samples per second
Definition: avcodec.h:2281
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
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
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&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
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1790
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
main external API structure.
Definition: avcodec.h:1621
int(* receive_frame)(AVCodecContext *avctx, AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: avcodec.h:3671
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:908
int skip_samples_multiplier
Definition: internal.h:223
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:2463
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1087
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:1646
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:1969
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:793
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:1723
int(* close)(AVCodecContext *)
Definition: avcodec.h:3654
static struct @327 state
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1769
int nb_coded_side_data
Definition: avcodec.h:3294
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:1809
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:3285
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:727
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:276
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:2249
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2242
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:1862
const char * name
short name for the profile
Definition: avcodec.h:3490
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:2069
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
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:3276
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:103
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:742
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:548
#define snprintf
Definition: snprintf.h:34
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1743
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
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&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
mfxU16 profile
Definition: qsvenc.c:44
int seek_preroll
Audio only.
Definition: avcodec.h:4176
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:734
int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:1909
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
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:564
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: avcodec.h:4091
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:3581
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
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:4146
enum AVMediaType type
Definition: avcodec.h:736
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: avcodec.h:3580
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:206
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:1612
const OptionDef options[]
Definition: ffmpeg_opt.c:3439
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
Definition: avcodec.h:3653
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:3638
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: avcodec.h:4096
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2918
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:196
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:3639
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:94
AVProfile.
Definition: avcodec.h:3488
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:1880
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2871
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:1872
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:385
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:3681
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3283
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:454
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:1534
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:808
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1212
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:893
static int lowres
Definition: ffplay.c:335
void * priv_data
Definition: avcodec.h:1648
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:1192
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:3268
#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:3651
#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:595
int len
int channels
number of audio channels
Definition: avcodec.h:2282
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: avcodec.h:3577
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1656
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: utils.c:1435
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:4007
This side data corresponds to the AVCPBProperties struct.
Definition: avcodec.h:1332
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:562
signed 64 bits, planar
Definition: samplefmt.h:72
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1708
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4078
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4050
static const struct twinvq_data tab
unsigned int byte_buffer_size
Definition: internal.h:184
int channels
Audio only.
Definition: avcodec.h:4142
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: utils.c:1876
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
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:973
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:3201
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2312
int height
Definition: frame.h:353
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:3198
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:2278
signed 16 bits, planar
Definition: samplefmt.h:67
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:554
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1827
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:3578
AVMatrixEncoding
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: utils.c:1856
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:4040
int ff_alloc_entries(AVCodecContext *avctx, int count)
Definition: utils.c:1885
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:2183
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:2465
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:1932
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:1890
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:342
#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:3370
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:222
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:183
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1420
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:1777
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#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:2684
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:3168
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
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: utils.c:441
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2499
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:3106
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