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 "hwconfig.h"
48 #include "libavutil/opt.h"
49 #include "mpegvideo.h"
50 #include "thread.h"
51 #include "frame_thread_encoder.h"
52 #include "internal.h"
53 #include "packet_internal.h"
54 #include "put_bits.h"
55 #include "raw.h"
56 #include "bytestream.h"
57 #include "version.h"
58 #include <stdlib.h>
59 #include <stdarg.h>
60 #include <stdatomic.h>
61 #include <limits.h>
62 #include <float.h>
63 #if CONFIG_ICONV
64 # include <iconv.h>
65 #endif
66 
67 #include "libavutil/ffversion.h"
68 const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
69 
71 
72 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
73 {
74  uint8_t **p = ptr;
75  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
76  av_freep(p);
77  *size = 0;
78  return;
79  }
80  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
81  memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
82 }
83 
84 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
85 {
86  uint8_t **p = ptr;
87  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
88  av_freep(p);
89  *size = 0;
90  return;
91  }
92  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
93  memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
94 }
95 
96 int av_codec_is_encoder(const AVCodec *codec)
97 {
98  return codec && (codec->encode_sub || codec->encode2 || codec->receive_packet);
99 }
100 
101 int av_codec_is_decoder(const AVCodec *codec)
102 {
103  return codec && (codec->decode || codec->receive_frame);
104 }
105 
107 {
108  int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
109 
110  if (ret < 0)
111  width = height = 0;
112 
113  s->coded_width = width;
114  s->coded_height = height;
115  s->width = AV_CEIL_RSHIFT(width, s->lowres);
116  s->height = AV_CEIL_RSHIFT(height, s->lowres);
117 
118  return ret;
119 }
120 
122 {
123  int ret = av_image_check_sar(avctx->width, avctx->height, sar);
124 
125  if (ret < 0) {
126  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
127  sar.num, sar.den);
128  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
129  return ret;
130  } else {
131  avctx->sample_aspect_ratio = sar;
132  }
133  return 0;
134 }
135 
137  enum AVMatrixEncoding matrix_encoding)
138 {
139  AVFrameSideData *side_data;
140  enum AVMatrixEncoding *data;
141 
143  if (!side_data)
145  sizeof(enum AVMatrixEncoding));
146 
147  if (!side_data)
148  return AVERROR(ENOMEM);
149 
150  data = (enum AVMatrixEncoding*)side_data->data;
151  *data = matrix_encoding;
152 
153  return 0;
154 }
155 
157  int linesize_align[AV_NUM_DATA_POINTERS])
158 {
159  int i;
160  int w_align = 1;
161  int h_align = 1;
163 
164  if (desc) {
165  w_align = 1 << desc->log2_chroma_w;
166  h_align = 1 << desc->log2_chroma_h;
167  }
168 
169  switch (s->pix_fmt) {
170  case AV_PIX_FMT_YUV420P:
171  case AV_PIX_FMT_YUYV422:
172  case AV_PIX_FMT_YVYU422:
173  case AV_PIX_FMT_UYVY422:
174  case AV_PIX_FMT_YUV422P:
175  case AV_PIX_FMT_YUV440P:
176  case AV_PIX_FMT_YUV444P:
177  case AV_PIX_FMT_GBRP:
178  case AV_PIX_FMT_GBRAP:
179  case AV_PIX_FMT_GRAY8:
180  case AV_PIX_FMT_GRAY16BE:
181  case AV_PIX_FMT_GRAY16LE:
182  case AV_PIX_FMT_YUVJ420P:
183  case AV_PIX_FMT_YUVJ422P:
184  case AV_PIX_FMT_YUVJ440P:
185  case AV_PIX_FMT_YUVJ444P:
186  case AV_PIX_FMT_YUVA420P:
187  case AV_PIX_FMT_YUVA422P:
188  case AV_PIX_FMT_YUVA444P:
245  case AV_PIX_FMT_GBRP9LE:
246  case AV_PIX_FMT_GBRP9BE:
247  case AV_PIX_FMT_GBRP10LE:
248  case AV_PIX_FMT_GBRP10BE:
249  case AV_PIX_FMT_GBRP12LE:
250  case AV_PIX_FMT_GBRP12BE:
251  case AV_PIX_FMT_GBRP14LE:
252  case AV_PIX_FMT_GBRP14BE:
253  case AV_PIX_FMT_GBRP16LE:
254  case AV_PIX_FMT_GBRP16BE:
259  w_align = 16; //FIXME assume 16 pixel per macroblock
260  h_align = 16 * 2; // interlaced needs 2 macroblocks height
261  break;
262  case AV_PIX_FMT_YUV411P:
263  case AV_PIX_FMT_YUVJ411P:
265  w_align = 32;
266  h_align = 16 * 2;
267  break;
268  case AV_PIX_FMT_YUV410P:
269  if (s->codec_id == AV_CODEC_ID_SVQ1) {
270  w_align = 64;
271  h_align = 64;
272  }
273  break;
274  case AV_PIX_FMT_RGB555:
275  if (s->codec_id == AV_CODEC_ID_RPZA) {
276  w_align = 4;
277  h_align = 4;
278  }
280  w_align = 8;
281  h_align = 8;
282  }
283  break;
284  case AV_PIX_FMT_PAL8:
285  case AV_PIX_FMT_BGR8:
286  case AV_PIX_FMT_RGB8:
287  if (s->codec_id == AV_CODEC_ID_SMC ||
289  w_align = 4;
290  h_align = 4;
291  }
292  if (s->codec_id == AV_CODEC_ID_JV ||
294  w_align = 8;
295  h_align = 8;
296  }
297  break;
298  case AV_PIX_FMT_BGR24:
299  if ((s->codec_id == AV_CODEC_ID_MSZH) ||
300  (s->codec_id == AV_CODEC_ID_ZLIB)) {
301  w_align = 4;
302  h_align = 4;
303  }
304  break;
305  case AV_PIX_FMT_RGB24:
306  if (s->codec_id == AV_CODEC_ID_CINEPAK) {
307  w_align = 4;
308  h_align = 4;
309  }
310  break;
311  default:
312  break;
313  }
314 
315  if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
316  w_align = FFMAX(w_align, 8);
317  }
318 
319  *width = FFALIGN(*width, w_align);
320  *height = FFALIGN(*height, h_align);
321  if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
324  ) {
325  // some of the optimized chroma MC reads one line too much
326  // which is also done in mpeg decoders with lowres > 0
327  *height += 2;
328 
329  // H.264 uses edge emulation for out of frame motion vectors, for this
330  // it requires a temporary area large enough to hold a 21x21 block,
331  // increasing witdth ensure that the temporary area is large enough,
332  // the next rounded up width is 32
333  *width = FFMAX(*width, 32);
334  }
335 
336  for (i = 0; i < 4; i++)
337  linesize_align[i] = STRIDE_ALIGN;
338 }
339 
341 {
343  int chroma_shift = desc->log2_chroma_w;
344  int linesize_align[AV_NUM_DATA_POINTERS];
345  int align;
346 
347  avcodec_align_dimensions2(s, width, height, linesize_align);
348  align = FFMAX(linesize_align[0], linesize_align[3]);
349  linesize_align[1] <<= chroma_shift;
350  linesize_align[2] <<= chroma_shift;
351  align = FFMAX3(align, linesize_align[1], linesize_align[2]);
352  *width = FFALIGN(*width, align);
353 }
354 
355 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
356 {
357  if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
358  return AVERROR(EINVAL);
359  pos--;
360 
361  *xpos = (pos&1) * 128;
362  *ypos = ((pos>>1)^(pos<4)) * 128;
363 
364  return 0;
365 }
366 
368 {
369  int pos, xout, yout;
370 
371  for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
372  if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
373  return pos;
374  }
376 }
377 
379  enum AVSampleFormat sample_fmt, const uint8_t *buf,
380  int buf_size, int align)
381 {
382  int ch, planar, needed_size, ret = 0;
383 
384  needed_size = av_samples_get_buffer_size(NULL, nb_channels,
385  frame->nb_samples, sample_fmt,
386  align);
387  if (buf_size < needed_size)
388  return AVERROR(EINVAL);
389 
390  planar = av_sample_fmt_is_planar(sample_fmt);
391  if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
392  if (!(frame->extended_data = av_mallocz_array(nb_channels,
393  sizeof(*frame->extended_data))))
394  return AVERROR(ENOMEM);
395  } else {
396  frame->extended_data = frame->data;
397  }
398 
399  if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
400  (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
401  sample_fmt, align)) < 0) {
402  if (frame->extended_data != frame->data)
403  av_freep(&frame->extended_data);
404  return ret;
405  }
406  if (frame->extended_data != frame->data) {
407  for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
408  frame->data[ch] = frame->extended_data[ch];
409  }
410 
411  return ret;
412 }
413 
414 void ff_color_frame(AVFrame *frame, const int c[4])
415 {
417  int p, y;
418 
420 
421  for (p = 0; p<desc->nb_components; p++) {
422  uint8_t *dst = frame->data[p];
423  int is_chroma = p == 1 || p == 2;
424  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
425  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
426  if (desc->comp[0].depth >= 9) {
427  ((uint16_t*)dst)[0] = c[p];
428  av_memcpy_backptr(dst + 2, 2, bytes - 2);
429  dst += frame->linesize[p];
430  for (y = 1; y < height; y++) {
431  memcpy(dst, frame->data[p], 2*bytes);
432  dst += frame->linesize[p];
433  }
434  } else {
435  for (y = 0; y < height; y++) {
436  memset(dst, c[p], bytes);
437  dst += frame->linesize[p];
438  }
439  }
440  }
441 }
442 
443 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
444 {
445  int i;
446 
447  for (i = 0; i < count; i++) {
448  int r = func(c, (char *)arg + i * size);
449  if (ret)
450  ret[i] = r;
451  }
452  emms_c();
453  return 0;
454 }
455 
456 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
457 {
458  int i;
459 
460  for (i = 0; i < count; i++) {
461  int r = func(c, arg, i, 0);
462  if (ret)
463  ret[i] = r;
464  }
465  emms_c();
466  return 0;
467 }
468 
470  unsigned int fourcc)
471 {
472  while (tags->pix_fmt >= 0) {
473  if (tags->fourcc == fourcc)
474  return tags->pix_fmt;
475  tags++;
476  }
477  return AV_PIX_FMT_NONE;
478 }
479 
480 #if FF_API_CODEC_GET_SET
481 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
482 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
484 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
485 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
486 
488 {
489  return codec->properties;
490 }
491 
493 {
494  return codec->max_lowres;
495 }
496 #endif
497 
500 }
501 
503 {
504  int64_t bit_rate;
505  int bits_per_sample;
506 
507  switch (ctx->codec_type) {
508  case AVMEDIA_TYPE_VIDEO:
509  case AVMEDIA_TYPE_DATA:
512  bit_rate = ctx->bit_rate;
513  break;
514  case AVMEDIA_TYPE_AUDIO:
515  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
516  bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
517  break;
518  default:
519  bit_rate = 0;
520  break;
521  }
522  return bit_rate;
523 }
524 
525 
526 static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
527 {
528  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
530 }
531 
532 static void ff_unlock_avcodec(const AVCodec *codec)
533 {
534  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
536 }
537 
538 int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
539 {
540  int ret = 0;
541 
542  ff_unlock_avcodec(codec);
543 
544  ret = avcodec_open2(avctx, codec, options);
545 
546  ff_lock_avcodec(avctx, codec);
547  return ret;
548 }
549 
550 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
551 {
552  int ret = 0;
553  int codec_init_ok = 0;
554  AVDictionary *tmp = NULL;
555  const AVPixFmtDescriptor *pixdesc;
556  AVCodecInternal *avci;
557 
558  if (avcodec_is_open(avctx))
559  return 0;
560 
561  if (!codec && !avctx->codec) {
562  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
563  return AVERROR(EINVAL);
564  }
565  if (codec && avctx->codec && codec != avctx->codec) {
566  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
567  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
568  return AVERROR(EINVAL);
569  }
570  if (!codec)
571  codec = avctx->codec;
572 
573  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
574  return AVERROR(EINVAL);
575 
576  if (options)
577  av_dict_copy(&tmp, *options, 0);
578 
579  ff_lock_avcodec(avctx, codec);
580 
581  avci = av_mallocz(sizeof(*avci));
582  if (!avci) {
583  ret = AVERROR(ENOMEM);
584  goto end;
585  }
586  avctx->internal = avci;
587 
588  avci->to_free = av_frame_alloc();
591  avci->buffer_frame = av_frame_alloc();
592  avci->buffer_pkt = av_packet_alloc();
593  avci->es.in_frame = av_frame_alloc();
594  avci->ds.in_pkt = av_packet_alloc();
596  if (!avci->compat_decode_frame || !avci->compat_encode_packet ||
597  !avci->buffer_frame || !avci->buffer_pkt ||
598  !avci->es.in_frame || !avci->ds.in_pkt ||
599  !avci->to_free || !avci->last_pkt_props) {
600  ret = AVERROR(ENOMEM);
601  goto free_and_end;
602  }
603 
604  avci->skip_samples_multiplier = 1;
605 
606  if (codec->priv_data_size > 0) {
607  if (!avctx->priv_data) {
608  avctx->priv_data = av_mallocz(codec->priv_data_size);
609  if (!avctx->priv_data) {
610  ret = AVERROR(ENOMEM);
611  goto end;
612  }
613  if (codec->priv_class) {
614  *(const AVClass **)avctx->priv_data = codec->priv_class;
616  }
617  }
618  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
619  goto free_and_end;
620  } else {
621  avctx->priv_data = NULL;
622  }
623  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
624  goto free_and_end;
625 
626  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
627  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
628  ret = AVERROR(EINVAL);
629  goto free_and_end;
630  }
631 
632  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
633  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
634  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
635  if (avctx->coded_width && avctx->coded_height)
636  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
637  else if (avctx->width && avctx->height)
638  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
639  if (ret < 0)
640  goto free_and_end;
641  }
642 
643  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
644  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
645  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
646  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
647  ff_set_dimensions(avctx, 0, 0);
648  }
649 
650  if (avctx->width > 0 && avctx->height > 0) {
651  if (av_image_check_sar(avctx->width, avctx->height,
652  avctx->sample_aspect_ratio) < 0) {
653  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
654  avctx->sample_aspect_ratio.num,
655  avctx->sample_aspect_ratio.den);
656  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
657  }
658  }
659 
660  /* if the decoder init function was already called previously,
661  * free the already allocated subtitle_header before overwriting it */
662  if (av_codec_is_decoder(codec))
663  av_freep(&avctx->subtitle_header);
664 
665  if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
666  av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
667  ret = AVERROR(EINVAL);
668  goto free_and_end;
669  }
670  if (avctx->sample_rate < 0) {
671  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
672  ret = AVERROR(EINVAL);
673  goto free_and_end;
674  }
675  if (avctx->block_align < 0) {
676  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
677  ret = AVERROR(EINVAL);
678  goto free_and_end;
679  }
680 
681  avctx->codec = codec;
682  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
683  avctx->codec_id == AV_CODEC_ID_NONE) {
684  avctx->codec_type = codec->type;
685  avctx->codec_id = codec->id;
686  }
687  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
688  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
689  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
690  ret = AVERROR(EINVAL);
691  goto free_and_end;
692  }
693  avctx->frame_number = 0;
695 
696  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
698  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
699  const AVCodec *codec2;
700  av_log(avctx, AV_LOG_ERROR,
701  "The %s '%s' is experimental but experimental codecs are not enabled, "
702  "add '-strict %d' if you want to use it.\n",
703  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
704  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
705  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
706  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
707  codec_string, codec2->name);
708  ret = AVERROR_EXPERIMENTAL;
709  goto free_and_end;
710  }
711 
712  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
713  (!avctx->time_base.num || !avctx->time_base.den)) {
714  avctx->time_base.num = 1;
715  avctx->time_base.den = avctx->sample_rate;
716  }
717 
718  if (!HAVE_THREADS)
719  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
720 
721  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
722  ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
723  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
724  ff_lock_avcodec(avctx, codec);
725  if (ret < 0)
726  goto free_and_end;
727  }
728 
729  if (av_codec_is_decoder(avctx->codec)) {
730  ret = ff_decode_bsfs_init(avctx);
731  if (ret < 0)
732  goto free_and_end;
733  }
734 
735  if (HAVE_THREADS
736  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
737  ret = ff_thread_init(avctx);
738  if (ret < 0) {
739  goto free_and_end;
740  }
741  }
742  if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
743  avctx->thread_count = 1;
744 
745  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
746  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
747  avctx->codec->max_lowres);
748  avctx->lowres = avctx->codec->max_lowres;
749  }
750 
751  if (av_codec_is_encoder(avctx->codec)) {
752  int i;
753 #if FF_API_CODED_FRAME
755  avctx->coded_frame = av_frame_alloc();
756  if (!avctx->coded_frame) {
757  ret = AVERROR(ENOMEM);
758  goto free_and_end;
759  }
761 #endif
762 
763  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
764  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
765  ret = AVERROR(EINVAL);
766  goto free_and_end;
767  }
768 
769  if (avctx->codec->sample_fmts) {
770  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
771  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
772  break;
773  if (avctx->channels == 1 &&
776  avctx->sample_fmt = avctx->codec->sample_fmts[i];
777  break;
778  }
779  }
780  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
781  char buf[128];
782  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
783  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
784  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
785  ret = AVERROR(EINVAL);
786  goto free_and_end;
787  }
788  }
789  if (avctx->codec->pix_fmts) {
790  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
791  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
792  break;
793  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
794  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
796  char buf[128];
797  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
798  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
799  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
800  ret = AVERROR(EINVAL);
801  goto free_and_end;
802  }
803  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
804  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
805  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
806  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
807  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
808  avctx->color_range = AVCOL_RANGE_JPEG;
809  }
810  if (avctx->codec->supported_samplerates) {
811  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
812  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
813  break;
814  if (avctx->codec->supported_samplerates[i] == 0) {
815  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
816  avctx->sample_rate);
817  ret = AVERROR(EINVAL);
818  goto free_and_end;
819  }
820  }
821  if (avctx->sample_rate < 0) {
822  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
823  avctx->sample_rate);
824  ret = AVERROR(EINVAL);
825  goto free_and_end;
826  }
827  if (avctx->codec->channel_layouts) {
828  if (!avctx->channel_layout) {
829  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
830  } else {
831  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
832  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
833  break;
834  if (avctx->codec->channel_layouts[i] == 0) {
835  char buf[512];
836  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
837  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
838  ret = AVERROR(EINVAL);
839  goto free_and_end;
840  }
841  }
842  }
843  if (avctx->channel_layout && avctx->channels) {
845  if (channels != avctx->channels) {
846  char buf[512];
847  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
848  av_log(avctx, AV_LOG_ERROR,
849  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
850  buf, channels, avctx->channels);
851  ret = AVERROR(EINVAL);
852  goto free_and_end;
853  }
854  } else if (avctx->channel_layout) {
856  }
857  if (avctx->channels < 0) {
858  av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
859  avctx->channels);
860  ret = AVERROR(EINVAL);
861  goto free_and_end;
862  }
863  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
864  pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
865  if ( avctx->bits_per_raw_sample < 0
866  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
867  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
868  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
869  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
870  }
871  if (avctx->width <= 0 || avctx->height <= 0) {
872  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
873  ret = AVERROR(EINVAL);
874  goto free_and_end;
875  }
876  }
877  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
878  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
879  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
880  }
881 
882  if (!avctx->rc_initial_buffer_occupancy)
883  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
884 
885  if (avctx->ticks_per_frame && avctx->time_base.num &&
886  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
887  av_log(avctx, AV_LOG_ERROR,
888  "ticks_per_frame %d too large for the timebase %d/%d.",
889  avctx->ticks_per_frame,
890  avctx->time_base.num,
891  avctx->time_base.den);
892  goto free_and_end;
893  }
894 
895  if (avctx->hw_frames_ctx) {
896  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
897  if (frames_ctx->format != avctx->pix_fmt) {
898  av_log(avctx, AV_LOG_ERROR,
899  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
900  ret = AVERROR(EINVAL);
901  goto free_and_end;
902  }
903  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
904  avctx->sw_pix_fmt != frames_ctx->sw_format) {
905  av_log(avctx, AV_LOG_ERROR,
906  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
907  "and AVHWFramesContext.sw_format (%s)\n",
909  av_get_pix_fmt_name(frames_ctx->sw_format));
910  ret = AVERROR(EINVAL);
911  goto free_and_end;
912  }
913  avctx->sw_pix_fmt = frames_ctx->sw_format;
914  }
915  }
916 
919  avctx->pts_correction_last_pts =
920  avctx->pts_correction_last_dts = INT64_MIN;
921 
922  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
924  av_log(avctx, AV_LOG_WARNING,
925  "gray decoding requested but not enabled at configuration time\n");
926  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
928  }
929 
930  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
931  || avci->frame_thread_encoder)) {
932  ret = avctx->codec->init(avctx);
933  if (ret < 0) {
934  goto free_and_end;
935  }
936  codec_init_ok = 1;
937  }
938 
939  ret=0;
940 
941  if (av_codec_is_decoder(avctx->codec)) {
942  if (!avctx->bit_rate)
943  avctx->bit_rate = get_bit_rate(avctx);
944  /* validate channel layout from the decoder */
945  if (avctx->channel_layout) {
947  if (!avctx->channels)
948  avctx->channels = channels;
949  else if (channels != avctx->channels) {
950  char buf[512];
951  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
952  av_log(avctx, AV_LOG_WARNING,
953  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
954  "ignoring specified channel layout\n",
955  buf, channels, avctx->channels);
956  avctx->channel_layout = 0;
957  }
958  }
959  if (avctx->channels && avctx->channels < 0 ||
960  avctx->channels > FF_SANE_NB_CHANNELS) {
961  ret = AVERROR(EINVAL);
962  goto free_and_end;
963  }
964  if (avctx->bits_per_coded_sample < 0) {
965  ret = AVERROR(EINVAL);
966  goto free_and_end;
967  }
968  if (avctx->sub_charenc) {
969  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
970  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
971  "supported with subtitles codecs\n");
972  ret = AVERROR(EINVAL);
973  goto free_and_end;
974  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
975  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
976  "subtitles character encoding will be ignored\n",
977  avctx->codec_descriptor->name);
979  } else {
980  /* input character encoding is set for a text based subtitle
981  * codec at this point */
984 
986 #if CONFIG_ICONV
987  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
988  if (cd == (iconv_t)-1) {
989  ret = AVERROR(errno);
990  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
991  "with input character encoding \"%s\"\n", avctx->sub_charenc);
992  goto free_and_end;
993  }
994  iconv_close(cd);
995 #else
996  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
997  "conversion needs a libavcodec built with iconv support "
998  "for this codec\n");
999  ret = AVERROR(ENOSYS);
1000  goto free_and_end;
1001 #endif
1002  }
1003  }
1004  }
1005 
1006 #if FF_API_AVCTX_TIMEBASE
1007  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1008  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1009 #endif
1010  }
1011  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1012  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1013  }
1014 
1015 end:
1016  ff_unlock_avcodec(codec);
1017  if (options) {
1018  av_dict_free(options);
1019  *options = tmp;
1020  }
1021 
1022  return ret;
1023 free_and_end:
1024  if (avctx->codec && avctx->codec->close &&
1025  (codec_init_ok ||
1027  avctx->codec->close(avctx);
1028 
1029  if (HAVE_THREADS && avci->thread_ctx)
1030  ff_thread_free(avctx);
1031 
1032  if (codec->priv_class && codec->priv_data_size)
1033  av_opt_free(avctx->priv_data);
1034  av_opt_free(avctx);
1035 
1036 #if FF_API_CODED_FRAME
1038  av_frame_free(&avctx->coded_frame);
1040 #endif
1041 
1042  av_dict_free(&tmp);
1043  av_freep(&avctx->priv_data);
1044  av_freep(&avctx->subtitle_header);
1045  if (avci) {
1046  av_frame_free(&avci->to_free);
1048  av_frame_free(&avci->buffer_frame);
1050  av_packet_free(&avci->buffer_pkt);
1052 
1053  av_packet_free(&avci->ds.in_pkt);
1054  av_frame_free(&avci->es.in_frame);
1055  av_bsf_free(&avci->bsf);
1056 
1057  av_buffer_unref(&avci->pool);
1058  }
1059  av_freep(&avci);
1060  avctx->internal = NULL;
1061  avctx->codec = NULL;
1062  goto end;
1063 }
1064 
1066 {
1067  AVCodecInternal *avci = avctx->internal;
1068 
1069  if (av_codec_is_encoder(avctx->codec)) {
1070  int caps = avctx->codec->capabilities;
1071 
1072  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
1073  // Only encoders that explicitly declare support for it can be
1074  // flushed. Otherwise, this is a no-op.
1075  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
1076  "that doesn't support it\n");
1077  return;
1078  }
1079 
1080  // We haven't implemented flushing for frame-threaded encoders.
1082  }
1083 
1084  avci->draining = 0;
1085  avci->draining_done = 0;
1086  avci->nb_draining_errors = 0;
1090  av_packet_unref(avci->buffer_pkt);
1091 
1092  av_frame_unref(avci->es.in_frame);
1093  av_packet_unref(avci->ds.in_pkt);
1094 
1095  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1096  ff_thread_flush(avctx);
1097  else if (avctx->codec->flush)
1098  avctx->codec->flush(avctx);
1099 
1100  avctx->pts_correction_last_pts =
1101  avctx->pts_correction_last_dts = INT64_MIN;
1102 
1103  if (av_codec_is_decoder(avctx->codec))
1104  av_bsf_flush(avci->bsf);
1105 
1106  if (!avctx->refcounted_frames)
1107  av_frame_unref(avci->to_free);
1108 }
1109 
1111 {
1112  int i;
1113 
1114  for (i = 0; i < sub->num_rects; i++) {
1115  av_freep(&sub->rects[i]->data[0]);
1116  av_freep(&sub->rects[i]->data[1]);
1117  av_freep(&sub->rects[i]->data[2]);
1118  av_freep(&sub->rects[i]->data[3]);
1119  av_freep(&sub->rects[i]->text);
1120  av_freep(&sub->rects[i]->ass);
1121  av_freep(&sub->rects[i]);
1122  }
1123 
1124  av_freep(&sub->rects);
1125 
1126  memset(sub, 0, sizeof(*sub));
1127 }
1128 
1130 {
1131  int i;
1132 
1133  if (!avctx)
1134  return 0;
1135 
1136  if (avcodec_is_open(avctx)) {
1137  if (CONFIG_FRAME_THREAD_ENCODER &&
1138  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1140  }
1141  if (HAVE_THREADS && avctx->internal->thread_ctx)
1142  ff_thread_free(avctx);
1143  if (avctx->codec && avctx->codec->close)
1144  avctx->codec->close(avctx);
1145  avctx->internal->byte_buffer_size = 0;
1146  av_freep(&avctx->internal->byte_buffer);
1147  av_frame_free(&avctx->internal->to_free);
1154  &avctx->internal->pkt_props_tail);
1155 
1156  av_packet_free(&avctx->internal->ds.in_pkt);
1157  av_frame_free(&avctx->internal->es.in_frame);
1158 
1159  av_buffer_unref(&avctx->internal->pool);
1160 
1161  if (avctx->hwaccel && avctx->hwaccel->uninit)
1162  avctx->hwaccel->uninit(avctx);
1164 
1165  av_bsf_free(&avctx->internal->bsf);
1166 
1167  av_freep(&avctx->internal);
1168  }
1169 
1170  for (i = 0; i < avctx->nb_coded_side_data; i++)
1171  av_freep(&avctx->coded_side_data[i].data);
1172  av_freep(&avctx->coded_side_data);
1173  avctx->nb_coded_side_data = 0;
1174 
1175  av_buffer_unref(&avctx->hw_frames_ctx);
1176  av_buffer_unref(&avctx->hw_device_ctx);
1177 
1178  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1179  av_opt_free(avctx->priv_data);
1180  av_opt_free(avctx);
1181  av_freep(&avctx->priv_data);
1182  if (av_codec_is_encoder(avctx->codec)) {
1183  av_freep(&avctx->extradata);
1184 #if FF_API_CODED_FRAME
1186  av_frame_free(&avctx->coded_frame);
1188 #endif
1189  }
1190  avctx->codec = NULL;
1191  avctx->active_thread_type = 0;
1192 
1193  return 0;
1194 }
1195 
1196 const char *avcodec_get_name(enum AVCodecID id)
1197 {
1198  const AVCodecDescriptor *cd;
1199  const AVCodec *codec;
1200 
1201  if (id == AV_CODEC_ID_NONE)
1202  return "none";
1203  cd = avcodec_descriptor_get(id);
1204  if (cd)
1205  return cd->name;
1206  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1207  codec = avcodec_find_decoder(id);
1208  if (codec)
1209  return codec->name;
1210  codec = avcodec_find_encoder(id);
1211  if (codec)
1212  return codec->name;
1213  return "unknown_codec";
1214 }
1215 
1216 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1217 {
1218  int i, len, ret = 0;
1219 
1220 #define TAG_PRINT(x) \
1221  (((x) >= '0' && (x) <= '9') || \
1222  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
1223  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1224 
1225  for (i = 0; i < 4; i++) {
1226  len = snprintf(buf, buf_size,
1227  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1228  buf += len;
1229  buf_size = buf_size > len ? buf_size - len : 0;
1230  ret += len;
1231  codec_tag >>= 8;
1232  }
1233  return ret;
1234 }
1235 
1236 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1237 {
1238  const char *codec_type;
1239  const char *codec_name;
1240  const char *profile = NULL;
1241  int64_t bitrate;
1242  int new_line = 0;
1243  AVRational display_aspect_ratio;
1244  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1245 
1246  if (!buf || buf_size <= 0)
1247  return;
1248  codec_type = av_get_media_type_string(enc->codec_type);
1249  codec_name = avcodec_get_name(enc->codec_id);
1250  profile = avcodec_profile_name(enc->codec_id, enc->profile);
1251 
1252  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1253  codec_name);
1254  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1255 
1256  if (enc->codec && strcmp(enc->codec->name, codec_name))
1257  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1258 
1259  if (profile)
1260  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1261  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
1263  && enc->refs)
1264  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1265  ", %d reference frame%s",
1266  enc->refs, enc->refs > 1 ? "s" : "");
1267 
1268  if (enc->codec_tag)
1269  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1270  av_fourcc2str(enc->codec_tag), enc->codec_tag);
1271 
1272  switch (enc->codec_type) {
1273  case AVMEDIA_TYPE_VIDEO:
1274  {
1275  char detail[256] = "(";
1276 
1277  av_strlcat(buf, separator, buf_size);
1278 
1279  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1280  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1282  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1284  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1286  av_strlcatf(detail, sizeof(detail), "%s, ",
1288 
1289  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1291  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1292  if (enc->colorspace != (int)enc->color_primaries ||
1293  enc->colorspace != (int)enc->color_trc) {
1294  new_line = 1;
1295  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1299  } else
1300  av_strlcatf(detail, sizeof(detail), "%s, ",
1302  }
1303 
1304  if (enc->field_order != AV_FIELD_UNKNOWN) {
1305  const char *field_order = "progressive";
1306  if (enc->field_order == AV_FIELD_TT)
1307  field_order = "top first";
1308  else if (enc->field_order == AV_FIELD_BB)
1309  field_order = "bottom first";
1310  else if (enc->field_order == AV_FIELD_TB)
1311  field_order = "top coded first (swapped)";
1312  else if (enc->field_order == AV_FIELD_BT)
1313  field_order = "bottom coded first (swapped)";
1314 
1315  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1316  }
1317 
1318  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1320  av_strlcatf(detail, sizeof(detail), "%s, ",
1322 
1323  if (strlen(detail) > 1) {
1324  detail[strlen(detail) - 2] = 0;
1325  av_strlcatf(buf, buf_size, "%s)", detail);
1326  }
1327  }
1328 
1329  if (enc->width) {
1330  av_strlcat(buf, new_line ? separator : ", ", buf_size);
1331 
1332  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1333  "%dx%d",
1334  enc->width, enc->height);
1335 
1336  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1337  (enc->width != enc->coded_width ||
1338  enc->height != enc->coded_height))
1339  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1340  " (%dx%d)", enc->coded_width, enc->coded_height);
1341 
1342  if (enc->sample_aspect_ratio.num) {
1343  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1344  enc->width * (int64_t)enc->sample_aspect_ratio.num,
1345  enc->height * (int64_t)enc->sample_aspect_ratio.den,
1346  1024 * 1024);
1347  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1348  " [SAR %d:%d DAR %d:%d]",
1350  display_aspect_ratio.num, display_aspect_ratio.den);
1351  }
1352  if (av_log_get_level() >= AV_LOG_DEBUG) {
1353  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1354  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1355  ", %d/%d",
1356  enc->time_base.num / g, enc->time_base.den / g);
1357  }
1358  }
1359  if (encode) {
1360  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1361  ", q=%d-%d", enc->qmin, enc->qmax);
1362  } else {
1364  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1365  ", Closed Captions");
1367  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1368  ", lossless");
1369  }
1370  break;
1371  case AVMEDIA_TYPE_AUDIO:
1372  av_strlcat(buf, separator, buf_size);
1373 
1374  if (enc->sample_rate) {
1375  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1376  "%d Hz, ", enc->sample_rate);
1377  }
1378  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1379  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1380  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1381  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1382  }
1383  if ( enc->bits_per_raw_sample > 0
1385  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1386  " (%d bit)", enc->bits_per_raw_sample);
1387  if (av_log_get_level() >= AV_LOG_VERBOSE) {
1388  if (enc->initial_padding)
1389  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1390  ", delay %d", enc->initial_padding);
1391  if (enc->trailing_padding)
1392  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1393  ", padding %d", enc->trailing_padding);
1394  }
1395  break;
1396  case AVMEDIA_TYPE_DATA:
1397  if (av_log_get_level() >= AV_LOG_DEBUG) {
1398  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1399  if (g)
1400  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1401  ", %d/%d",
1402  enc->time_base.num / g, enc->time_base.den / g);
1403  }
1404  break;
1405  case AVMEDIA_TYPE_SUBTITLE:
1406  if (enc->width)
1407  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1408  ", %dx%d", enc->width, enc->height);
1409  break;
1410  default:
1411  return;
1412  }
1413  if (encode) {
1414  if (enc->flags & AV_CODEC_FLAG_PASS1)
1415  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1416  ", pass 1");
1417  if (enc->flags & AV_CODEC_FLAG_PASS2)
1418  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1419  ", pass 2");
1420  }
1421  bitrate = get_bit_rate(enc);
1422  if (bitrate != 0) {
1423  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1424  ", %"PRId64" kb/s", bitrate / 1000);
1425  } else if (enc->rc_max_rate > 0) {
1426  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1427  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
1428  }
1429 }
1430 
1431 const char *av_get_profile_name(const AVCodec *codec, int profile)
1432 {
1433  const AVProfile *p;
1434  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1435  return NULL;
1436 
1437  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1438  if (p->profile == profile)
1439  return p->name;
1440 
1441  return NULL;
1442 }
1443 
1445 {
1446  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
1447  const AVProfile *p;
1448 
1449  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1450  return NULL;
1451 
1452  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1453  if (p->profile == profile)
1454  return p->name;
1455 
1456  return NULL;
1457 }
1458 
1459 unsigned avcodec_version(void)
1460 {
1463  av_assert0(AV_CODEC_ID_SRT==94216);
1465 
1466  return LIBAVCODEC_VERSION_INT;
1467 }
1468 
1469 const char *avcodec_configuration(void)
1470 {
1471  return FFMPEG_CONFIGURATION;
1472 }
1473 
1474 const char *avcodec_license(void)
1475 {
1476 #define LICENSE_PREFIX "libavcodec license: "
1477  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
1478 }
1479 
1481 {
1482  switch (codec_id) {
1483  case AV_CODEC_ID_8SVX_EXP:
1484  case AV_CODEC_ID_8SVX_FIB:
1486  case AV_CODEC_ID_ADPCM_CT:
1496  return 4;
1497  case AV_CODEC_ID_DSD_LSBF:
1498  case AV_CODEC_ID_DSD_MSBF:
1501  case AV_CODEC_ID_PCM_ALAW:
1502  case AV_CODEC_ID_PCM_MULAW:
1503  case AV_CODEC_ID_PCM_VIDC:
1504  case AV_CODEC_ID_PCM_S8:
1506  case AV_CODEC_ID_PCM_U8:
1507  case AV_CODEC_ID_SDX2_DPCM:
1508  case AV_CODEC_ID_DERF_DPCM:
1509  return 8;
1510  case AV_CODEC_ID_PCM_S16BE:
1512  case AV_CODEC_ID_PCM_S16LE:
1514  case AV_CODEC_ID_PCM_U16BE:
1515  case AV_CODEC_ID_PCM_U16LE:
1516  return 16;
1518  case AV_CODEC_ID_PCM_S24BE:
1519  case AV_CODEC_ID_PCM_S24LE:
1521  case AV_CODEC_ID_PCM_U24BE:
1522  case AV_CODEC_ID_PCM_U24LE:
1523  return 24;
1524  case AV_CODEC_ID_PCM_S32BE:
1525  case AV_CODEC_ID_PCM_S32LE:
1527  case AV_CODEC_ID_PCM_U32BE:
1528  case AV_CODEC_ID_PCM_U32LE:
1529  case AV_CODEC_ID_PCM_F32BE:
1530  case AV_CODEC_ID_PCM_F32LE:
1531  case AV_CODEC_ID_PCM_F24LE:
1532  case AV_CODEC_ID_PCM_F16LE:
1533  return 32;
1534  case AV_CODEC_ID_PCM_F64BE:
1535  case AV_CODEC_ID_PCM_F64LE:
1536  case AV_CODEC_ID_PCM_S64BE:
1537  case AV_CODEC_ID_PCM_S64LE:
1538  return 64;
1539  default:
1540  return 0;
1541  }
1542 }
1543 
1545 {
1546  static const enum AVCodecID map[][2] = {
1552  [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
1553  [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
1554  [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
1556  [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
1557  [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
1558  };
1559  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
1560  return AV_CODEC_ID_NONE;
1561  if (be < 0 || be > 1)
1562  be = AV_NE(1, 0);
1563  return map[fmt][be];
1564 }
1565 
1567 {
1568  switch (codec_id) {
1570  return 2;
1572  return 3;
1576  case AV_CODEC_ID_ADPCM_SWF:
1577  case AV_CODEC_ID_ADPCM_MS:
1578  return 4;
1579  default:
1580  return av_get_exact_bits_per_sample(codec_id);
1581  }
1582 }
1583 
1584 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1585  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
1586  uint8_t * extradata, int frame_size, int frame_bytes)
1587 {
1589  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
1590 
1591  /* codecs with an exact constant bits per sample */
1592  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
1593  return (frame_bytes * 8LL) / (bps * ch);
1594  bps = bits_per_coded_sample;
1595 
1596  /* codecs with a fixed packet duration */
1597  switch (id) {
1598  case AV_CODEC_ID_ADPCM_ADX: return 32;
1599  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
1600  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
1601  case AV_CODEC_ID_AMR_NB:
1602  case AV_CODEC_ID_EVRC:
1603  case AV_CODEC_ID_GSM:
1604  case AV_CODEC_ID_QCELP:
1605  case AV_CODEC_ID_RA_288: return 160;
1606  case AV_CODEC_ID_AMR_WB:
1607  case AV_CODEC_ID_GSM_MS: return 320;
1608  case AV_CODEC_ID_MP1: return 384;
1609  case AV_CODEC_ID_ATRAC1: return 512;
1610  case AV_CODEC_ID_ATRAC9:
1611  case AV_CODEC_ID_ATRAC3: return 1024 * framecount;
1612  case AV_CODEC_ID_ATRAC3P: return 2048;
1613  case AV_CODEC_ID_MP2:
1614  case AV_CODEC_ID_MUSEPACK7: return 1152;
1615  case AV_CODEC_ID_AC3: return 1536;
1616  }
1617 
1618  if (sr > 0) {
1619  /* calc from sample rate */
1620  if (id == AV_CODEC_ID_TTA)
1621  return 256 * sr / 245;
1622  else if (id == AV_CODEC_ID_DST)
1623  return 588 * sr / 44100;
1624 
1625  if (ch > 0) {
1626  /* calc from sample rate and channels */
1627  if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1628  return (480 << (sr / 22050)) / ch;
1629  }
1630 
1631  if (id == AV_CODEC_ID_MP3)
1632  return sr <= 24000 ? 576 : 1152;
1633  }
1634 
1635  if (ba > 0) {
1636  /* calc from block_align */
1637  if (id == AV_CODEC_ID_SIPR) {
1638  switch (ba) {
1639  case 20: return 160;
1640  case 19: return 144;
1641  case 29: return 288;
1642  case 37: return 480;
1643  }
1644  } else if (id == AV_CODEC_ID_ILBC) {
1645  switch (ba) {
1646  case 38: return 160;
1647  case 50: return 240;
1648  }
1649  }
1650  }
1651 
1652  if (frame_bytes > 0) {
1653  /* calc from frame_bytes only */
1654  if (id == AV_CODEC_ID_TRUESPEECH)
1655  return 240 * (frame_bytes / 32);
1656  if (id == AV_CODEC_ID_NELLYMOSER)
1657  return 256 * (frame_bytes / 64);
1658  if (id == AV_CODEC_ID_RA_144)
1659  return 160 * (frame_bytes / 20);
1660 
1661  if (bps > 0) {
1662  /* calc from frame_bytes and bits_per_coded_sample */
1664  return frame_bytes * 8 / bps;
1665  }
1666 
1667  if (ch > 0 && ch < INT_MAX/16) {
1668  /* calc from frame_bytes and channels */
1669  switch (id) {
1670  case AV_CODEC_ID_FASTAUDIO:
1671  return frame_bytes / (40 * ch) * 256;
1673  return (frame_bytes - 4 * ch) / (128 * ch) * 256;
1674  case AV_CODEC_ID_ADPCM_AFC:
1675  return frame_bytes / (9 * ch) * 16;
1676  case AV_CODEC_ID_ADPCM_PSX:
1677  case AV_CODEC_ID_ADPCM_DTK:
1678  return frame_bytes / (16 * ch) * 28;
1679  case AV_CODEC_ID_ADPCM_4XM:
1682  return (frame_bytes - 4 * ch) * 2 / ch;
1684  return (frame_bytes - 4) * 2 / ch;
1686  return (frame_bytes - 8) * 2 / ch;
1687  case AV_CODEC_ID_ADPCM_THP:
1689  if (extradata)
1690  return frame_bytes * 14 / (8 * ch);
1691  break;
1692  case AV_CODEC_ID_ADPCM_XA:
1693  return (frame_bytes / 128) * 224 / ch;
1695  return (frame_bytes - 6 - ch) / ch;
1696  case AV_CODEC_ID_ROQ_DPCM:
1697  return (frame_bytes - 8) / ch;
1698  case AV_CODEC_ID_XAN_DPCM:
1699  return (frame_bytes - 2 * ch) / ch;
1700  case AV_CODEC_ID_MACE3:
1701  return 3 * frame_bytes / ch;
1702  case AV_CODEC_ID_MACE6:
1703  return 6 * frame_bytes / ch;
1704  case AV_CODEC_ID_PCM_LXF:
1705  return 2 * (frame_bytes / (5 * ch));
1706  case AV_CODEC_ID_IAC:
1707  case AV_CODEC_ID_IMC:
1708  return 4 * frame_bytes / ch;
1709  }
1710 
1711  if (tag) {
1712  /* calc from frame_bytes, channels, and codec_tag */
1713  if (id == AV_CODEC_ID_SOL_DPCM) {
1714  if (tag == 3)
1715  return frame_bytes / ch;
1716  else
1717  return frame_bytes * 2 / ch;
1718  }
1719  }
1720 
1721  if (ba > 0) {
1722  /* calc from frame_bytes, channels, and block_align */
1723  int blocks = frame_bytes / ba;
1724  switch (id) {
1726  if (bps < 2 || bps > 5)
1727  return 0;
1728  return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
1730  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1732  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1734  return blocks * ((ba - 4 * ch) * 2 / ch);
1735  case AV_CODEC_ID_ADPCM_MS:
1736  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1738  return blocks * (ba - 16) * 2 / ch;
1739  }
1740  }
1741 
1742  if (bps > 0) {
1743  /* calc from frame_bytes, channels, and bits_per_coded_sample */
1744  switch (id) {
1745  case AV_CODEC_ID_PCM_DVD:
1746  if(bps<4 || frame_bytes<3)
1747  return 0;
1748  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
1750  if(bps<4 || frame_bytes<4)
1751  return 0;
1752  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
1753  case AV_CODEC_ID_S302M:
1754  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1755  }
1756  }
1757  }
1758  }
1759 
1760  /* Fall back on using frame_size */
1761  if (frame_size > 1 && frame_bytes)
1762  return frame_size;
1763 
1764  //For WMA we currently have no other means to calculate duration thus we
1765  //do it here by assuming CBR, which is true for all known cases.
1766  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
1767  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
1768  return (frame_bytes * 8LL * sr) / bitrate;
1769  }
1770 
1771  return 0;
1772 }
1773 
1774 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1775 {
1776  return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1777  avctx->channels, avctx->block_align,
1778  avctx->codec_tag, avctx->bits_per_coded_sample,
1779  avctx->bit_rate, avctx->extradata, avctx->frame_size,
1780  frame_bytes);
1781 }
1782 
1784 {
1785  return get_audio_frame_duration(par->codec_id, par->sample_rate,
1786  par->channels, par->block_align,
1787  par->codec_tag, par->bits_per_coded_sample,
1788  par->bit_rate, par->extradata, par->frame_size,
1789  frame_bytes);
1790 }
1791 
1792 #if !HAVE_THREADS
1794 {
1795  return -1;
1796 }
1797 
1798 #endif
1799 
1800 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1801 {
1802  unsigned int n = 0;
1803 
1804  while (v >= 0xff) {
1805  *s++ = 0xff;
1806  v -= 0xff;
1807  n++;
1808  }
1809  *s = v;
1810  n++;
1811  return n;
1812 }
1813 
1814 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1815 {
1816  int i;
1817  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1818  return i;
1819 }
1820 
1822 {
1823  int i;
1824  if (!codec->hw_configs || index < 0)
1825  return NULL;
1826  for (i = 0; i <= index; i++)
1827  if (!codec->hw_configs[i])
1828  return NULL;
1829  return &codec->hw_configs[index]->public;
1830 }
1831 
1832 #if FF_API_USER_VISIBLE_AVHWACCEL
1834 {
1835  return NULL;
1836 }
1837 
1839 {
1840 }
1841 #endif
1842 
1843 #if FF_API_LOCKMGR
1844 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1845 {
1846  return 0;
1847 }
1848 #endif
1849 
1850 unsigned int avpriv_toupper4(unsigned int x)
1851 {
1852  return av_toupper(x & 0xFF) +
1853  (av_toupper((x >> 8) & 0xFF) << 8) +
1854  (av_toupper((x >> 16) & 0xFF) << 16) +
1855 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
1856 }
1857 
1859 {
1860  int ret;
1861 
1862  dst->owner[0] = src->owner[0];
1863  dst->owner[1] = src->owner[1];
1864 
1865  ret = av_frame_ref(dst->f, src->f);
1866  if (ret < 0)
1867  return ret;
1868 
1869  av_assert0(!dst->progress);
1870 
1871  if (src->progress &&
1872  !(dst->progress = av_buffer_ref(src->progress))) {
1873  ff_thread_release_buffer(dst->owner[0], dst);
1874  return AVERROR(ENOMEM);
1875  }
1876 
1877  return 0;
1878 }
1879 
1880 #if !HAVE_THREADS
1881 
1883 {
1884  return ff_get_format(avctx, fmt);
1885 }
1886 
1888 {
1889  f->owner[0] = f->owner[1] = avctx;
1890  return ff_get_buffer(avctx, f->f, flags);
1891 }
1892 
1894 {
1895  if (f->f)
1896  av_frame_unref(f->f);
1897 }
1898 
1900 {
1901 }
1902 
1904 {
1905 }
1906 
1907 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1908 {
1909 }
1910 
1912 {
1913  return 1;
1914 }
1915 
1917 {
1918  return 0;
1919 }
1920 
1922 {
1923 }
1924 
1925 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1926 {
1927 }
1928 
1929 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1930 {
1931 }
1932 
1933 #endif
1934 
1936 {
1937  return !!s->internal;
1938 }
1939 
1940 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
1941 {
1942  int ret;
1943  char *str;
1944 
1945  ret = av_bprint_finalize(buf, &str);
1946  if (ret < 0)
1947  return ret;
1948  if (!av_bprint_is_complete(buf)) {
1949  av_free(str);
1950  return AVERROR(ENOMEM);
1951  }
1952 
1953  avctx->extradata = str;
1954  /* Note: the string is NUL terminated (so extradata can be read as a
1955  * string), but the ending character is not accounted in the size (in
1956  * binary formats you are likely not supposed to mux that character). When
1957  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
1958  * zeros. */
1959  avctx->extradata_size = buf->len;
1960  return 0;
1961 }
1962 
1963 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
1964  const uint8_t *end,
1965  uint32_t *av_restrict state)
1966 {
1967  int i;
1968 
1969  av_assert0(p <= end);
1970  if (p >= end)
1971  return end;
1972 
1973  for (i = 0; i < 3; i++) {
1974  uint32_t tmp = *state << 8;
1975  *state = tmp + *(p++);
1976  if (tmp == 0x100 || p == end)
1977  return p;
1978  }
1979 
1980  while (p < end) {
1981  if (p[-1] > 1 ) p += 3;
1982  else if (p[-2] ) p += 2;
1983  else if (p[-3]|(p[-1]-1)) p++;
1984  else {
1985  p++;
1986  break;
1987  }
1988  }
1989 
1990  p = FFMIN(p, end) - 4;
1991  *state = AV_RB32(p);
1992 
1993  return p + 4;
1994 }
1995 
1997 {
1998  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1999  if (!props)
2000  return NULL;
2001 
2002  if (size)
2003  *size = sizeof(*props);
2004 
2005  props->vbv_delay = UINT64_MAX;
2006 
2007  return props;
2008 }
2009 
2011 {
2013  AVCPBProperties *props;
2014  size_t size;
2015  int i;
2016 
2017  for (i = 0; i < avctx->nb_coded_side_data; i++)
2019  return (AVCPBProperties *)avctx->coded_side_data[i].data;
2020 
2021  props = av_cpb_properties_alloc(&size);
2022  if (!props)
2023  return NULL;
2024 
2025  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
2026  if (!tmp) {
2027  av_freep(&props);
2028  return NULL;
2029  }
2030 
2031  avctx->coded_side_data = tmp;
2032  avctx->nb_coded_side_data++;
2033 
2035  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
2036  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
2037 
2038  return props;
2039 }
2040 
2042 {
2043  av_freep(&par->extradata);
2044 
2045  memset(par, 0, sizeof(*par));
2046 
2048  par->codec_id = AV_CODEC_ID_NONE;
2049  par->format = -1;
2056  par->sample_aspect_ratio = (AVRational){ 0, 1 };
2057  par->profile = FF_PROFILE_UNKNOWN;
2058  par->level = FF_LEVEL_UNKNOWN;
2059 }
2060 
2062 {
2063  AVCodecParameters *par = av_mallocz(sizeof(*par));
2064 
2065  if (!par)
2066  return NULL;
2068  return par;
2069 }
2070 
2072 {
2073  AVCodecParameters *par = *ppar;
2074 
2075  if (!par)
2076  return;
2078 
2079  av_freep(ppar);
2080 }
2081 
2083 {
2085  memcpy(dst, src, sizeof(*dst));
2086 
2087  dst->extradata = NULL;
2088  dst->extradata_size = 0;
2089  if (src->extradata) {
2091  if (!dst->extradata)
2092  return AVERROR(ENOMEM);
2093  memcpy(dst->extradata, src->extradata, src->extradata_size);
2094  dst->extradata_size = src->extradata_size;
2095  }
2096 
2097  return 0;
2098 }
2099 
2101  const AVCodecContext *codec)
2102 {
2104 
2105  par->codec_type = codec->codec_type;
2106  par->codec_id = codec->codec_id;
2107  par->codec_tag = codec->codec_tag;
2108 
2109  par->bit_rate = codec->bit_rate;
2112  par->profile = codec->profile;
2113  par->level = codec->level;
2114 
2115  switch (par->codec_type) {
2116  case AVMEDIA_TYPE_VIDEO:
2117  par->format = codec->pix_fmt;
2118  par->width = codec->width;
2119  par->height = codec->height;
2120  par->field_order = codec->field_order;
2121  par->color_range = codec->color_range;
2122  par->color_primaries = codec->color_primaries;
2123  par->color_trc = codec->color_trc;
2124  par->color_space = codec->colorspace;
2127  par->video_delay = codec->has_b_frames;
2128  break;
2129  case AVMEDIA_TYPE_AUDIO:
2130  par->format = codec->sample_fmt;
2131  par->channel_layout = codec->channel_layout;
2132  par->channels = codec->channels;
2133  par->sample_rate = codec->sample_rate;
2134  par->block_align = codec->block_align;
2135  par->frame_size = codec->frame_size;
2136  par->initial_padding = codec->initial_padding;
2137  par->trailing_padding = codec->trailing_padding;
2138  par->seek_preroll = codec->seek_preroll;
2139  break;
2140  case AVMEDIA_TYPE_SUBTITLE:
2141  par->width = codec->width;
2142  par->height = codec->height;
2143  break;
2144  }
2145 
2146  if (codec->extradata) {
2148  if (!par->extradata)
2149  return AVERROR(ENOMEM);
2150  memcpy(par->extradata, codec->extradata, codec->extradata_size);
2151  par->extradata_size = codec->extradata_size;
2152  }
2153 
2154  return 0;
2155 }
2156 
2158  const AVCodecParameters *par)
2159 {
2160  codec->codec_type = par->codec_type;
2161  codec->codec_id = par->codec_id;
2162  codec->codec_tag = par->codec_tag;
2163 
2164  codec->bit_rate = par->bit_rate;
2167  codec->profile = par->profile;
2168  codec->level = par->level;
2169 
2170  switch (par->codec_type) {
2171  case AVMEDIA_TYPE_VIDEO:
2172  codec->pix_fmt = par->format;
2173  codec->width = par->width;
2174  codec->height = par->height;
2175  codec->field_order = par->field_order;
2176  codec->color_range = par->color_range;
2177  codec->color_primaries = par->color_primaries;
2178  codec->color_trc = par->color_trc;
2179  codec->colorspace = par->color_space;
2182  codec->has_b_frames = par->video_delay;
2183  break;
2184  case AVMEDIA_TYPE_AUDIO:
2185  codec->sample_fmt = par->format;
2186  codec->channel_layout = par->channel_layout;
2187  codec->channels = par->channels;
2188  codec->sample_rate = par->sample_rate;
2189  codec->block_align = par->block_align;
2190  codec->frame_size = par->frame_size;
2191  codec->delay =
2192  codec->initial_padding = par->initial_padding;
2193  codec->trailing_padding = par->trailing_padding;
2194  codec->seek_preroll = par->seek_preroll;
2195  break;
2196  case AVMEDIA_TYPE_SUBTITLE:
2197  codec->width = par->width;
2198  codec->height = par->height;
2199  break;
2200  }
2201 
2202  if (par->extradata) {
2203  av_freep(&codec->extradata);
2205  if (!codec->extradata)
2206  return AVERROR(ENOMEM);
2207  memcpy(codec->extradata, par->extradata, par->extradata_size);
2208  codec->extradata_size = par->extradata_size;
2209  }
2210 
2211  return 0;
2212 }
2213 
2214 static unsigned bcd2uint(uint8_t bcd)
2215 {
2216  unsigned low = bcd & 0xf;
2217  unsigned high = bcd >> 4;
2218  if (low > 9 || high > 9)
2219  return 0;
2220  return low + 10*high;
2221 }
2222 
2223 int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len,
2224  void **data, size_t *sei_size)
2225 {
2226  AVFrameSideData *sd = NULL;
2227  uint8_t *sei_data;
2228  PutBitContext pb;
2229  uint32_t *tc;
2230  int m;
2231 
2232  if (frame)
2234 
2235  if (!sd) {
2236  *data = NULL;
2237  return 0;
2238  }
2239  tc = (uint32_t*)sd->data;
2240  m = tc[0] & 3;
2241 
2242  *sei_size = sizeof(uint32_t) * 4;
2243  *data = av_mallocz(*sei_size + prefix_len);
2244  if (!*data)
2245  return AVERROR(ENOMEM);
2246  sei_data = (uint8_t*)*data + prefix_len;
2247 
2248  init_put_bits(&pb, sei_data, *sei_size);
2249  put_bits(&pb, 2, m); // num_clock_ts
2250 
2251  for (int j = 1; j <= m; j++) {
2252  uint32_t tcsmpte = tc[j];
2253  unsigned hh = bcd2uint(tcsmpte & 0x3f); // 6-bit hours
2254  unsigned mm = bcd2uint(tcsmpte>>8 & 0x7f); // 7-bit minutes
2255  unsigned ss = bcd2uint(tcsmpte>>16 & 0x7f); // 7-bit seconds
2256  unsigned ff = bcd2uint(tcsmpte>>24 & 0x3f); // 6-bit frames
2257  unsigned drop = tcsmpte & 1<<30 && !0; // 1-bit drop if not arbitrary bit
2258 
2259  /* Calculate frame number of HEVC by SMPTE ST 12-1:2014 Sec 12.2 if rate > 30FPS */
2260  if (av_cmp_q(rate, (AVRational) {30, 1}) == 1) {
2261  unsigned pc;
2262  ff *= 2;
2263  if (av_cmp_q(rate, (AVRational) {50, 1}) == 0)
2264  pc = !!(tcsmpte & 1 << 7);
2265  else
2266  pc = !!(tcsmpte & 1 << 23);
2267  ff = (ff + pc) & 0x7f;
2268  }
2269 
2270  put_bits(&pb, 1, 1); // clock_timestamp_flag
2271  put_bits(&pb, 1, 1); // units_field_based_flag
2272  put_bits(&pb, 5, 0); // counting_type
2273  put_bits(&pb, 1, 1); // full_timestamp_flag
2274  put_bits(&pb, 1, 0); // discontinuity_flag
2275  put_bits(&pb, 1, drop);
2276  put_bits(&pb, 9, ff);
2277  put_bits(&pb, 6, ss);
2278  put_bits(&pb, 6, mm);
2279  put_bits(&pb, 5, hh);
2280  put_bits(&pb, 5, 0);
2281  }
2282  flush_put_bits(&pb);
2283 
2284  return 0;
2285 }
2286 
2288 {
2289  AVRational framerate = avctx->framerate;
2290  int bits_per_coded_sample = avctx->bits_per_coded_sample;
2291  int64_t bitrate;
2292 
2293  if (!(framerate.num && framerate.den))
2294  framerate = av_inv_q(avctx->time_base);
2295  if (!(framerate.num && framerate.den))
2296  return 0;
2297 
2298  if (!bits_per_coded_sample) {
2300  bits_per_coded_sample = av_get_bits_per_pixel(desc);
2301  }
2302  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
2303  framerate.num / framerate.den;
2304 
2305  return bitrate;
2306 }
2307 
2308 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
2309  const int * array_valid_values, int default_value)
2310 {
2311  int i = 0, ref_val;
2312 
2313  while (1) {
2314  ref_val = array_valid_values[i];
2315  if (ref_val == INT_MAX)
2316  break;
2317  if (val == ref_val)
2318  return val;
2319  i++;
2320  }
2321  /* val is not a valid value */
2322  av_log(ctx, AV_LOG_DEBUG,
2323  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
2324  return default_value;
2325 }
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:2287
#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:97
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1594
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: hwconfig.h:34
int nb_draining_errors
Definition: internal.h:197
enum AVChromaLocation chroma_location
Definition: codec_par.h:150
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:2127
#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:1292
const struct AVCodec * codec
Definition: avcodec.h:535
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:2069
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
static int64_t get_bit_rate(AVCodecContext *ctx)
Definition: utils.c:502
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:2090
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: codec_par.h:148
int(* receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt)
Encode API with decoupled frame/packet dataflow.
Definition: codec.h:289
#define AV_NUM_DATA_POINTERS
Definition: frame.h:309
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:2126
static AVMutex mutex
Definition: log.c:44
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:2107
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
unsigned int fourcc
Definition: raw.h:36
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:96
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: codec.h:321
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2082
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:147
const char * desc
Definition: libsvtav1.c:79
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
AVFrame * f
Definition: thread.h:35
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
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:134
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
const char * g
Definition: vf_curves.c:115
#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:2525
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:296
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:136
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1432
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:301
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:171
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:1357
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: utils.c:1469
uint32_t fourcc
Definition: vaapi_decode.c:239
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
int ff_decode_bsfs_init(AVCodecContext *avctx)
Called during avcodec_open2() to initialize avctx->internal->bsf.
Definition: decode.c:214
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int num
Numerator.
Definition: rational.h:59
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
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:2125
static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
Definition: utils.c:526
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:101
const char * avcodec_license(void)
Return the libavcodec license.
Definition: utils.c:1474
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
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:736
#define tc
Definition: regdef.h:69
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:2698
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:498
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:72
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: codec.h:98
mpegvideo header.
enum AVMediaType type
Definition: codec.h:203
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1757
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: utils.c:1882
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:1844
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: utils.c:355
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
Definition: codec.h:118
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1690
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:188
int trailing_padding
Audio only.
Definition: codec_par.h:196
int profile
profile
Definition: avcodec.h:1859
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AVCodec.
Definition: codec.h:190
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:1223
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: codec_par.h:52
AVLockOp
Lock operation used by lockmgr.
Definition: avcodec.h:4084
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:106
char * text
0 terminated plain UTF-8 text
Definition: avcodec.h:2682
enum AVColorSpace color_space
Definition: codec_par.h:149
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2966
Macro definitions for various function/variable attributes.
int frame_size
Audio only.
Definition: codec_par.h:181
static AVMutex codec_mutex
Definition: utils.c:70
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
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:751
AVSubtitleRect ** rects
Definition: avcodec.h:2699
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2548
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:1925
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:378
uint64_t vbv_delay
The delay between the time the packet this structure is associated with is received and the time when...
Definition: avcodec.h:490
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:340
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1983
#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:2354
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:64
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:1194
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:88
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: codec_par.h:126
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:403
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:2899
void * thread_ctx
Definition: internal.h:138
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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:136
int trailing_padding
Audio only.
Definition: avcodec.h:2248
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:456
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2061
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:2192
#define LIBAVCODEC_VERSION_INT
Definition: version.h:34
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:280
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
#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:2157
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:2010
Public header for CRC hash function implementation.
void * frame_thread_encoder
Definition: internal.h:157
int initial_padding
Audio only.
Definition: codec_par.h:189
Structure to hold side data for an AVFrame.
Definition: frame.h:214
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:322
int 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:538
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:1532
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:428
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
uint8_t * data
Definition: packet.h:307
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:1584
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1765
int av_codec_get_max_lowres(const AVCodec *codec)
Definition: utils.c:492
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
static unsigned bcd2uint(uint8_t bcd)
Definition: utils.c:2214
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:1814
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:1750
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:121
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
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:1996
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
static void codec_parameters_reset(AVCodecParameters *par)
Definition: utils.c:2041
#define FFALIGN(x, a)
Definition: macros.h:48
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#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
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:2071
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1593
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:156
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:1838
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
AVPacketList * pkt_props_tail
Definition: internal.h:149
Libavcodec version macros.
#define src
Definition: vp8dsp.c:254
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:1129
AVBSFContext * bsf
Definition: internal.h:141
enum AVCodecID id
Definition: codec.h:204
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
Definition: codec.h:214
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:2990
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
Definition: utils.c:487
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1566
#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:2308
#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:1850
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int qmax
maximum quantizer
Definition: avcodec.h:1375
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:2108
AVFrame * in_frame
Definition: internal.h:116
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1935
int video_delay
Video only.
Definition: codec_par.h:155
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:451
AVFrame * buffer_frame
Definition: internal.h:180
int capabilities
Codec capabilities.
Definition: codec.h:209
int initial_padding
Audio only.
Definition: avcodec.h:2060
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:1793
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: codec_id.h:415
#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: codec_par.h:56
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:606
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:926
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: packet.h:309
int av_log_get_level(void)
Get the current log level.
Definition: log.c:435
const char * name
Name of the codec implementation.
Definition: codec.h:197
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:2256
const struct AVProfile * profiles
If non-NULL, an array of profiles recognized for this codec.
Definition: codec_desc.h:65
int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for S12M timecode side data and allocate and fill TC SEI message with timecode info...
Definition: utils.c:2223
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
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:1783
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
const char av_codec_ffversion[]
Definition: utils.c:68
static int ff_mutex_unlock(AVMutex *mutex)
Definition: thread.h:169
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2918
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
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:1389
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
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:230
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
int refs
number of reference frames
Definition: avcodec.h:1114
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:287
int block_align
Audio only.
Definition: codec_par.h:177
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
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: codec.h:211
static struct @322 state
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
#define FFMIN(a, b)
Definition: common.h:96
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2201
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:1480
AVFrame * compat_decode_frame
Definition: internal.h:189
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1929
int width
picture width / height.
Definition: avcodec.h:699
static void ff_unlock_avcodec(const AVCodec *codec)
Definition: utils.c:532
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2226
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1860
int priv_data_size
Definition: codec.h:238
int profile
Definition: codec.h:177
AVPacket * in_pkt
Definition: internal.h:112
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
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:1982
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:1899
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: codec.h:217
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:658
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: codec_par.h:146
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:140
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:469
char * sub_charenc
DTS of the last frame.
Definition: avcodec.h:2116
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:2677
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:174
#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
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1785
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:538
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2124
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
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: utils.c:1065
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:381
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:1431
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1206
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:448
AVPacketList * pkt_props
Definition: internal.h:148
int(* decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt)
Definition: codec.h:282
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:2166
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:1833
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:534
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
EncodeSimpleContext es
Definition: internal.h:159
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:1544
enum AVCodecID codec_id
Definition: avcodec.h:536
int seek_preroll
Number of samples to skip after a discontinuity.
Definition: avcodec.h:2149
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1655
int sample_rate
samples per second
Definition: avcodec.h:1186
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
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:1821
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
main external API structure.
Definition: avcodec.h:526
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
int skip_samples_multiplier
Definition: internal.h:194
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:1368
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1110
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:551
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:1872
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
uint8_t * data
Definition: frame.h:216
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: codec_desc.h:97
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:257
int extradata_size
Definition: avcodec.h:628
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1800
int nb_coded_side_data
Definition: avcodec.h:2202
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:714
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
AVPacket * compat_encode_packet
Definition: internal.h:190
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2193
int(* init)(struct AVCodecContext *)
Definition: codec.h:267
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:739
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
int index
Definition: gxfenc.c:89
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:1154
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:1893
const char * name
short name for the profile
Definition: codec.h:178
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:2100
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:2184
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:108
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:550
#define snprintf
Definition: snprintf.h:34
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1774
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
Definition: avcodec.h:1357
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:931
AVBufferRef * pool
Definition: internal.h:136
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:45
int seek_preroll
Audio only.
Definition: codec_par.h:200
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
Definition: utils.c:1940
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:566
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:560
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: codec_par.h:115
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:216
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
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:414
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: codec_par.h:170
enum AVMediaType type
Definition: codec_desc.h:40
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:215
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:179
int64_t bitrate
Definition: h264_levels.c:131
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:75
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:1610
const OptionDef options[]
Definition: ffmpeg_opt.c:3393
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
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:367
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:115
#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 profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:120
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2942
int(* encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: codec.h:268
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:169
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:84
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AVProfile.
Definition: codec.h:176
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:1911
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1776
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:1903
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:387
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: codec.h:306
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1196
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2191
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
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:456
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:288
unsigned bps
Definition: movenc.c:1533
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:215
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
Definition: utils.c:1236
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:300
static int lowres
Definition: ffplay.c:336
void * priv_data
Definition: avcodec.h:553
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:1216
int(* close)(struct AVCodecContext *)
Definition: codec.h:283
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
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
#define av_free(p)
uint8_t * dump_separator
dump format separator.
Definition: avcodec.h:2176
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:1858
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
#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: codec_id.h:432
int len
int channels
number of audio channels
Definition: avcodec.h:1187
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
Definition: codec.h:212
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:561
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: utils.c:1459
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:53
char * ass
0 terminated ASS/SSA compatible event line.
Definition: avcodec.h:2689
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:145
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:565
signed 64 bits, planar
Definition: samplefmt.h:72
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3429
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:613
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
static const struct twinvq_data tab
unsigned int byte_buffer_size
Definition: internal.h:155
int channels
Audio only.
Definition: codec_par.h:166
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: utils.c:1907
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:380
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:2109
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
int height
Definition: frame.h:366
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:2106
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:1183
signed 16 bits, planar
Definition: samplefmt.h:67
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:557
static float sub(float src0, float src1)
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:40
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: codec.h:213
AVMatrixEncoding
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: utils.c:1887
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
int ff_alloc_entries(AVCodecContext *avctx, int count)
Definition: utils.c:1916
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:2489
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:1963
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:1921
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:355
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:2278
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
static double val(void *priv, double ch)
Definition: aeval.c:76
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:154
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1444
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:682
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:374
#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:1589
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:2076
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:246
int i
Definition: input.c:407
#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:443
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
void avpriv_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
Wipe the list and unref all the packets in it.
Definition: avpacket.c:782
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:2014
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
bitstream writer API