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 "put_bits.h"
54 #include "raw.h"
55 #include "bytestream.h"
56 #include "version.h"
57 #include <stdlib.h>
58 #include <stdarg.h>
59 #include <stdatomic.h>
60 #include <limits.h>
61 #include <float.h>
62 #if CONFIG_ICONV
63 # include <iconv.h>
64 #endif
65 
66 #include "libavutil/ffversion.h"
67 const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
68 
70 
71 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
72 {
73  uint8_t **p = ptr;
74  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
75  av_freep(p);
76  *size = 0;
77  return;
78  }
79  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
80  memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
81 }
82 
83 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
84 {
85  uint8_t **p = ptr;
86  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
87  av_freep(p);
88  *size = 0;
89  return;
90  }
91  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
92  memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
93 }
94 
95 int av_codec_is_encoder(const AVCodec *codec)
96 {
97  return codec && (codec->encode_sub || codec->encode2 || codec->receive_packet);
98 }
99 
100 int av_codec_is_decoder(const AVCodec *codec)
101 {
102  return codec && (codec->decode || codec->receive_frame);
103 }
104 
106 {
107  int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
108 
109  if (ret < 0)
110  width = height = 0;
111 
112  s->coded_width = width;
113  s->coded_height = height;
114  s->width = AV_CEIL_RSHIFT(width, s->lowres);
115  s->height = AV_CEIL_RSHIFT(height, s->lowres);
116 
117  return ret;
118 }
119 
121 {
122  int ret = av_image_check_sar(avctx->width, avctx->height, sar);
123 
124  if (ret < 0) {
125  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
126  sar.num, sar.den);
127  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
128  return ret;
129  } else {
130  avctx->sample_aspect_ratio = sar;
131  }
132  return 0;
133 }
134 
136  enum AVMatrixEncoding matrix_encoding)
137 {
138  AVFrameSideData *side_data;
139  enum AVMatrixEncoding *data;
140 
142  if (!side_data)
144  sizeof(enum AVMatrixEncoding));
145 
146  if (!side_data)
147  return AVERROR(ENOMEM);
148 
149  data = (enum AVMatrixEncoding*)side_data->data;
150  *data = matrix_encoding;
151 
152  return 0;
153 }
154 
156  int linesize_align[AV_NUM_DATA_POINTERS])
157 {
158  int i;
159  int w_align = 1;
160  int h_align = 1;
162 
163  if (desc) {
164  w_align = 1 << desc->log2_chroma_w;
165  h_align = 1 << desc->log2_chroma_h;
166  }
167 
168  switch (s->pix_fmt) {
169  case AV_PIX_FMT_YUV420P:
170  case AV_PIX_FMT_YUYV422:
171  case AV_PIX_FMT_YVYU422:
172  case AV_PIX_FMT_UYVY422:
173  case AV_PIX_FMT_YUV422P:
174  case AV_PIX_FMT_YUV440P:
175  case AV_PIX_FMT_YUV444P:
176  case AV_PIX_FMT_GBRP:
177  case AV_PIX_FMT_GBRAP:
178  case AV_PIX_FMT_GRAY8:
179  case AV_PIX_FMT_GRAY16BE:
180  case AV_PIX_FMT_GRAY16LE:
181  case AV_PIX_FMT_YUVJ420P:
182  case AV_PIX_FMT_YUVJ422P:
183  case AV_PIX_FMT_YUVJ440P:
184  case AV_PIX_FMT_YUVJ444P:
185  case AV_PIX_FMT_YUVA420P:
186  case AV_PIX_FMT_YUVA422P:
187  case AV_PIX_FMT_YUVA444P:
244  case AV_PIX_FMT_GBRP9LE:
245  case AV_PIX_FMT_GBRP9BE:
246  case AV_PIX_FMT_GBRP10LE:
247  case AV_PIX_FMT_GBRP10BE:
248  case AV_PIX_FMT_GBRP12LE:
249  case AV_PIX_FMT_GBRP12BE:
250  case AV_PIX_FMT_GBRP14LE:
251  case AV_PIX_FMT_GBRP14BE:
252  case AV_PIX_FMT_GBRP16LE:
253  case AV_PIX_FMT_GBRP16BE:
258  w_align = 16; //FIXME assume 16 pixel per macroblock
259  h_align = 16 * 2; // interlaced needs 2 macroblocks height
260  break;
261  case AV_PIX_FMT_YUV411P:
262  case AV_PIX_FMT_YUVJ411P:
264  w_align = 32;
265  h_align = 16 * 2;
266  break;
267  case AV_PIX_FMT_YUV410P:
268  if (s->codec_id == AV_CODEC_ID_SVQ1) {
269  w_align = 64;
270  h_align = 64;
271  }
272  break;
273  case AV_PIX_FMT_RGB555:
274  if (s->codec_id == AV_CODEC_ID_RPZA) {
275  w_align = 4;
276  h_align = 4;
277  }
279  w_align = 8;
280  h_align = 8;
281  }
282  break;
283  case AV_PIX_FMT_PAL8:
284  case AV_PIX_FMT_BGR8:
285  case AV_PIX_FMT_RGB8:
286  if (s->codec_id == AV_CODEC_ID_SMC ||
288  w_align = 4;
289  h_align = 4;
290  }
291  if (s->codec_id == AV_CODEC_ID_JV ||
293  w_align = 8;
294  h_align = 8;
295  }
296  break;
297  case AV_PIX_FMT_BGR24:
298  if ((s->codec_id == AV_CODEC_ID_MSZH) ||
299  (s->codec_id == AV_CODEC_ID_ZLIB)) {
300  w_align = 4;
301  h_align = 4;
302  }
303  break;
304  case AV_PIX_FMT_RGB24:
305  if (s->codec_id == AV_CODEC_ID_CINEPAK) {
306  w_align = 4;
307  h_align = 4;
308  }
309  break;
310  default:
311  break;
312  }
313 
314  if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
315  w_align = FFMAX(w_align, 8);
316  }
317 
318  *width = FFALIGN(*width, w_align);
319  *height = FFALIGN(*height, h_align);
320  if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
323  ) {
324  // some of the optimized chroma MC reads one line too much
325  // which is also done in mpeg decoders with lowres > 0
326  *height += 2;
327 
328  // H.264 uses edge emulation for out of frame motion vectors, for this
329  // it requires a temporary area large enough to hold a 21x21 block,
330  // increasing witdth ensure that the temporary area is large enough,
331  // the next rounded up width is 32
332  *width = FFMAX(*width, 32);
333  }
334 
335  for (i = 0; i < 4; i++)
336  linesize_align[i] = STRIDE_ALIGN;
337 }
338 
340 {
342  int chroma_shift = desc->log2_chroma_w;
343  int linesize_align[AV_NUM_DATA_POINTERS];
344  int align;
345 
346  avcodec_align_dimensions2(s, width, height, linesize_align);
347  align = FFMAX(linesize_align[0], linesize_align[3]);
348  linesize_align[1] <<= chroma_shift;
349  linesize_align[2] <<= chroma_shift;
350  align = FFMAX3(align, linesize_align[1], linesize_align[2]);
351  *width = FFALIGN(*width, align);
352 }
353 
354 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
355 {
356  if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
357  return AVERROR(EINVAL);
358  pos--;
359 
360  *xpos = (pos&1) * 128;
361  *ypos = ((pos>>1)^(pos<4)) * 128;
362 
363  return 0;
364 }
365 
367 {
368  int pos, xout, yout;
369 
370  for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
371  if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
372  return pos;
373  }
375 }
376 
378  enum AVSampleFormat sample_fmt, const uint8_t *buf,
379  int buf_size, int align)
380 {
381  int ch, planar, needed_size, ret = 0;
382 
383  needed_size = av_samples_get_buffer_size(NULL, nb_channels,
384  frame->nb_samples, sample_fmt,
385  align);
386  if (buf_size < needed_size)
387  return AVERROR(EINVAL);
388 
389  planar = av_sample_fmt_is_planar(sample_fmt);
390  if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
391  if (!(frame->extended_data = av_mallocz_array(nb_channels,
392  sizeof(*frame->extended_data))))
393  return AVERROR(ENOMEM);
394  } else {
395  frame->extended_data = frame->data;
396  }
397 
398  if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
399  (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
400  sample_fmt, align)) < 0) {
401  if (frame->extended_data != frame->data)
402  av_freep(&frame->extended_data);
403  return ret;
404  }
405  if (frame->extended_data != frame->data) {
406  for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
407  frame->data[ch] = frame->extended_data[ch];
408  }
409 
410  return ret;
411 }
412 
413 void ff_color_frame(AVFrame *frame, const int c[4])
414 {
416  int p, y;
417 
419 
420  for (p = 0; p<desc->nb_components; p++) {
421  uint8_t *dst = frame->data[p];
422  int is_chroma = p == 1 || p == 2;
423  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
424  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
425  if (desc->comp[0].depth >= 9) {
426  ((uint16_t*)dst)[0] = c[p];
427  av_memcpy_backptr(dst + 2, 2, bytes - 2);
428  dst += frame->linesize[p];
429  for (y = 1; y < height; y++) {
430  memcpy(dst, frame->data[p], 2*bytes);
431  dst += frame->linesize[p];
432  }
433  } else {
434  for (y = 0; y < height; y++) {
435  memset(dst, c[p], bytes);
436  dst += frame->linesize[p];
437  }
438  }
439  }
440 }
441 
442 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
443 {
444  int i;
445 
446  for (i = 0; i < count; i++) {
447  int r = func(c, (char *)arg + i * size);
448  if (ret)
449  ret[i] = r;
450  }
451  emms_c();
452  return 0;
453 }
454 
455 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
456 {
457  int i;
458 
459  for (i = 0; i < count; i++) {
460  int r = func(c, arg, i, 0);
461  if (ret)
462  ret[i] = r;
463  }
464  emms_c();
465  return 0;
466 }
467 
469  unsigned int fourcc)
470 {
471  while (tags->pix_fmt >= 0) {
472  if (tags->fourcc == fourcc)
473  return tags->pix_fmt;
474  tags++;
475  }
476  return AV_PIX_FMT_NONE;
477 }
478 
479 #if FF_API_CODEC_GET_SET
480 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
481 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
483 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
484 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
485 
487 {
488  return codec->properties;
489 }
490 
492 {
493  return codec->max_lowres;
494 }
495 #endif
496 
499 }
500 
502 {
503  int64_t bit_rate;
504  int bits_per_sample;
505 
506  switch (ctx->codec_type) {
507  case AVMEDIA_TYPE_VIDEO:
508  case AVMEDIA_TYPE_DATA:
511  bit_rate = ctx->bit_rate;
512  break;
513  case AVMEDIA_TYPE_AUDIO:
514  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
515  bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
516  break;
517  default:
518  bit_rate = 0;
519  break;
520  }
521  return bit_rate;
522 }
523 
524 
525 static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
526 {
527  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
529 }
530 
531 static void ff_unlock_avcodec(const AVCodec *codec)
532 {
533  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
535 }
536 
537 int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
538 {
539  int ret = 0;
540 
541  ff_unlock_avcodec(codec);
542 
543  ret = avcodec_open2(avctx, codec, options);
544 
545  ff_lock_avcodec(avctx, codec);
546  return ret;
547 }
548 
549 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
550 {
551  int ret = 0;
552  int codec_init_ok = 0;
553  AVDictionary *tmp = NULL;
554  const AVPixFmtDescriptor *pixdesc;
555  AVCodecInternal *avci;
556 
557  if (avcodec_is_open(avctx))
558  return 0;
559 
560  if (!codec && !avctx->codec) {
561  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
562  return AVERROR(EINVAL);
563  }
564  if (codec && avctx->codec && codec != avctx->codec) {
565  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
566  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
567  return AVERROR(EINVAL);
568  }
569  if (!codec)
570  codec = avctx->codec;
571 
572  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
573  return AVERROR(EINVAL);
574 
575  if (options)
576  av_dict_copy(&tmp, *options, 0);
577 
578  ff_lock_avcodec(avctx, codec);
579 
580  avci = av_mallocz(sizeof(*avci));
581  if (!avci) {
582  ret = AVERROR(ENOMEM);
583  goto end;
584  }
585  avctx->internal = avci;
586 
587  avci->to_free = av_frame_alloc();
590  avci->buffer_frame = av_frame_alloc();
591  avci->buffer_pkt = av_packet_alloc();
592  avci->es.in_frame = av_frame_alloc();
593  avci->ds.in_pkt = av_packet_alloc();
595  if (!avci->compat_decode_frame || !avci->compat_encode_packet ||
596  !avci->buffer_frame || !avci->buffer_pkt ||
597  !avci->es.in_frame || !avci->ds.in_pkt ||
598  !avci->to_free || !avci->last_pkt_props) {
599  ret = AVERROR(ENOMEM);
600  goto free_and_end;
601  }
602 
603  avci->skip_samples_multiplier = 1;
604 
605  if (codec->priv_data_size > 0) {
606  if (!avctx->priv_data) {
607  avctx->priv_data = av_mallocz(codec->priv_data_size);
608  if (!avctx->priv_data) {
609  ret = AVERROR(ENOMEM);
610  goto end;
611  }
612  if (codec->priv_class) {
613  *(const AVClass **)avctx->priv_data = codec->priv_class;
615  }
616  }
617  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
618  goto free_and_end;
619  } else {
620  avctx->priv_data = NULL;
621  }
622  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
623  goto free_and_end;
624 
625  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
626  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
627  ret = AVERROR(EINVAL);
628  goto free_and_end;
629  }
630 
631  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
632  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
633  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
634  if (avctx->coded_width && avctx->coded_height)
635  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
636  else if (avctx->width && avctx->height)
637  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
638  if (ret < 0)
639  goto free_and_end;
640  }
641 
642  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
643  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
644  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
645  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
646  ff_set_dimensions(avctx, 0, 0);
647  }
648 
649  if (avctx->width > 0 && avctx->height > 0) {
650  if (av_image_check_sar(avctx->width, avctx->height,
651  avctx->sample_aspect_ratio) < 0) {
652  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
653  avctx->sample_aspect_ratio.num,
654  avctx->sample_aspect_ratio.den);
655  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
656  }
657  }
658 
659  /* if the decoder init function was already called previously,
660  * free the already allocated subtitle_header before overwriting it */
661  if (av_codec_is_decoder(codec))
662  av_freep(&avctx->subtitle_header);
663 
664  if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
665  av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
666  ret = AVERROR(EINVAL);
667  goto free_and_end;
668  }
669  if (avctx->sample_rate < 0) {
670  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
671  ret = AVERROR(EINVAL);
672  goto free_and_end;
673  }
674  if (avctx->block_align < 0) {
675  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
676  ret = AVERROR(EINVAL);
677  goto free_and_end;
678  }
679 
680  avctx->codec = codec;
681  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
682  avctx->codec_id == AV_CODEC_ID_NONE) {
683  avctx->codec_type = codec->type;
684  avctx->codec_id = codec->id;
685  }
686  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
687  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
688  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
689  ret = AVERROR(EINVAL);
690  goto free_and_end;
691  }
692  avctx->frame_number = 0;
694 
695  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
697  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
698  AVCodec *codec2;
699  av_log(avctx, AV_LOG_ERROR,
700  "The %s '%s' is experimental but experimental codecs are not enabled, "
701  "add '-strict %d' if you want to use it.\n",
702  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
703  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
704  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
705  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
706  codec_string, codec2->name);
707  ret = AVERROR_EXPERIMENTAL;
708  goto free_and_end;
709  }
710 
711  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
712  (!avctx->time_base.num || !avctx->time_base.den)) {
713  avctx->time_base.num = 1;
714  avctx->time_base.den = avctx->sample_rate;
715  }
716 
717  if (!HAVE_THREADS)
718  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
719 
720  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
721  ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
722  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
723  ff_lock_avcodec(avctx, codec);
724  if (ret < 0)
725  goto free_and_end;
726  }
727 
728  if (av_codec_is_decoder(avctx->codec)) {
729  ret = ff_decode_bsfs_init(avctx);
730  if (ret < 0)
731  goto free_and_end;
732  }
733 
734  if (HAVE_THREADS
735  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
736  ret = ff_thread_init(avctx);
737  if (ret < 0) {
738  goto free_and_end;
739  }
740  }
741  if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
742  avctx->thread_count = 1;
743 
744  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
745  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
746  avctx->codec->max_lowres);
747  avctx->lowres = avctx->codec->max_lowres;
748  }
749 
750  if (av_codec_is_encoder(avctx->codec)) {
751  int i;
752 #if FF_API_CODED_FRAME
754  avctx->coded_frame = av_frame_alloc();
755  if (!avctx->coded_frame) {
756  ret = AVERROR(ENOMEM);
757  goto free_and_end;
758  }
760 #endif
761 
762  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
763  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
764  ret = AVERROR(EINVAL);
765  goto free_and_end;
766  }
767 
768  if (avctx->codec->sample_fmts) {
769  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
770  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
771  break;
772  if (avctx->channels == 1 &&
775  avctx->sample_fmt = avctx->codec->sample_fmts[i];
776  break;
777  }
778  }
779  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
780  char buf[128];
781  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
782  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
783  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
784  ret = AVERROR(EINVAL);
785  goto free_and_end;
786  }
787  }
788  if (avctx->codec->pix_fmts) {
789  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
790  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
791  break;
792  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
793  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
795  char buf[128];
796  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
797  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
798  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
799  ret = AVERROR(EINVAL);
800  goto free_and_end;
801  }
802  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
803  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
804  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
805  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
806  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
807  avctx->color_range = AVCOL_RANGE_JPEG;
808  }
809  if (avctx->codec->supported_samplerates) {
810  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
811  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
812  break;
813  if (avctx->codec->supported_samplerates[i] == 0) {
814  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
815  avctx->sample_rate);
816  ret = AVERROR(EINVAL);
817  goto free_and_end;
818  }
819  }
820  if (avctx->sample_rate < 0) {
821  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
822  avctx->sample_rate);
823  ret = AVERROR(EINVAL);
824  goto free_and_end;
825  }
826  if (avctx->codec->channel_layouts) {
827  if (!avctx->channel_layout) {
828  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
829  } else {
830  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
831  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
832  break;
833  if (avctx->codec->channel_layouts[i] == 0) {
834  char buf[512];
835  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
836  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
837  ret = AVERROR(EINVAL);
838  goto free_and_end;
839  }
840  }
841  }
842  if (avctx->channel_layout && avctx->channels) {
844  if (channels != avctx->channels) {
845  char buf[512];
846  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
847  av_log(avctx, AV_LOG_ERROR,
848  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
849  buf, channels, avctx->channels);
850  ret = AVERROR(EINVAL);
851  goto free_and_end;
852  }
853  } else if (avctx->channel_layout) {
855  }
856  if (avctx->channels < 0) {
857  av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
858  avctx->channels);
859  ret = AVERROR(EINVAL);
860  goto free_and_end;
861  }
862  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
863  pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
864  if ( avctx->bits_per_raw_sample < 0
865  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
866  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
867  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
868  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
869  }
870  if (avctx->width <= 0 || avctx->height <= 0) {
871  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
872  ret = AVERROR(EINVAL);
873  goto free_and_end;
874  }
875  }
876  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
877  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
878  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
879  }
880 
881  if (!avctx->rc_initial_buffer_occupancy)
882  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
883 
884  if (avctx->ticks_per_frame && avctx->time_base.num &&
885  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
886  av_log(avctx, AV_LOG_ERROR,
887  "ticks_per_frame %d too large for the timebase %d/%d.",
888  avctx->ticks_per_frame,
889  avctx->time_base.num,
890  avctx->time_base.den);
891  goto free_and_end;
892  }
893 
894  if (avctx->hw_frames_ctx) {
895  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
896  if (frames_ctx->format != avctx->pix_fmt) {
897  av_log(avctx, AV_LOG_ERROR,
898  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
899  ret = AVERROR(EINVAL);
900  goto free_and_end;
901  }
902  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
903  avctx->sw_pix_fmt != frames_ctx->sw_format) {
904  av_log(avctx, AV_LOG_ERROR,
905  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
906  "and AVHWFramesContext.sw_format (%s)\n",
908  av_get_pix_fmt_name(frames_ctx->sw_format));
909  ret = AVERROR(EINVAL);
910  goto free_and_end;
911  }
912  avctx->sw_pix_fmt = frames_ctx->sw_format;
913  }
914  }
915 
918  avctx->pts_correction_last_pts =
919  avctx->pts_correction_last_dts = INT64_MIN;
920 
921  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
923  av_log(avctx, AV_LOG_WARNING,
924  "gray decoding requested but not enabled at configuration time\n");
925  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
927  }
928 
929  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
930  || avci->frame_thread_encoder)) {
931  ret = avctx->codec->init(avctx);
932  if (ret < 0) {
933  goto free_and_end;
934  }
935  codec_init_ok = 1;
936  }
937 
938  ret=0;
939 
940  if (av_codec_is_decoder(avctx->codec)) {
941  if (!avctx->bit_rate)
942  avctx->bit_rate = get_bit_rate(avctx);
943  /* validate channel layout from the decoder */
944  if (avctx->channel_layout) {
946  if (!avctx->channels)
947  avctx->channels = channels;
948  else if (channels != avctx->channels) {
949  char buf[512];
950  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
951  av_log(avctx, AV_LOG_WARNING,
952  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
953  "ignoring specified channel layout\n",
954  buf, channels, avctx->channels);
955  avctx->channel_layout = 0;
956  }
957  }
958  if (avctx->channels && avctx->channels < 0 ||
959  avctx->channels > FF_SANE_NB_CHANNELS) {
960  ret = AVERROR(EINVAL);
961  goto free_and_end;
962  }
963  if (avctx->bits_per_coded_sample < 0) {
964  ret = AVERROR(EINVAL);
965  goto free_and_end;
966  }
967  if (avctx->sub_charenc) {
968  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
969  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
970  "supported with subtitles codecs\n");
971  ret = AVERROR(EINVAL);
972  goto free_and_end;
973  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
974  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
975  "subtitles character encoding will be ignored\n",
976  avctx->codec_descriptor->name);
978  } else {
979  /* input character encoding is set for a text based subtitle
980  * codec at this point */
983 
985 #if CONFIG_ICONV
986  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
987  if (cd == (iconv_t)-1) {
988  ret = AVERROR(errno);
989  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
990  "with input character encoding \"%s\"\n", avctx->sub_charenc);
991  goto free_and_end;
992  }
993  iconv_close(cd);
994 #else
995  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
996  "conversion needs a libavcodec built with iconv support "
997  "for this codec\n");
998  ret = AVERROR(ENOSYS);
999  goto free_and_end;
1000 #endif
1001  }
1002  }
1003  }
1004 
1005 #if FF_API_AVCTX_TIMEBASE
1006  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1007  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1008 #endif
1009  }
1010  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1011  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1012  }
1013 
1014 end:
1015  ff_unlock_avcodec(codec);
1016  if (options) {
1017  av_dict_free(options);
1018  *options = tmp;
1019  }
1020 
1021  return ret;
1022 free_and_end:
1023  if (avctx->codec && avctx->codec->close &&
1024  (codec_init_ok ||
1026  avctx->codec->close(avctx);
1027 
1028  if (HAVE_THREADS && avci->thread_ctx)
1029  ff_thread_free(avctx);
1030 
1031  if (codec->priv_class && codec->priv_data_size)
1032  av_opt_free(avctx->priv_data);
1033  av_opt_free(avctx);
1034 
1035 #if FF_API_CODED_FRAME
1037  av_frame_free(&avctx->coded_frame);
1039 #endif
1040 
1041  av_dict_free(&tmp);
1042  av_freep(&avctx->priv_data);
1043  av_freep(&avctx->subtitle_header);
1044  if (avci) {
1045  av_frame_free(&avci->to_free);
1047  av_frame_free(&avci->buffer_frame);
1049  av_packet_free(&avci->buffer_pkt);
1051 
1052  av_packet_free(&avci->ds.in_pkt);
1053  av_frame_free(&avci->es.in_frame);
1054  av_bsf_free(&avci->bsf);
1055 
1056  av_buffer_unref(&avci->pool);
1057  }
1058  av_freep(&avci);
1059  avctx->internal = NULL;
1060  avctx->codec = NULL;
1061  goto end;
1062 }
1063 
1065 {
1066  AVCodecInternal *avci = avctx->internal;
1067 
1068  if (av_codec_is_encoder(avctx->codec)) {
1069  int caps = avctx->codec->capabilities;
1070 
1071  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
1072  // Only encoders that explicitly declare support for it can be
1073  // flushed. Otherwise, this is a no-op.
1074  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
1075  "that doesn't support it\n");
1076  return;
1077  }
1078 
1079  // We haven't implemented flushing for frame-threaded encoders.
1081  }
1082 
1083  avci->draining = 0;
1084  avci->draining_done = 0;
1085  avci->nb_draining_errors = 0;
1089  av_packet_unref(avci->buffer_pkt);
1090 
1091  av_frame_unref(avci->es.in_frame);
1092  av_packet_unref(avci->ds.in_pkt);
1093 
1094  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1095  ff_thread_flush(avctx);
1096  else if (avctx->codec->flush)
1097  avctx->codec->flush(avctx);
1098 
1099  avctx->pts_correction_last_pts =
1100  avctx->pts_correction_last_dts = INT64_MIN;
1101 
1102  if (av_codec_is_decoder(avctx->codec))
1103  av_bsf_flush(avci->bsf);
1104 
1105  if (!avctx->refcounted_frames)
1106  av_frame_unref(avci->to_free);
1107 }
1108 
1110 {
1111  int i;
1112 
1113  for (i = 0; i < sub->num_rects; i++) {
1114  av_freep(&sub->rects[i]->data[0]);
1115  av_freep(&sub->rects[i]->data[1]);
1116  av_freep(&sub->rects[i]->data[2]);
1117  av_freep(&sub->rects[i]->data[3]);
1118  av_freep(&sub->rects[i]->text);
1119  av_freep(&sub->rects[i]->ass);
1120  av_freep(&sub->rects[i]);
1121  }
1122 
1123  av_freep(&sub->rects);
1124 
1125  memset(sub, 0, sizeof(*sub));
1126 }
1127 
1129 {
1130  int i;
1131 
1132  if (!avctx)
1133  return 0;
1134 
1135  if (avcodec_is_open(avctx)) {
1136  if (CONFIG_FRAME_THREAD_ENCODER &&
1137  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1139  }
1140  if (HAVE_THREADS && avctx->internal->thread_ctx)
1141  ff_thread_free(avctx);
1142  if (avctx->codec && avctx->codec->close)
1143  avctx->codec->close(avctx);
1144  avctx->internal->byte_buffer_size = 0;
1145  av_freep(&avctx->internal->byte_buffer);
1146  av_frame_free(&avctx->internal->to_free);
1152 
1153  av_packet_free(&avctx->internal->ds.in_pkt);
1154  av_frame_free(&avctx->internal->es.in_frame);
1155 
1156  av_buffer_unref(&avctx->internal->pool);
1157 
1158  if (avctx->hwaccel && avctx->hwaccel->uninit)
1159  avctx->hwaccel->uninit(avctx);
1161 
1162  av_bsf_free(&avctx->internal->bsf);
1163 
1164  av_freep(&avctx->internal);
1165  }
1166 
1167  for (i = 0; i < avctx->nb_coded_side_data; i++)
1168  av_freep(&avctx->coded_side_data[i].data);
1169  av_freep(&avctx->coded_side_data);
1170  avctx->nb_coded_side_data = 0;
1171 
1172  av_buffer_unref(&avctx->hw_frames_ctx);
1173  av_buffer_unref(&avctx->hw_device_ctx);
1174 
1175  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1176  av_opt_free(avctx->priv_data);
1177  av_opt_free(avctx);
1178  av_freep(&avctx->priv_data);
1179  if (av_codec_is_encoder(avctx->codec)) {
1180  av_freep(&avctx->extradata);
1181 #if FF_API_CODED_FRAME
1183  av_frame_free(&avctx->coded_frame);
1185 #endif
1186  }
1187  avctx->codec = NULL;
1188  avctx->active_thread_type = 0;
1189 
1190  return 0;
1191 }
1192 
1193 const char *avcodec_get_name(enum AVCodecID id)
1194 {
1195  const AVCodecDescriptor *cd;
1196  AVCodec *codec;
1197 
1198  if (id == AV_CODEC_ID_NONE)
1199  return "none";
1200  cd = avcodec_descriptor_get(id);
1201  if (cd)
1202  return cd->name;
1203  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1204  codec = avcodec_find_decoder(id);
1205  if (codec)
1206  return codec->name;
1207  codec = avcodec_find_encoder(id);
1208  if (codec)
1209  return codec->name;
1210  return "unknown_codec";
1211 }
1212 
1213 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1214 {
1215  int i, len, ret = 0;
1216 
1217 #define TAG_PRINT(x) \
1218  (((x) >= '0' && (x) <= '9') || \
1219  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
1220  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1221 
1222  for (i = 0; i < 4; i++) {
1223  len = snprintf(buf, buf_size,
1224  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1225  buf += len;
1226  buf_size = buf_size > len ? buf_size - len : 0;
1227  ret += len;
1228  codec_tag >>= 8;
1229  }
1230  return ret;
1231 }
1232 
1233 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1234 {
1235  const char *codec_type;
1236  const char *codec_name;
1237  const char *profile = NULL;
1238  int64_t bitrate;
1239  int new_line = 0;
1240  AVRational display_aspect_ratio;
1241  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1242 
1243  if (!buf || buf_size <= 0)
1244  return;
1245  codec_type = av_get_media_type_string(enc->codec_type);
1246  codec_name = avcodec_get_name(enc->codec_id);
1247  profile = avcodec_profile_name(enc->codec_id, enc->profile);
1248 
1249  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1250  codec_name);
1251  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1252 
1253  if (enc->codec && strcmp(enc->codec->name, codec_name))
1254  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1255 
1256  if (profile)
1257  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1258  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
1260  && enc->refs)
1261  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1262  ", %d reference frame%s",
1263  enc->refs, enc->refs > 1 ? "s" : "");
1264 
1265  if (enc->codec_tag)
1266  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1267  av_fourcc2str(enc->codec_tag), enc->codec_tag);
1268 
1269  switch (enc->codec_type) {
1270  case AVMEDIA_TYPE_VIDEO:
1271  {
1272  char detail[256] = "(";
1273 
1274  av_strlcat(buf, separator, buf_size);
1275 
1276  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1277  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1279  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1281  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1283  av_strlcatf(detail, sizeof(detail), "%s, ",
1285 
1286  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1288  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1289  if (enc->colorspace != (int)enc->color_primaries ||
1290  enc->colorspace != (int)enc->color_trc) {
1291  new_line = 1;
1292  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1296  } else
1297  av_strlcatf(detail, sizeof(detail), "%s, ",
1299  }
1300 
1301  if (enc->field_order != AV_FIELD_UNKNOWN) {
1302  const char *field_order = "progressive";
1303  if (enc->field_order == AV_FIELD_TT)
1304  field_order = "top first";
1305  else if (enc->field_order == AV_FIELD_BB)
1306  field_order = "bottom first";
1307  else if (enc->field_order == AV_FIELD_TB)
1308  field_order = "top coded first (swapped)";
1309  else if (enc->field_order == AV_FIELD_BT)
1310  field_order = "bottom coded first (swapped)";
1311 
1312  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1313  }
1314 
1315  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1317  av_strlcatf(detail, sizeof(detail), "%s, ",
1319 
1320  if (strlen(detail) > 1) {
1321  detail[strlen(detail) - 2] = 0;
1322  av_strlcatf(buf, buf_size, "%s)", detail);
1323  }
1324  }
1325 
1326  if (enc->width) {
1327  av_strlcat(buf, new_line ? separator : ", ", buf_size);
1328 
1329  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1330  "%dx%d",
1331  enc->width, enc->height);
1332 
1333  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1334  (enc->width != enc->coded_width ||
1335  enc->height != enc->coded_height))
1336  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1337  " (%dx%d)", enc->coded_width, enc->coded_height);
1338 
1339  if (enc->sample_aspect_ratio.num) {
1340  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1341  enc->width * (int64_t)enc->sample_aspect_ratio.num,
1342  enc->height * (int64_t)enc->sample_aspect_ratio.den,
1343  1024 * 1024);
1344  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1345  " [SAR %d:%d DAR %d:%d]",
1347  display_aspect_ratio.num, display_aspect_ratio.den);
1348  }
1349  if (av_log_get_level() >= AV_LOG_DEBUG) {
1350  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1351  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1352  ", %d/%d",
1353  enc->time_base.num / g, enc->time_base.den / g);
1354  }
1355  }
1356  if (encode) {
1357  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1358  ", q=%d-%d", enc->qmin, enc->qmax);
1359  } else {
1361  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1362  ", Closed Captions");
1364  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1365  ", lossless");
1366  }
1367  break;
1368  case AVMEDIA_TYPE_AUDIO:
1369  av_strlcat(buf, separator, buf_size);
1370 
1371  if (enc->sample_rate) {
1372  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1373  "%d Hz, ", enc->sample_rate);
1374  }
1375  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1376  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1377  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1378  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1379  }
1380  if ( enc->bits_per_raw_sample > 0
1382  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1383  " (%d bit)", enc->bits_per_raw_sample);
1384  if (av_log_get_level() >= AV_LOG_VERBOSE) {
1385  if (enc->initial_padding)
1386  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1387  ", delay %d", enc->initial_padding);
1388  if (enc->trailing_padding)
1389  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1390  ", padding %d", enc->trailing_padding);
1391  }
1392  break;
1393  case AVMEDIA_TYPE_DATA:
1394  if (av_log_get_level() >= AV_LOG_DEBUG) {
1395  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1396  if (g)
1397  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1398  ", %d/%d",
1399  enc->time_base.num / g, enc->time_base.den / g);
1400  }
1401  break;
1402  case AVMEDIA_TYPE_SUBTITLE:
1403  if (enc->width)
1404  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1405  ", %dx%d", enc->width, enc->height);
1406  break;
1407  default:
1408  return;
1409  }
1410  if (encode) {
1411  if (enc->flags & AV_CODEC_FLAG_PASS1)
1412  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1413  ", pass 1");
1414  if (enc->flags & AV_CODEC_FLAG_PASS2)
1415  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1416  ", pass 2");
1417  }
1418  bitrate = get_bit_rate(enc);
1419  if (bitrate != 0) {
1420  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1421  ", %"PRId64" kb/s", bitrate / 1000);
1422  } else if (enc->rc_max_rate > 0) {
1423  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1424  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
1425  }
1426 }
1427 
1428 const char *av_get_profile_name(const AVCodec *codec, int profile)
1429 {
1430  const AVProfile *p;
1431  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1432  return NULL;
1433 
1434  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1435  if (p->profile == profile)
1436  return p->name;
1437 
1438  return NULL;
1439 }
1440 
1442 {
1443  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
1444  const AVProfile *p;
1445 
1446  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1447  return NULL;
1448 
1449  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1450  if (p->profile == profile)
1451  return p->name;
1452 
1453  return NULL;
1454 }
1455 
1456 unsigned avcodec_version(void)
1457 {
1460  av_assert0(AV_CODEC_ID_SRT==94216);
1462 
1463  return LIBAVCODEC_VERSION_INT;
1464 }
1465 
1466 const char *avcodec_configuration(void)
1467 {
1468  return FFMPEG_CONFIGURATION;
1469 }
1470 
1471 const char *avcodec_license(void)
1472 {
1473 #define LICENSE_PREFIX "libavcodec license: "
1474  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
1475 }
1476 
1478 {
1479  switch (codec_id) {
1480  case AV_CODEC_ID_8SVX_EXP:
1481  case AV_CODEC_ID_8SVX_FIB:
1482  case AV_CODEC_ID_ADPCM_CT:
1492  return 4;
1493  case AV_CODEC_ID_DSD_LSBF:
1494  case AV_CODEC_ID_DSD_MSBF:
1497  case AV_CODEC_ID_PCM_ALAW:
1498  case AV_CODEC_ID_PCM_MULAW:
1499  case AV_CODEC_ID_PCM_VIDC:
1500  case AV_CODEC_ID_PCM_S8:
1502  case AV_CODEC_ID_PCM_U8:
1503  case AV_CODEC_ID_SDX2_DPCM:
1504  case AV_CODEC_ID_DERF_DPCM:
1505  return 8;
1506  case AV_CODEC_ID_PCM_S16BE:
1508  case AV_CODEC_ID_PCM_S16LE:
1510  case AV_CODEC_ID_PCM_U16BE:
1511  case AV_CODEC_ID_PCM_U16LE:
1512  return 16;
1514  case AV_CODEC_ID_PCM_S24BE:
1515  case AV_CODEC_ID_PCM_S24LE:
1517  case AV_CODEC_ID_PCM_U24BE:
1518  case AV_CODEC_ID_PCM_U24LE:
1519  return 24;
1520  case AV_CODEC_ID_PCM_S32BE:
1521  case AV_CODEC_ID_PCM_S32LE:
1523  case AV_CODEC_ID_PCM_U32BE:
1524  case AV_CODEC_ID_PCM_U32LE:
1525  case AV_CODEC_ID_PCM_F32BE:
1526  case AV_CODEC_ID_PCM_F32LE:
1527  case AV_CODEC_ID_PCM_F24LE:
1528  case AV_CODEC_ID_PCM_F16LE:
1529  return 32;
1530  case AV_CODEC_ID_PCM_F64BE:
1531  case AV_CODEC_ID_PCM_F64LE:
1532  case AV_CODEC_ID_PCM_S64BE:
1533  case AV_CODEC_ID_PCM_S64LE:
1534  return 64;
1535  default:
1536  return 0;
1537  }
1538 }
1539 
1541 {
1542  static const enum AVCodecID map[][2] = {
1548  [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
1549  [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
1550  [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
1552  [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
1553  [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
1554  };
1555  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
1556  return AV_CODEC_ID_NONE;
1557  if (be < 0 || be > 1)
1558  be = AV_NE(1, 0);
1559  return map[fmt][be];
1560 }
1561 
1563 {
1564  switch (codec_id) {
1566  return 2;
1568  return 3;
1572  case AV_CODEC_ID_ADPCM_SWF:
1573  case AV_CODEC_ID_ADPCM_MS:
1574  return 4;
1575  default:
1576  return av_get_exact_bits_per_sample(codec_id);
1577  }
1578 }
1579 
1580 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1581  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
1582  uint8_t * extradata, int frame_size, int frame_bytes)
1583 {
1585  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
1586 
1587  /* codecs with an exact constant bits per sample */
1588  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
1589  return (frame_bytes * 8LL) / (bps * ch);
1590  bps = bits_per_coded_sample;
1591 
1592  /* codecs with a fixed packet duration */
1593  switch (id) {
1594  case AV_CODEC_ID_ADPCM_ADX: return 32;
1595  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
1596  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
1597  case AV_CODEC_ID_AMR_NB:
1598  case AV_CODEC_ID_EVRC:
1599  case AV_CODEC_ID_GSM:
1600  case AV_CODEC_ID_QCELP:
1601  case AV_CODEC_ID_RA_288: return 160;
1602  case AV_CODEC_ID_AMR_WB:
1603  case AV_CODEC_ID_GSM_MS: return 320;
1604  case AV_CODEC_ID_MP1: return 384;
1605  case AV_CODEC_ID_ATRAC1: return 512;
1606  case AV_CODEC_ID_ATRAC9:
1607  case AV_CODEC_ID_ATRAC3: return 1024 * framecount;
1608  case AV_CODEC_ID_ATRAC3P: return 2048;
1609  case AV_CODEC_ID_MP2:
1610  case AV_CODEC_ID_MUSEPACK7: return 1152;
1611  case AV_CODEC_ID_AC3: return 1536;
1612  }
1613 
1614  if (sr > 0) {
1615  /* calc from sample rate */
1616  if (id == AV_CODEC_ID_TTA)
1617  return 256 * sr / 245;
1618  else if (id == AV_CODEC_ID_DST)
1619  return 588 * sr / 44100;
1620 
1621  if (ch > 0) {
1622  /* calc from sample rate and channels */
1623  if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1624  return (480 << (sr / 22050)) / ch;
1625  }
1626 
1627  if (id == AV_CODEC_ID_MP3)
1628  return sr <= 24000 ? 576 : 1152;
1629  }
1630 
1631  if (ba > 0) {
1632  /* calc from block_align */
1633  if (id == AV_CODEC_ID_SIPR) {
1634  switch (ba) {
1635  case 20: return 160;
1636  case 19: return 144;
1637  case 29: return 288;
1638  case 37: return 480;
1639  }
1640  } else if (id == AV_CODEC_ID_ILBC) {
1641  switch (ba) {
1642  case 38: return 160;
1643  case 50: return 240;
1644  }
1645  }
1646  }
1647 
1648  if (frame_bytes > 0) {
1649  /* calc from frame_bytes only */
1650  if (id == AV_CODEC_ID_TRUESPEECH)
1651  return 240 * (frame_bytes / 32);
1652  if (id == AV_CODEC_ID_NELLYMOSER)
1653  return 256 * (frame_bytes / 64);
1654  if (id == AV_CODEC_ID_RA_144)
1655  return 160 * (frame_bytes / 20);
1656 
1657  if (bps > 0) {
1658  /* calc from frame_bytes and bits_per_coded_sample */
1660  return frame_bytes * 8 / bps;
1661  }
1662 
1663  if (ch > 0 && ch < INT_MAX/16) {
1664  /* calc from frame_bytes and channels */
1665  switch (id) {
1666  case AV_CODEC_ID_ADPCM_AFC:
1667  return frame_bytes / (9 * ch) * 16;
1668  case AV_CODEC_ID_ADPCM_PSX:
1669  case AV_CODEC_ID_ADPCM_DTK:
1670  return frame_bytes / (16 * ch) * 28;
1671  case AV_CODEC_ID_ADPCM_4XM:
1674  return (frame_bytes - 4 * ch) * 2 / ch;
1676  return (frame_bytes - 4) * 2 / ch;
1678  return (frame_bytes - 8) * 2 / ch;
1679  case AV_CODEC_ID_ADPCM_THP:
1681  if (extradata)
1682  return frame_bytes * 14 / (8 * ch);
1683  break;
1684  case AV_CODEC_ID_ADPCM_XA:
1685  return (frame_bytes / 128) * 224 / ch;
1687  return (frame_bytes - 6 - ch) / ch;
1688  case AV_CODEC_ID_ROQ_DPCM:
1689  return (frame_bytes - 8) / ch;
1690  case AV_CODEC_ID_XAN_DPCM:
1691  return (frame_bytes - 2 * ch) / ch;
1692  case AV_CODEC_ID_MACE3:
1693  return 3 * frame_bytes / ch;
1694  case AV_CODEC_ID_MACE6:
1695  return 6 * frame_bytes / ch;
1696  case AV_CODEC_ID_PCM_LXF:
1697  return 2 * (frame_bytes / (5 * ch));
1698  case AV_CODEC_ID_IAC:
1699  case AV_CODEC_ID_IMC:
1700  return 4 * frame_bytes / ch;
1701  }
1702 
1703  if (tag) {
1704  /* calc from frame_bytes, channels, and codec_tag */
1705  if (id == AV_CODEC_ID_SOL_DPCM) {
1706  if (tag == 3)
1707  return frame_bytes / ch;
1708  else
1709  return frame_bytes * 2 / ch;
1710  }
1711  }
1712 
1713  if (ba > 0) {
1714  /* calc from frame_bytes, channels, and block_align */
1715  int blocks = frame_bytes / ba;
1716  switch (id) {
1718  if (bps < 2 || bps > 5)
1719  return 0;
1720  return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
1722  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1724  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1726  return blocks * ((ba - 4 * ch) * 2 / ch);
1727  case AV_CODEC_ID_ADPCM_MS:
1728  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1730  return blocks * (ba - 16) * 2 / ch;
1731  }
1732  }
1733 
1734  if (bps > 0) {
1735  /* calc from frame_bytes, channels, and bits_per_coded_sample */
1736  switch (id) {
1737  case AV_CODEC_ID_PCM_DVD:
1738  if(bps<4 || frame_bytes<3)
1739  return 0;
1740  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
1742  if(bps<4 || frame_bytes<4)
1743  return 0;
1744  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
1745  case AV_CODEC_ID_S302M:
1746  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1747  }
1748  }
1749  }
1750  }
1751 
1752  /* Fall back on using frame_size */
1753  if (frame_size > 1 && frame_bytes)
1754  return frame_size;
1755 
1756  //For WMA we currently have no other means to calculate duration thus we
1757  //do it here by assuming CBR, which is true for all known cases.
1758  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
1759  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
1760  return (frame_bytes * 8LL * sr) / bitrate;
1761  }
1762 
1763  return 0;
1764 }
1765 
1766 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1767 {
1768  return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1769  avctx->channels, avctx->block_align,
1770  avctx->codec_tag, avctx->bits_per_coded_sample,
1771  avctx->bit_rate, avctx->extradata, avctx->frame_size,
1772  frame_bytes);
1773 }
1774 
1776 {
1777  return get_audio_frame_duration(par->codec_id, par->sample_rate,
1778  par->channels, par->block_align,
1779  par->codec_tag, par->bits_per_coded_sample,
1780  par->bit_rate, par->extradata, par->frame_size,
1781  frame_bytes);
1782 }
1783 
1784 #if !HAVE_THREADS
1786 {
1787  return -1;
1788 }
1789 
1790 #endif
1791 
1792 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1793 {
1794  unsigned int n = 0;
1795 
1796  while (v >= 0xff) {
1797  *s++ = 0xff;
1798  v -= 0xff;
1799  n++;
1800  }
1801  *s = v;
1802  n++;
1803  return n;
1804 }
1805 
1806 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1807 {
1808  int i;
1809  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1810  return i;
1811 }
1812 
1814 {
1815  int i;
1816  if (!codec->hw_configs || index < 0)
1817  return NULL;
1818  for (i = 0; i <= index; i++)
1819  if (!codec->hw_configs[i])
1820  return NULL;
1821  return &codec->hw_configs[index]->public;
1822 }
1823 
1824 #if FF_API_USER_VISIBLE_AVHWACCEL
1826 {
1827  return NULL;
1828 }
1829 
1831 {
1832 }
1833 #endif
1834 
1835 #if FF_API_LOCKMGR
1836 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1837 {
1838  return 0;
1839 }
1840 #endif
1841 
1842 unsigned int avpriv_toupper4(unsigned int x)
1843 {
1844  return av_toupper(x & 0xFF) +
1845  (av_toupper((x >> 8) & 0xFF) << 8) +
1846  (av_toupper((x >> 16) & 0xFF) << 16) +
1847 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
1848 }
1849 
1851 {
1852  int ret;
1853 
1854  dst->owner[0] = src->owner[0];
1855  dst->owner[1] = src->owner[1];
1856 
1857  ret = av_frame_ref(dst->f, src->f);
1858  if (ret < 0)
1859  return ret;
1860 
1861  av_assert0(!dst->progress);
1862 
1863  if (src->progress &&
1864  !(dst->progress = av_buffer_ref(src->progress))) {
1865  ff_thread_release_buffer(dst->owner[0], dst);
1866  return AVERROR(ENOMEM);
1867  }
1868 
1869  return 0;
1870 }
1871 
1872 #if !HAVE_THREADS
1873 
1875 {
1876  return ff_get_format(avctx, fmt);
1877 }
1878 
1880 {
1881  f->owner[0] = f->owner[1] = avctx;
1882  return ff_get_buffer(avctx, f->f, flags);
1883 }
1884 
1886 {
1887  if (f->f)
1888  av_frame_unref(f->f);
1889 }
1890 
1892 {
1893 }
1894 
1896 {
1897 }
1898 
1899 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1900 {
1901 }
1902 
1904 {
1905  return 1;
1906 }
1907 
1909 {
1910  return 0;
1911 }
1912 
1914 {
1915 }
1916 
1917 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1918 {
1919 }
1920 
1921 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1922 {
1923 }
1924 
1925 #endif
1926 
1928 {
1929  return !!s->internal;
1930 }
1931 
1932 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
1933 {
1934  int ret;
1935  char *str;
1936 
1937  ret = av_bprint_finalize(buf, &str);
1938  if (ret < 0)
1939  return ret;
1940  if (!av_bprint_is_complete(buf)) {
1941  av_free(str);
1942  return AVERROR(ENOMEM);
1943  }
1944 
1945  avctx->extradata = str;
1946  /* Note: the string is NUL terminated (so extradata can be read as a
1947  * string), but the ending character is not accounted in the size (in
1948  * binary formats you are likely not supposed to mux that character). When
1949  * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
1950  * zeros. */
1951  avctx->extradata_size = buf->len;
1952  return 0;
1953 }
1954 
1955 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
1956  const uint8_t *end,
1957  uint32_t *av_restrict state)
1958 {
1959  int i;
1960 
1961  av_assert0(p <= end);
1962  if (p >= end)
1963  return end;
1964 
1965  for (i = 0; i < 3; i++) {
1966  uint32_t tmp = *state << 8;
1967  *state = tmp + *(p++);
1968  if (tmp == 0x100 || p == end)
1969  return p;
1970  }
1971 
1972  while (p < end) {
1973  if (p[-1] > 1 ) p += 3;
1974  else if (p[-2] ) p += 2;
1975  else if (p[-3]|(p[-1]-1)) p++;
1976  else {
1977  p++;
1978  break;
1979  }
1980  }
1981 
1982  p = FFMIN(p, end) - 4;
1983  *state = AV_RB32(p);
1984 
1985  return p + 4;
1986 }
1987 
1989 {
1990  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1991  if (!props)
1992  return NULL;
1993 
1994  if (size)
1995  *size = sizeof(*props);
1996 
1997  props->vbv_delay = UINT64_MAX;
1998 
1999  return props;
2000 }
2001 
2003 {
2005  AVCPBProperties *props;
2006  size_t size;
2007  int i;
2008 
2009  for (i = 0; i < avctx->nb_coded_side_data; i++)
2011  return (AVCPBProperties *)avctx->coded_side_data[i].data;
2012 
2013  props = av_cpb_properties_alloc(&size);
2014  if (!props)
2015  return NULL;
2016 
2017  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
2018  if (!tmp) {
2019  av_freep(&props);
2020  return NULL;
2021  }
2022 
2023  avctx->coded_side_data = tmp;
2024  avctx->nb_coded_side_data++;
2025 
2027  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
2028  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
2029 
2030  return props;
2031 }
2032 
2034 {
2035  av_freep(&par->extradata);
2036 
2037  memset(par, 0, sizeof(*par));
2038 
2040  par->codec_id = AV_CODEC_ID_NONE;
2041  par->format = -1;
2048  par->sample_aspect_ratio = (AVRational){ 0, 1 };
2049  par->profile = FF_PROFILE_UNKNOWN;
2050  par->level = FF_LEVEL_UNKNOWN;
2051 }
2052 
2054 {
2055  AVCodecParameters *par = av_mallocz(sizeof(*par));
2056 
2057  if (!par)
2058  return NULL;
2060  return par;
2061 }
2062 
2064 {
2065  AVCodecParameters *par = *ppar;
2066 
2067  if (!par)
2068  return;
2070 
2071  av_freep(ppar);
2072 }
2073 
2075 {
2077  memcpy(dst, src, sizeof(*dst));
2078 
2079  dst->extradata = NULL;
2080  dst->extradata_size = 0;
2081  if (src->extradata) {
2083  if (!dst->extradata)
2084  return AVERROR(ENOMEM);
2085  memcpy(dst->extradata, src->extradata, src->extradata_size);
2086  dst->extradata_size = src->extradata_size;
2087  }
2088 
2089  return 0;
2090 }
2091 
2093  const AVCodecContext *codec)
2094 {
2096 
2097  par->codec_type = codec->codec_type;
2098  par->codec_id = codec->codec_id;
2099  par->codec_tag = codec->codec_tag;
2100 
2101  par->bit_rate = codec->bit_rate;
2104  par->profile = codec->profile;
2105  par->level = codec->level;
2106 
2107  switch (par->codec_type) {
2108  case AVMEDIA_TYPE_VIDEO:
2109  par->format = codec->pix_fmt;
2110  par->width = codec->width;
2111  par->height = codec->height;
2112  par->field_order = codec->field_order;
2113  par->color_range = codec->color_range;
2114  par->color_primaries = codec->color_primaries;
2115  par->color_trc = codec->color_trc;
2116  par->color_space = codec->colorspace;
2119  par->video_delay = codec->has_b_frames;
2120  break;
2121  case AVMEDIA_TYPE_AUDIO:
2122  par->format = codec->sample_fmt;
2123  par->channel_layout = codec->channel_layout;
2124  par->channels = codec->channels;
2125  par->sample_rate = codec->sample_rate;
2126  par->block_align = codec->block_align;
2127  par->frame_size = codec->frame_size;
2128  par->initial_padding = codec->initial_padding;
2129  par->trailing_padding = codec->trailing_padding;
2130  par->seek_preroll = codec->seek_preroll;
2131  break;
2132  case AVMEDIA_TYPE_SUBTITLE:
2133  par->width = codec->width;
2134  par->height = codec->height;
2135  break;
2136  }
2137 
2138  if (codec->extradata) {
2140  if (!par->extradata)
2141  return AVERROR(ENOMEM);
2142  memcpy(par->extradata, codec->extradata, codec->extradata_size);
2143  par->extradata_size = codec->extradata_size;
2144  }
2145 
2146  return 0;
2147 }
2148 
2150  const AVCodecParameters *par)
2151 {
2152  codec->codec_type = par->codec_type;
2153  codec->codec_id = par->codec_id;
2154  codec->codec_tag = par->codec_tag;
2155 
2156  codec->bit_rate = par->bit_rate;
2159  codec->profile = par->profile;
2160  codec->level = par->level;
2161 
2162  switch (par->codec_type) {
2163  case AVMEDIA_TYPE_VIDEO:
2164  codec->pix_fmt = par->format;
2165  codec->width = par->width;
2166  codec->height = par->height;
2167  codec->field_order = par->field_order;
2168  codec->color_range = par->color_range;
2169  codec->color_primaries = par->color_primaries;
2170  codec->color_trc = par->color_trc;
2171  codec->colorspace = par->color_space;
2174  codec->has_b_frames = par->video_delay;
2175  break;
2176  case AVMEDIA_TYPE_AUDIO:
2177  codec->sample_fmt = par->format;
2178  codec->channel_layout = par->channel_layout;
2179  codec->channels = par->channels;
2180  codec->sample_rate = par->sample_rate;
2181  codec->block_align = par->block_align;
2182  codec->frame_size = par->frame_size;
2183  codec->delay =
2184  codec->initial_padding = par->initial_padding;
2185  codec->trailing_padding = par->trailing_padding;
2186  codec->seek_preroll = par->seek_preroll;
2187  break;
2188  case AVMEDIA_TYPE_SUBTITLE:
2189  codec->width = par->width;
2190  codec->height = par->height;
2191  break;
2192  }
2193 
2194  if (par->extradata) {
2195  av_freep(&codec->extradata);
2197  if (!codec->extradata)
2198  return AVERROR(ENOMEM);
2199  memcpy(codec->extradata, par->extradata, par->extradata_size);
2200  codec->extradata_size = par->extradata_size;
2201  }
2202 
2203  return 0;
2204 }
2205 
2206 int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
2207  void **data, size_t *sei_size)
2208 {
2209  AVFrameSideData *side_data = NULL;
2210  uint8_t *sei_data;
2211 
2212  if (frame)
2213  side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC);
2214 
2215  if (!side_data) {
2216  *data = NULL;
2217  return 0;
2218  }
2219 
2220  *sei_size = side_data->size + 11;
2221  *data = av_mallocz(*sei_size + prefix_len);
2222  if (!*data)
2223  return AVERROR(ENOMEM);
2224  sei_data = (uint8_t*)*data + prefix_len;
2225 
2226  // country code
2227  sei_data[0] = 181;
2228  sei_data[1] = 0;
2229  sei_data[2] = 49;
2230 
2231  /**
2232  * 'GA94' is standard in North America for ATSC, but hard coding
2233  * this style may not be the right thing to do -- other formats
2234  * do exist. This information is not available in the side_data
2235  * so we are going with this right now.
2236  */
2237  AV_WL32(sei_data + 3, MKTAG('G', 'A', '9', '4'));
2238  sei_data[7] = 3;
2239  sei_data[8] = ((side_data->size/3) & 0x1f) | 0x40;
2240  sei_data[9] = 0;
2241 
2242  memcpy(sei_data + 10, side_data->data, side_data->size);
2243 
2244  sei_data[side_data->size+10] = 255;
2245 
2246  return 0;
2247 }
2248 
2249 static unsigned bcd2uint(uint8_t bcd)
2250 {
2251  unsigned low = bcd & 0xf;
2252  unsigned high = bcd >> 4;
2253  if (low > 9 || high > 9)
2254  return 0;
2255  return low + 10*high;
2256 }
2257 
2258 int ff_alloc_timecode_sei(const AVFrame *frame, size_t prefix_len,
2259  void **data, size_t *sei_size)
2260 {
2261  AVFrameSideData *sd = NULL;
2262  uint8_t *sei_data;
2263  PutBitContext pb;
2264  uint32_t *tc;
2265  int m;
2266 
2267  if (frame)
2269 
2270  if (!sd) {
2271  *data = NULL;
2272  return 0;
2273  }
2274  tc = (uint32_t*)sd->data;
2275  m = tc[0] & 3;
2276 
2277  *sei_size = sizeof(uint32_t) * 4;
2278  *data = av_mallocz(*sei_size + prefix_len);
2279  if (!*data)
2280  return AVERROR(ENOMEM);
2281  sei_data = (uint8_t*)*data + prefix_len;
2282 
2283  init_put_bits(&pb, sei_data, *sei_size);
2284  put_bits(&pb, 2, m); // num_clock_ts
2285 
2286  for (int j = 1; j <= m; j++) {
2287  uint32_t tcsmpte = tc[j];
2288  unsigned hh = bcd2uint(tcsmpte & 0x3f); // 6-bit hours
2289  unsigned mm = bcd2uint(tcsmpte>>8 & 0x7f); // 7-bit minutes
2290  unsigned ss = bcd2uint(tcsmpte>>16 & 0x7f); // 7-bit seconds
2291  unsigned ff = bcd2uint(tcsmpte>>24 & 0x3f); // 6-bit frames
2292  unsigned drop = tcsmpte & 1<<30 && !0; // 1-bit drop if not arbitrary bit
2293 
2294  put_bits(&pb, 1, 1); // clock_timestamp_flag
2295  put_bits(&pb, 1, 1); // units_field_based_flag
2296  put_bits(&pb, 5, 0); // counting_type
2297  put_bits(&pb, 1, 1); // full_timestamp_flag
2298  put_bits(&pb, 1, 0); // discontinuity_flag
2299  put_bits(&pb, 1, drop);
2300  put_bits(&pb, 9, ff);
2301  put_bits(&pb, 6, ss);
2302  put_bits(&pb, 6, mm);
2303  put_bits(&pb, 5, hh);
2304  put_bits(&pb, 5, 0);
2305  }
2306  flush_put_bits(&pb);
2307 
2308  return 0;
2309 }
2310 
2312 {
2313  AVRational framerate = avctx->framerate;
2314  int bits_per_coded_sample = avctx->bits_per_coded_sample;
2315  int64_t bitrate;
2316 
2317  if (!(framerate.num && framerate.den))
2318  framerate = av_inv_q(avctx->time_base);
2319  if (!(framerate.num && framerate.den))
2320  return 0;
2321 
2322  if (!bits_per_coded_sample) {
2324  bits_per_coded_sample = av_get_bits_per_pixel(desc);
2325  }
2326  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
2327  framerate.num / framerate.den;
2328 
2329  return bitrate;
2330 }
2331 
2332 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
2333  const int * array_valid_values, int default_value)
2334 {
2335  int i = 0, ref_val;
2336 
2337  while (1) {
2338  ref_val = array_valid_values[i];
2339  if (ref_val == INT_MAX)
2340  break;
2341  if (val == ref_val)
2342  return val;
2343  i++;
2344  }
2345  /* val is not a valid value */
2346  av_log(ctx, AV_LOG_DEBUG,
2347  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
2348  return default_value;
2349 }
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:2311
#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:195
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:1279
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:501
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:95
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:2074
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:208
#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:1466
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:204
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:525
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:100
const char * avcodec_license(void)
Return the libavcodec license.
Definition: utils.c:1471
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:497
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:71
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:1874
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:1836
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: utils.c:354
#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 / flush internal buffers.
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:105
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:69
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:1917
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:377
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:339
#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:90
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Definition: utils.c:135
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:2053
#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:2149
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:2002
Public header for CRC hash function implementation.
void * frame_thread_encoder
Definition: internal.h:155
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:537
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:1580
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:491
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:2249
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:1806
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:120
#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:1988
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:2033
#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:2063
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:155
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:1830
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
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:1128
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:486
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:1562
#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:2332
#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:1842
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:1927
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:449
AVFrame * buffer_frame
Definition: internal.h:178
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
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:1785
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:412
#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:918
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
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:1775
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
const char av_codec_ffversion[]
Definition: utils.c:67
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:228
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
#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:1477
AVFrame * compat_decode_frame
Definition: internal.h:187
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1921
int width
picture width / height.
Definition: avcodec.h:699
static void ff_unlock_avcodec(const AVCodec *codec)
Definition: utils.c:531
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
static struct @318 state
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:1891
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:468
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:172
#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:1064
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:1428
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
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:2139
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:1825
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:157
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:1540
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:1813
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:192
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:1109
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:1854
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:1792
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:188
#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:231
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:1885
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:2092
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
int ff_alloc_timecode_sei(const AVFrame *frame, 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:2258
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:549
#define snprintf
Definition: snprintf.h:34
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1766
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:923
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:1932
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:413
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:177
int64_t bitrate
Definition: h264_levels.c:131
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c: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:3392
#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:366
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:167
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:83
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:1903
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:1895
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:1193
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:455
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:1233
#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:1213
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
#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:429
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:1456
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:3401
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:153
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:1899
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
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:1850
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:1879
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:1908
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
Definition: utils.c:2206
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:1955
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:1913
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
#define MKTAG(a, b, c, d)
Definition: common.h:406
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:152
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1441
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:442
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
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
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