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  if (bits_per_sample) {
516  bit_rate = ctx->sample_rate * (int64_t)ctx->channels;
517  if (bit_rate > INT64_MAX / bits_per_sample) {
518  bit_rate = 0;
519  } else
520  bit_rate *= bits_per_sample;
521  } else
522  bit_rate = ctx->bit_rate;
523  break;
524  default:
525  bit_rate = 0;
526  break;
527  }
528  return bit_rate;
529 }
530 
531 
532 static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
533 {
534  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
536 }
537 
538 static void ff_unlock_avcodec(const AVCodec *codec)
539 {
540  if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init)
542 }
543 
544 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
545 {
546  int ret = 0;
547  int codec_init_ok = 0;
548  AVDictionary *tmp = NULL;
549  const AVPixFmtDescriptor *pixdesc;
550  AVCodecInternal *avci;
551 
552  if (avcodec_is_open(avctx))
553  return 0;
554 
555  if (!codec && !avctx->codec) {
556  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
557  return AVERROR(EINVAL);
558  }
559  if (codec && avctx->codec && codec != avctx->codec) {
560  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
561  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
562  return AVERROR(EINVAL);
563  }
564  if (!codec)
565  codec = avctx->codec;
566 
567  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
568  return AVERROR(EINVAL);
569 
570  if (options)
571  av_dict_copy(&tmp, *options, 0);
572 
573  ff_lock_avcodec(avctx, codec);
574 
575  avci = av_mallocz(sizeof(*avci));
576  if (!avci) {
577  ret = AVERROR(ENOMEM);
578  goto end;
579  }
580  avctx->internal = avci;
581 
582 #if FF_API_OLD_ENCDEC
583  avci->to_free = av_frame_alloc();
586  if (!avci->to_free || !avci->compat_decode_frame || !avci->compat_encode_packet) {
587  ret = AVERROR(ENOMEM);
588  goto free_and_end;
589  }
590 #endif
591  avci->buffer_frame = av_frame_alloc();
592  avci->buffer_pkt = av_packet_alloc();
593  avci->es.in_frame = av_frame_alloc();
594  avci->ds.in_pkt = av_packet_alloc();
596  avci->pkt_props = av_fifo_alloc(sizeof(*avci->last_pkt_props));
597  if (!avci->buffer_frame || !avci->buffer_pkt ||
598  !avci->es.in_frame || !avci->ds.in_pkt ||
599  !avci->last_pkt_props || !avci->pkt_props) {
600  ret = AVERROR(ENOMEM);
601  goto free_and_end;
602  }
603 
604  avci->skip_samples_multiplier = 1;
605 
606  if (codec->priv_data_size > 0) {
607  if (!avctx->priv_data) {
608  avctx->priv_data = av_mallocz(codec->priv_data_size);
609  if (!avctx->priv_data) {
610  ret = AVERROR(ENOMEM);
611  goto free_and_end;
612  }
613  if (codec->priv_class) {
614  *(const AVClass **)avctx->priv_data = codec->priv_class;
616  }
617  }
618  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
619  goto free_and_end;
620  } else {
621  avctx->priv_data = NULL;
622  }
623  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
624  goto free_and_end;
625 
626  if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
627  av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
628  ret = AVERROR(EINVAL);
629  goto free_and_end;
630  }
631 
632  // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
633  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
634  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
635  if (avctx->coded_width && avctx->coded_height)
636  ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
637  else if (avctx->width && avctx->height)
638  ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
639  if (ret < 0)
640  goto free_and_end;
641  }
642 
643  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
644  && ( av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
645  || av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
646  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
647  ff_set_dimensions(avctx, 0, 0);
648  }
649 
650  if (avctx->width > 0 && avctx->height > 0) {
651  if (av_image_check_sar(avctx->width, avctx->height,
652  avctx->sample_aspect_ratio) < 0) {
653  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
654  avctx->sample_aspect_ratio.num,
655  avctx->sample_aspect_ratio.den);
656  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
657  }
658  }
659 
660  /* if the decoder init function was already called previously,
661  * free the already allocated subtitle_header before overwriting it */
662  if (av_codec_is_decoder(codec))
663  av_freep(&avctx->subtitle_header);
664 
665  if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
666  av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
667  ret = AVERROR(EINVAL);
668  goto free_and_end;
669  }
670  if (av_codec_is_decoder(codec) &&
671  codec->type == AVMEDIA_TYPE_AUDIO &&
673  avctx->channels == 0) {
674  av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
675  ret = AVERROR(EINVAL);
676  goto free_and_end;
677  }
678 
679  if (avctx->sample_rate < 0) {
680  av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
681  ret = AVERROR(EINVAL);
682  goto free_and_end;
683  }
684  if (avctx->block_align < 0) {
685  av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
686  ret = AVERROR(EINVAL);
687  goto free_and_end;
688  }
689 
690 #if FF_API_THREAD_SAFE_CALLBACKS
692  if ((avctx->thread_type & FF_THREAD_FRAME) &&
694  !avctx->thread_safe_callbacks) {
695  av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
696  "custom get_buffer2() implementation which is not marked as "
697  "thread safe. This is not supported anymore, make your "
698  "callback thread-safe.\n");
699  }
701 #endif
702 
703  avctx->codec = codec;
704  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
705  avctx->codec_id == AV_CODEC_ID_NONE) {
706  avctx->codec_type = codec->type;
707  avctx->codec_id = codec->id;
708  }
709  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
710  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
711  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
712  ret = AVERROR(EINVAL);
713  goto free_and_end;
714  }
715  avctx->frame_number = 0;
717 
718  if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
720  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
721  const AVCodec *codec2;
722  av_log(avctx, AV_LOG_ERROR,
723  "The %s '%s' is experimental but experimental codecs are not enabled, "
724  "add '-strict %d' if you want to use it.\n",
725  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
726  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
727  if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
728  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
729  codec_string, codec2->name);
730  ret = AVERROR_EXPERIMENTAL;
731  goto free_and_end;
732  }
733 
734  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
735  (!avctx->time_base.num || !avctx->time_base.den)) {
736  avctx->time_base.num = 1;
737  avctx->time_base.den = avctx->sample_rate;
738  }
739 
740  if (!HAVE_THREADS)
741  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
742 
743  if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
744  ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
745  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
746  ff_lock_avcodec(avctx, codec);
747  if (ret < 0)
748  goto free_and_end;
749  }
750 
751  if (av_codec_is_decoder(avctx->codec)) {
752  ret = ff_decode_bsfs_init(avctx);
753  if (ret < 0)
754  goto free_and_end;
755  }
756 
757  if (HAVE_THREADS
758  && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
759  ret = ff_thread_init(avctx);
760  if (ret < 0) {
761  goto free_and_end;
762  }
763  }
764  if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
765  avctx->thread_count = 1;
766 
767  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
768  av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
769  avctx->codec->max_lowres);
770  avctx->lowres = avctx->codec->max_lowres;
771  }
772 
773  if (av_codec_is_encoder(avctx->codec)) {
774  int i;
775 #if FF_API_CODED_FRAME
777  avctx->coded_frame = av_frame_alloc();
778  if (!avctx->coded_frame) {
779  ret = AVERROR(ENOMEM);
780  goto free_and_end;
781  }
783 #endif
784 
785  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
786  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
787  ret = AVERROR(EINVAL);
788  goto free_and_end;
789  }
790 
791  if (avctx->codec->sample_fmts) {
792  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
793  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
794  break;
795  if (avctx->channels == 1 &&
798  avctx->sample_fmt = avctx->codec->sample_fmts[i];
799  break;
800  }
801  }
802  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
803  char buf[128];
804  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
805  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
806  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
807  ret = AVERROR(EINVAL);
808  goto free_and_end;
809  }
810  }
811  if (avctx->codec->pix_fmts) {
812  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
813  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
814  break;
815  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
816  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
818  char buf[128];
819  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
820  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
821  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
822  ret = AVERROR(EINVAL);
823  goto free_and_end;
824  }
825  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
826  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
827  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
828  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
829  avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
830  avctx->color_range = AVCOL_RANGE_JPEG;
831  }
832  if (avctx->codec->supported_samplerates) {
833  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
834  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
835  break;
836  if (avctx->codec->supported_samplerates[i] == 0) {
837  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
838  avctx->sample_rate);
839  ret = AVERROR(EINVAL);
840  goto free_and_end;
841  }
842  }
843  if (avctx->sample_rate < 0) {
844  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
845  avctx->sample_rate);
846  ret = AVERROR(EINVAL);
847  goto free_and_end;
848  }
849  if (avctx->codec->channel_layouts) {
850  if (!avctx->channel_layout) {
851  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
852  } else {
853  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
854  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
855  break;
856  if (avctx->codec->channel_layouts[i] == 0) {
857  char buf[512];
858  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
859  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
860  ret = AVERROR(EINVAL);
861  goto free_and_end;
862  }
863  }
864  }
865  if (avctx->channel_layout && avctx->channels) {
867  if (channels != avctx->channels) {
868  char buf[512];
869  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
870  av_log(avctx, AV_LOG_ERROR,
871  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
872  buf, channels, avctx->channels);
873  ret = AVERROR(EINVAL);
874  goto free_and_end;
875  }
876  } else if (avctx->channel_layout) {
878  }
879  if (avctx->channels < 0) {
880  av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
881  avctx->channels);
882  ret = AVERROR(EINVAL);
883  goto free_and_end;
884  }
885  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
886  pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
887  if ( avctx->bits_per_raw_sample < 0
888  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
889  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
890  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
891  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
892  }
893  if (avctx->width <= 0 || avctx->height <= 0) {
894  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
895  ret = AVERROR(EINVAL);
896  goto free_and_end;
897  }
898  }
899  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
900  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
901  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
902  }
903 
904  if (!avctx->rc_initial_buffer_occupancy)
905  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
906 
907  if (avctx->ticks_per_frame && avctx->time_base.num &&
908  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
909  av_log(avctx, AV_LOG_ERROR,
910  "ticks_per_frame %d too large for the timebase %d/%d.",
911  avctx->ticks_per_frame,
912  avctx->time_base.num,
913  avctx->time_base.den);
914  goto free_and_end;
915  }
916 
917  if (avctx->hw_frames_ctx) {
918  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
919  if (frames_ctx->format != avctx->pix_fmt) {
920  av_log(avctx, AV_LOG_ERROR,
921  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
922  ret = AVERROR(EINVAL);
923  goto free_and_end;
924  }
925  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
926  avctx->sw_pix_fmt != frames_ctx->sw_format) {
927  av_log(avctx, AV_LOG_ERROR,
928  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
929  "and AVHWFramesContext.sw_format (%s)\n",
931  av_get_pix_fmt_name(frames_ctx->sw_format));
932  ret = AVERROR(EINVAL);
933  goto free_and_end;
934  }
935  avctx->sw_pix_fmt = frames_ctx->sw_format;
936  }
937  }
938 
941  avctx->pts_correction_last_pts =
942  avctx->pts_correction_last_dts = INT64_MIN;
943 
944  if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
946  av_log(avctx, AV_LOG_WARNING,
947  "gray decoding requested but not enabled at configuration time\n");
948  if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
950  }
951 
952  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
953  || avci->frame_thread_encoder)) {
954  ret = avctx->codec->init(avctx);
955  if (ret < 0) {
956  codec_init_ok = -1;
957  goto free_and_end;
958  }
959  codec_init_ok = 1;
960  }
961 
962  ret=0;
963 
964  if (av_codec_is_decoder(avctx->codec)) {
965  if (!avctx->bit_rate)
966  avctx->bit_rate = get_bit_rate(avctx);
967  /* validate channel layout from the decoder */
968  if (avctx->channel_layout) {
970  if (!avctx->channels)
971  avctx->channels = channels;
972  else if (channels != avctx->channels) {
973  char buf[512];
974  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
975  av_log(avctx, AV_LOG_WARNING,
976  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
977  "ignoring specified channel layout\n",
978  buf, channels, avctx->channels);
979  avctx->channel_layout = 0;
980  }
981  }
982  if (avctx->channels && avctx->channels < 0 ||
983  avctx->channels > FF_SANE_NB_CHANNELS) {
984  ret = AVERROR(EINVAL);
985  goto free_and_end;
986  }
987  if (avctx->bits_per_coded_sample < 0) {
988  ret = AVERROR(EINVAL);
989  goto free_and_end;
990  }
991  if (avctx->sub_charenc) {
992  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
993  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
994  "supported with subtitles codecs\n");
995  ret = AVERROR(EINVAL);
996  goto free_and_end;
997  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
998  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
999  "subtitles character encoding will be ignored\n",
1000  avctx->codec_descriptor->name);
1002  } else {
1003  /* input character encoding is set for a text based subtitle
1004  * codec at this point */
1007 
1009 #if CONFIG_ICONV
1010  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1011  if (cd == (iconv_t)-1) {
1012  ret = AVERROR(errno);
1013  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1014  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1015  goto free_and_end;
1016  }
1017  iconv_close(cd);
1018 #else
1019  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1020  "conversion needs a libavcodec built with iconv support "
1021  "for this codec\n");
1022  ret = AVERROR(ENOSYS);
1023  goto free_and_end;
1024 #endif
1025  }
1026  }
1027  }
1028 
1029 #if FF_API_AVCTX_TIMEBASE
1030  if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1031  avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1032 #endif
1033  }
1034  if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1035  av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1036  }
1037 
1038 end:
1039  ff_unlock_avcodec(codec);
1040  if (options) {
1041  av_dict_free(options);
1042  *options = tmp;
1043  }
1044 
1045  return ret;
1046 free_and_end:
1047  if (avctx->codec && avctx->codec->close &&
1048  (codec_init_ok > 0 || (codec_init_ok < 0 &&
1050  avctx->codec->close(avctx);
1051 
1052  if (HAVE_THREADS && avci->thread_ctx)
1053  ff_thread_free(avctx);
1054 
1055  if (codec->priv_class && avctx->priv_data)
1056  av_opt_free(avctx->priv_data);
1057  av_opt_free(avctx);
1058 
1059  if (av_codec_is_encoder(avctx->codec)) {
1060 #if FF_API_CODED_FRAME
1062  av_frame_free(&avctx->coded_frame);
1064 #endif
1065  av_freep(&avctx->extradata);
1066  avctx->extradata_size = 0;
1067  }
1068 
1069  av_dict_free(&tmp);
1070  av_freep(&avctx->priv_data);
1071  av_freep(&avctx->subtitle_header);
1072 
1073 #if FF_API_OLD_ENCDEC
1074  av_frame_free(&avci->to_free);
1077 #endif
1078  av_frame_free(&avci->buffer_frame);
1079  av_packet_free(&avci->buffer_pkt);
1081  av_fifo_freep(&avci->pkt_props);
1082 
1083  av_packet_free(&avci->ds.in_pkt);
1084  av_frame_free(&avci->es.in_frame);
1085  av_bsf_free(&avci->bsf);
1086 
1087  av_buffer_unref(&avci->pool);
1088  av_freep(&avci);
1089  avctx->internal = NULL;
1090  avctx->codec = NULL;
1091  goto end;
1092 }
1093 
1095 {
1096  AVCodecInternal *avci = avctx->internal;
1097 
1098  if (av_codec_is_encoder(avctx->codec)) {
1099  int caps = avctx->codec->capabilities;
1100 
1101  if (!(caps & AV_CODEC_CAP_ENCODER_FLUSH)) {
1102  // Only encoders that explicitly declare support for it can be
1103  // flushed. Otherwise, this is a no-op.
1104  av_log(avctx, AV_LOG_WARNING, "Ignoring attempt to flush encoder "
1105  "that doesn't support it\n");
1106  return;
1107  }
1108 
1109  // We haven't implemented flushing for frame-threaded encoders.
1111  }
1112 
1113  avci->draining = 0;
1114  avci->draining_done = 0;
1115  avci->nb_draining_errors = 0;
1117 #if FF_API_OLD_ENCDEC
1120 #endif
1121  av_packet_unref(avci->buffer_pkt);
1122 
1124  while (av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props)) {
1126  avci->last_pkt_props, sizeof(*avci->last_pkt_props),
1127  NULL);
1129  }
1130  av_fifo_reset(avci->pkt_props);
1131 
1132  av_frame_unref(avci->es.in_frame);
1133  av_packet_unref(avci->ds.in_pkt);
1134 
1135  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1136  ff_thread_flush(avctx);
1137  else if (avctx->codec->flush)
1138  avctx->codec->flush(avctx);
1139 
1140  avctx->pts_correction_last_pts =
1141  avctx->pts_correction_last_dts = INT64_MIN;
1142 
1143  if (av_codec_is_decoder(avctx->codec))
1144  av_bsf_flush(avci->bsf);
1145 
1146 #if FF_API_OLD_ENCDEC
1148  if (!avctx->refcounted_frames)
1149  av_frame_unref(avci->to_free);
1151 #endif
1152 }
1153 
1155 {
1156  int i;
1157 
1158  for (i = 0; i < sub->num_rects; i++) {
1159  av_freep(&sub->rects[i]->data[0]);
1160  av_freep(&sub->rects[i]->data[1]);
1161  av_freep(&sub->rects[i]->data[2]);
1162  av_freep(&sub->rects[i]->data[3]);
1163  av_freep(&sub->rects[i]->text);
1164  av_freep(&sub->rects[i]->ass);
1165  av_freep(&sub->rects[i]);
1166  }
1167 
1168  av_freep(&sub->rects);
1169 
1170  memset(sub, 0, sizeof(*sub));
1171 }
1172 
1174 {
1175  int i;
1176 
1177  if (!avctx)
1178  return 0;
1179 
1180  if (avcodec_is_open(avctx)) {
1181  if (CONFIG_FRAME_THREAD_ENCODER &&
1182  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
1184  }
1185  if (HAVE_THREADS && avctx->internal->thread_ctx)
1186  ff_thread_free(avctx);
1187  if (avctx->codec && avctx->codec->close)
1188  avctx->codec->close(avctx);
1189  avctx->internal->byte_buffer_size = 0;
1190  av_freep(&avctx->internal->byte_buffer);
1191 #if FF_API_OLD_ENCDEC
1192  av_frame_free(&avctx->internal->to_free);
1195 #endif
1199  while (av_fifo_size(avctx->internal->pkt_props) >=
1200  sizeof(*avctx->internal->last_pkt_props)) {
1202  avctx->internal->last_pkt_props,
1203  sizeof(*avctx->internal->last_pkt_props),
1204  NULL);
1206  }
1208  av_fifo_freep(&avctx->internal->pkt_props);
1209 
1210  av_packet_free(&avctx->internal->ds.in_pkt);
1211  av_frame_free(&avctx->internal->es.in_frame);
1212 
1213  av_buffer_unref(&avctx->internal->pool);
1214 
1215  if (avctx->hwaccel && avctx->hwaccel->uninit)
1216  avctx->hwaccel->uninit(avctx);
1218 
1219  av_bsf_free(&avctx->internal->bsf);
1220 
1221  av_freep(&avctx->internal);
1222  }
1223 
1224  for (i = 0; i < avctx->nb_coded_side_data; i++)
1225  av_freep(&avctx->coded_side_data[i].data);
1226  av_freep(&avctx->coded_side_data);
1227  avctx->nb_coded_side_data = 0;
1228 
1229  av_buffer_unref(&avctx->hw_frames_ctx);
1230  av_buffer_unref(&avctx->hw_device_ctx);
1231 
1232  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1233  av_opt_free(avctx->priv_data);
1234  av_opt_free(avctx);
1235  av_freep(&avctx->priv_data);
1236  if (av_codec_is_encoder(avctx->codec)) {
1237  av_freep(&avctx->extradata);
1238 #if FF_API_CODED_FRAME
1240  av_frame_free(&avctx->coded_frame);
1242 #endif
1243  }
1244  avctx->codec = NULL;
1245  avctx->active_thread_type = 0;
1246 
1247  return 0;
1248 }
1249 
1250 const char *avcodec_get_name(enum AVCodecID id)
1251 {
1252  const AVCodecDescriptor *cd;
1253  const AVCodec *codec;
1254 
1255  if (id == AV_CODEC_ID_NONE)
1256  return "none";
1257  cd = avcodec_descriptor_get(id);
1258  if (cd)
1259  return cd->name;
1260  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
1261  codec = avcodec_find_decoder(id);
1262  if (codec)
1263  return codec->name;
1264  codec = avcodec_find_encoder(id);
1265  if (codec)
1266  return codec->name;
1267  return "unknown_codec";
1268 }
1269 
1270 #if FF_API_TAG_STRING
1271 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1272 {
1273  int i, len, ret = 0;
1274 
1275 #define TAG_PRINT(x) \
1276  (((x) >= '0' && (x) <= '9') || \
1277  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
1278  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
1279 
1280  for (i = 0; i < 4; i++) {
1281  len = snprintf(buf, buf_size,
1282  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1283  buf += len;
1284  buf_size = buf_size > len ? buf_size - len : 0;
1285  ret += len;
1286  codec_tag >>= 8;
1287  }
1288  return ret;
1289 }
1290 #endif
1291 
1292 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1293 {
1294  const char *codec_type;
1295  const char *codec_name;
1296  const char *profile = NULL;
1297  int64_t bitrate;
1298  int new_line = 0;
1299  AVRational display_aspect_ratio;
1300  const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
1301 
1302  if (!buf || buf_size <= 0)
1303  return;
1304  codec_type = av_get_media_type_string(enc->codec_type);
1305  codec_name = avcodec_get_name(enc->codec_id);
1306  profile = avcodec_profile_name(enc->codec_id, enc->profile);
1307 
1308  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
1309  codec_name);
1310  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
1311 
1312  if (enc->codec && strcmp(enc->codec->name, codec_name))
1313  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
1314 
1315  if (profile)
1316  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
1317  if ( enc->codec_type == AVMEDIA_TYPE_VIDEO
1319  && enc->refs)
1320  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1321  ", %d reference frame%s",
1322  enc->refs, enc->refs > 1 ? "s" : "");
1323 
1324  if (enc->codec_tag)
1325  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s / 0x%04X)",
1326  av_fourcc2str(enc->codec_tag), enc->codec_tag);
1327 
1328  switch (enc->codec_type) {
1329  case AVMEDIA_TYPE_VIDEO:
1330  {
1331  char detail[256] = "(";
1332 
1333  av_strlcat(buf, separator, buf_size);
1334 
1335  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1336  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
1338  if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
1340  av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
1342  av_strlcatf(detail, sizeof(detail), "%s, ",
1344 
1345  if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
1347  enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
1348  if (enc->colorspace != (int)enc->color_primaries ||
1349  enc->colorspace != (int)enc->color_trc) {
1350  new_line = 1;
1351  av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
1355  } else
1356  av_strlcatf(detail, sizeof(detail), "%s, ",
1358  }
1359 
1360  if (enc->field_order != AV_FIELD_UNKNOWN) {
1361  const char *field_order = "progressive";
1362  if (enc->field_order == AV_FIELD_TT)
1363  field_order = "top first";
1364  else if (enc->field_order == AV_FIELD_BB)
1365  field_order = "bottom first";
1366  else if (enc->field_order == AV_FIELD_TB)
1367  field_order = "top coded first (swapped)";
1368  else if (enc->field_order == AV_FIELD_BT)
1369  field_order = "bottom coded first (swapped)";
1370 
1371  av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
1372  }
1373 
1374  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1376  av_strlcatf(detail, sizeof(detail), "%s, ",
1378 
1379  if (strlen(detail) > 1) {
1380  detail[strlen(detail) - 2] = 0;
1381  av_strlcatf(buf, buf_size, "%s)", detail);
1382  }
1383  }
1384 
1385  if (enc->width) {
1386  av_strlcat(buf, new_line ? separator : ", ", buf_size);
1387 
1388  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1389  "%dx%d",
1390  enc->width, enc->height);
1391 
1392  if (av_log_get_level() >= AV_LOG_VERBOSE &&
1393  (enc->width != enc->coded_width ||
1394  enc->height != enc->coded_height))
1395  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1396  " (%dx%d)", enc->coded_width, enc->coded_height);
1397 
1398  if (enc->sample_aspect_ratio.num) {
1399  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1400  enc->width * (int64_t)enc->sample_aspect_ratio.num,
1401  enc->height * (int64_t)enc->sample_aspect_ratio.den,
1402  1024 * 1024);
1403  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1404  " [SAR %d:%d DAR %d:%d]",
1406  display_aspect_ratio.num, display_aspect_ratio.den);
1407  }
1408  if (av_log_get_level() >= AV_LOG_DEBUG) {
1409  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1410  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1411  ", %d/%d",
1412  enc->time_base.num / g, enc->time_base.den / g);
1413  }
1414  }
1415  if (encode) {
1416  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1417  ", q=%d-%d", enc->qmin, enc->qmax);
1418  } else {
1420  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1421  ", Closed Captions");
1423  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1424  ", lossless");
1425  }
1426  break;
1427  case AVMEDIA_TYPE_AUDIO:
1428  av_strlcat(buf, separator, buf_size);
1429 
1430  if (enc->sample_rate) {
1431  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1432  "%d Hz, ", enc->sample_rate);
1433  }
1434  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1435  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1436  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1437  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1438  }
1439  if ( enc->bits_per_raw_sample > 0
1441  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1442  " (%d bit)", enc->bits_per_raw_sample);
1443  if (av_log_get_level() >= AV_LOG_VERBOSE) {
1444  if (enc->initial_padding)
1445  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1446  ", delay %d", enc->initial_padding);
1447  if (enc->trailing_padding)
1448  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1449  ", padding %d", enc->trailing_padding);
1450  }
1451  break;
1452  case AVMEDIA_TYPE_DATA:
1453  if (av_log_get_level() >= AV_LOG_DEBUG) {
1454  int g = av_gcd(enc->time_base.num, enc->time_base.den);
1455  if (g)
1456  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1457  ", %d/%d",
1458  enc->time_base.num / g, enc->time_base.den / g);
1459  }
1460  break;
1461  case AVMEDIA_TYPE_SUBTITLE:
1462  if (enc->width)
1463  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1464  ", %dx%d", enc->width, enc->height);
1465  break;
1466  default:
1467  return;
1468  }
1469  if (encode) {
1470  if (enc->flags & AV_CODEC_FLAG_PASS1)
1471  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1472  ", pass 1");
1473  if (enc->flags & AV_CODEC_FLAG_PASS2)
1474  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1475  ", pass 2");
1476  }
1477  bitrate = get_bit_rate(enc);
1478  if (bitrate != 0) {
1479  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1480  ", %"PRId64" kb/s", bitrate / 1000);
1481  } else if (enc->rc_max_rate > 0) {
1482  snprintf(buf + strlen(buf), buf_size - strlen(buf),
1483  ", max. %"PRId64" kb/s", enc->rc_max_rate / 1000);
1484  }
1485 }
1486 
1487 const char *av_get_profile_name(const AVCodec *codec, int profile)
1488 {
1489  const AVProfile *p;
1490  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1491  return NULL;
1492 
1493  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1494  if (p->profile == profile)
1495  return p->name;
1496 
1497  return NULL;
1498 }
1499 
1501 {
1502  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
1503  const AVProfile *p;
1504 
1505  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1506  return NULL;
1507 
1508  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1509  if (p->profile == profile)
1510  return p->name;
1511 
1512  return NULL;
1513 }
1514 
1515 unsigned avcodec_version(void)
1516 {
1519  av_assert0(AV_CODEC_ID_SRT==94216);
1521 
1522  return LIBAVCODEC_VERSION_INT;
1523 }
1524 
1525 const char *avcodec_configuration(void)
1526 {
1527  return FFMPEG_CONFIGURATION;
1528 }
1529 
1530 const char *avcodec_license(void)
1531 {
1532 #define LICENSE_PREFIX "libavcodec license: "
1533  return &LICENSE_PREFIX FFMPEG_LICENSE[sizeof(LICENSE_PREFIX) - 1];
1534 }
1535 
1537 {
1538  switch (codec_id) {
1539  case AV_CODEC_ID_8SVX_EXP:
1540  case AV_CODEC_ID_8SVX_FIB:
1542  case AV_CODEC_ID_ADPCM_CT:
1554  return 4;
1555  case AV_CODEC_ID_DSD_LSBF:
1556  case AV_CODEC_ID_DSD_MSBF:
1559  case AV_CODEC_ID_PCM_ALAW:
1560  case AV_CODEC_ID_PCM_MULAW:
1561  case AV_CODEC_ID_PCM_VIDC:
1562  case AV_CODEC_ID_PCM_S8:
1564  case AV_CODEC_ID_PCM_SGA:
1565  case AV_CODEC_ID_PCM_U8:
1566  case AV_CODEC_ID_SDX2_DPCM:
1567  case AV_CODEC_ID_DERF_DPCM:
1568  return 8;
1569  case AV_CODEC_ID_PCM_S16BE:
1571  case AV_CODEC_ID_PCM_S16LE:
1573  case AV_CODEC_ID_PCM_U16BE:
1574  case AV_CODEC_ID_PCM_U16LE:
1575  return 16;
1577  case AV_CODEC_ID_PCM_S24BE:
1578  case AV_CODEC_ID_PCM_S24LE:
1580  case AV_CODEC_ID_PCM_U24BE:
1581  case AV_CODEC_ID_PCM_U24LE:
1582  return 24;
1583  case AV_CODEC_ID_PCM_S32BE:
1584  case AV_CODEC_ID_PCM_S32LE:
1586  case AV_CODEC_ID_PCM_U32BE:
1587  case AV_CODEC_ID_PCM_U32LE:
1588  case AV_CODEC_ID_PCM_F32BE:
1589  case AV_CODEC_ID_PCM_F32LE:
1590  case AV_CODEC_ID_PCM_F24LE:
1591  case AV_CODEC_ID_PCM_F16LE:
1592  return 32;
1593  case AV_CODEC_ID_PCM_F64BE:
1594  case AV_CODEC_ID_PCM_F64LE:
1595  case AV_CODEC_ID_PCM_S64BE:
1596  case AV_CODEC_ID_PCM_S64LE:
1597  return 64;
1598  default:
1599  return 0;
1600  }
1601 }
1602 
1604 {
1605  static const enum AVCodecID map[][2] = {
1611  [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
1612  [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
1613  [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
1615  [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
1616  [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
1617  };
1618  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
1619  return AV_CODEC_ID_NONE;
1620  if (be < 0 || be > 1)
1621  be = AV_NE(1, 0);
1622  return map[fmt][be];
1623 }
1624 
1626 {
1627  switch (codec_id) {
1629  return 2;
1631  return 3;
1635  case AV_CODEC_ID_ADPCM_SWF:
1636  case AV_CODEC_ID_ADPCM_MS:
1637  return 4;
1638  default:
1639  return av_get_exact_bits_per_sample(codec_id);
1640  }
1641 }
1642 
1643 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1644  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
1645  uint8_t * extradata, int frame_size, int frame_bytes)
1646 {
1648  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
1649 
1650  /* codecs with an exact constant bits per sample */
1651  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
1652  return (frame_bytes * 8LL) / (bps * ch);
1653  bps = bits_per_coded_sample;
1654 
1655  /* codecs with a fixed packet duration */
1656  switch (id) {
1657  case AV_CODEC_ID_ADPCM_ADX: return 32;
1658  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
1659  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
1660  case AV_CODEC_ID_AMR_NB:
1661  case AV_CODEC_ID_EVRC:
1662  case AV_CODEC_ID_GSM:
1663  case AV_CODEC_ID_QCELP:
1664  case AV_CODEC_ID_RA_288: return 160;
1665  case AV_CODEC_ID_AMR_WB:
1666  case AV_CODEC_ID_GSM_MS: return 320;
1667  case AV_CODEC_ID_MP1: return 384;
1668  case AV_CODEC_ID_ATRAC1: return 512;
1669  case AV_CODEC_ID_ATRAC9:
1670  case AV_CODEC_ID_ATRAC3:
1671  if (framecount > INT_MAX/1024)
1672  return 0;
1673  return 1024 * framecount;
1674  case AV_CODEC_ID_ATRAC3P: return 2048;
1675  case AV_CODEC_ID_MP2:
1676  case AV_CODEC_ID_MUSEPACK7: return 1152;
1677  case AV_CODEC_ID_AC3: return 1536;
1678  }
1679 
1680  if (sr > 0) {
1681  /* calc from sample rate */
1682  if (id == AV_CODEC_ID_TTA)
1683  return 256 * sr / 245;
1684  else if (id == AV_CODEC_ID_DST)
1685  return 588 * sr / 44100;
1686  else if (id == AV_CODEC_ID_BINKAUDIO_DCT) {
1687  if (sr / 22050 > 22)
1688  return 0;
1689  return (480 << (sr / 22050));
1690  }
1691 
1692  if (id == AV_CODEC_ID_MP3)
1693  return sr <= 24000 ? 576 : 1152;
1694  }
1695 
1696  if (ba > 0) {
1697  /* calc from block_align */
1698  if (id == AV_CODEC_ID_SIPR) {
1699  switch (ba) {
1700  case 20: return 160;
1701  case 19: return 144;
1702  case 29: return 288;
1703  case 37: return 480;
1704  }
1705  } else if (id == AV_CODEC_ID_ILBC) {
1706  switch (ba) {
1707  case 38: return 160;
1708  case 50: return 240;
1709  }
1710  }
1711  }
1712 
1713  if (frame_bytes > 0) {
1714  /* calc from frame_bytes only */
1715  if (id == AV_CODEC_ID_TRUESPEECH)
1716  return 240 * (frame_bytes / 32);
1717  if (id == AV_CODEC_ID_NELLYMOSER)
1718  return 256 * (frame_bytes / 64);
1719  if (id == AV_CODEC_ID_RA_144)
1720  return 160 * (frame_bytes / 20);
1721 
1722  if (bps > 0) {
1723  /* calc from frame_bytes and bits_per_coded_sample */
1725  return frame_bytes * 8 / bps;
1726  }
1727 
1728  if (ch > 0 && ch < INT_MAX/16) {
1729  /* calc from frame_bytes and channels */
1730  switch (id) {
1731  case AV_CODEC_ID_FASTAUDIO:
1732  return frame_bytes / (40 * ch) * 256;
1734  return (frame_bytes - 4 * ch) / (128 * ch) * 256;
1735  case AV_CODEC_ID_ADPCM_AFC:
1736  return frame_bytes / (9 * ch) * 16;
1737  case AV_CODEC_ID_ADPCM_PSX:
1738  case AV_CODEC_ID_ADPCM_DTK:
1739  frame_bytes /= 16 * ch;
1740  if (frame_bytes > INT_MAX / 28)
1741  return 0;
1742  return frame_bytes * 28;
1743  case AV_CODEC_ID_ADPCM_4XM:
1746  return (frame_bytes - 4 * ch) * 2 / ch;
1748  return (frame_bytes - 4) * 2 / ch;
1750  return (frame_bytes - 8) * 2;
1751  case AV_CODEC_ID_ADPCM_THP:
1753  if (extradata)
1754  return frame_bytes * 14 / (8 * ch);
1755  break;
1756  case AV_CODEC_ID_ADPCM_XA:
1757  return (frame_bytes / 128) * 224 / ch;
1759  return (frame_bytes - 6 - ch) / ch;
1760  case AV_CODEC_ID_ROQ_DPCM:
1761  return (frame_bytes - 8) / ch;
1762  case AV_CODEC_ID_XAN_DPCM:
1763  return (frame_bytes - 2 * ch) / ch;
1764  case AV_CODEC_ID_MACE3:
1765  return 3 * frame_bytes / ch;
1766  case AV_CODEC_ID_MACE6:
1767  return 6 * frame_bytes / ch;
1768  case AV_CODEC_ID_PCM_LXF:
1769  return 2 * (frame_bytes / (5 * ch));
1770  case AV_CODEC_ID_IAC:
1771  case AV_CODEC_ID_IMC:
1772  return 4 * frame_bytes / ch;
1773  }
1774 
1775  if (tag) {
1776  /* calc from frame_bytes, channels, and codec_tag */
1777  if (id == AV_CODEC_ID_SOL_DPCM) {
1778  if (tag == 3)
1779  return frame_bytes / ch;
1780  else
1781  return frame_bytes * 2 / ch;
1782  }
1783  }
1784 
1785  if (ba > 0) {
1786  /* calc from frame_bytes, channels, and block_align */
1787  int blocks = frame_bytes / ba;
1788  switch (id) {
1790  if (bps < 2 || bps > 5)
1791  return 0;
1792  return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
1794  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1796  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1798  return blocks * ((ba - 4 * ch) * 2 / ch);
1799  case AV_CODEC_ID_ADPCM_MS:
1800  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1802  return blocks * (ba - 16) * 2 / ch;
1803  }
1804  }
1805 
1806  if (bps > 0) {
1807  /* calc from frame_bytes, channels, and bits_per_coded_sample */
1808  switch (id) {
1809  case AV_CODEC_ID_PCM_DVD:
1810  if(bps<4 || frame_bytes<3)
1811  return 0;
1812  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
1814  if(bps<4 || frame_bytes<4)
1815  return 0;
1816  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
1817  case AV_CODEC_ID_S302M:
1818  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1819  }
1820  }
1821  }
1822  }
1823 
1824  /* Fall back on using frame_size */
1825  if (frame_size > 1 && frame_bytes)
1826  return frame_size;
1827 
1828  //For WMA we currently have no other means to calculate duration thus we
1829  //do it here by assuming CBR, which is true for all known cases.
1830  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
1831  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
1832  return (frame_bytes * 8LL * sr) / bitrate;
1833  }
1834 
1835  return 0;
1836 }
1837 
1838 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1839 {
1840  return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1841  avctx->channels, avctx->block_align,
1842  avctx->codec_tag, avctx->bits_per_coded_sample,
1843  avctx->bit_rate, avctx->extradata, avctx->frame_size,
1844  frame_bytes);
1845 }
1846 
1848 {
1849  return get_audio_frame_duration(par->codec_id, par->sample_rate,
1850  par->channels, par->block_align,
1851  par->codec_tag, par->bits_per_coded_sample,
1852  par->bit_rate, par->extradata, par->frame_size,
1853  frame_bytes);
1854 }
1855 
1856 #if !HAVE_THREADS
1858 {
1859  return -1;
1860 }
1861 
1862 #endif
1863 
1864 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1865 {
1866  unsigned int n = 0;
1867 
1868  while (v >= 0xff) {
1869  *s++ = 0xff;
1870  v -= 0xff;
1871  n++;
1872  }
1873  *s = v;
1874  n++;
1875  return n;
1876 }
1877 
1878 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1879 {
1880  int i;
1881  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1882  return i;
1883 }
1884 
1886 {
1887  int i;
1888  if (!codec->hw_configs || index < 0)
1889  return NULL;
1890  for (i = 0; i <= index; i++)
1891  if (!codec->hw_configs[i])
1892  return NULL;
1893  return &codec->hw_configs[index]->public;
1894 }
1895 
1896 #if FF_API_USER_VISIBLE_AVHWACCEL
1898 {
1899  return NULL;
1900 }
1901 
1903 {
1904 }
1905 #endif
1906 
1907 #if FF_API_LOCKMGR
1908 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1909 {
1910  return 0;
1911 }
1912 #endif
1913 
1914 unsigned int avpriv_toupper4(unsigned int x)
1915 {
1916  return av_toupper(x & 0xFF) +
1917  (av_toupper((x >> 8) & 0xFF) << 8) +
1918  (av_toupper((x >> 16) & 0xFF) << 16) +
1919 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
1920 }
1921 
1923 {
1924  int ret;
1925 
1926  dst->owner[0] = src->owner[0];
1927  dst->owner[1] = src->owner[1];
1928 
1929  ret = av_frame_ref(dst->f, src->f);
1930  if (ret < 0)
1931  return ret;
1932 
1933  av_assert0(!dst->progress);
1934 
1935  if (src->progress &&
1936  !(dst->progress = av_buffer_ref(src->progress))) {
1937  ff_thread_release_buffer(dst->owner[0], dst);
1938  return AVERROR(ENOMEM);
1939  }
1940 
1941  return 0;
1942 }
1943 
1944 #if !HAVE_THREADS
1945 
1947 {
1948  return ff_get_format(avctx, fmt);
1949 }
1950 
1952 {
1953  f->owner[0] = f->owner[1] = avctx;
1954  return ff_get_buffer(avctx, f->f, flags);
1955 }
1956 
1958 {
1959  if (f->f)
1960  av_frame_unref(f->f);
1961 }
1962 
1964 {
1965 }
1966 
1968 {
1969 }
1970 
1971 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1972 {
1973 }
1974 
1976 {
1977  return 1;
1978 }
1979 
1981 {
1982  return 0;
1983 }
1984 
1986 {
1987 }
1988 
1989 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1990 {
1991 }
1992 
1993 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1994 {
1995 }
1996 
1997 #endif
1998 
2000 {
2001  return !!s->internal;
2002 }
2003 
2004 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
2005  const uint8_t *end,
2006  uint32_t *av_restrict state)
2007 {
2008  int i;
2009 
2010  av_assert0(p <= end);
2011  if (p >= end)
2012  return end;
2013 
2014  for (i = 0; i < 3; i++) {
2015  uint32_t tmp = *state << 8;
2016  *state = tmp + *(p++);
2017  if (tmp == 0x100 || p == end)
2018  return p;
2019  }
2020 
2021  while (p < end) {
2022  if (p[-1] > 1 ) p += 3;
2023  else if (p[-2] ) p += 2;
2024  else if (p[-3]|(p[-1]-1)) p++;
2025  else {
2026  p++;
2027  break;
2028  }
2029  }
2030 
2031  p = FFMIN(p, end) - 4;
2032  *state = AV_RB32(p);
2033 
2034  return p + 4;
2035 }
2036 
2038 {
2039  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
2040  if (!props)
2041  return NULL;
2042 
2043  if (size)
2044  *size = sizeof(*props);
2045 
2046  props->vbv_delay = UINT64_MAX;
2047 
2048  return props;
2049 }
2050 
2052 {
2054  AVCPBProperties *props;
2055  size_t size;
2056  int i;
2057 
2058  for (i = 0; i < avctx->nb_coded_side_data; i++)
2060  return (AVCPBProperties *)avctx->coded_side_data[i].data;
2061 
2062  props = av_cpb_properties_alloc(&size);
2063  if (!props)
2064  return NULL;
2065 
2066  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
2067  if (!tmp) {
2068  av_freep(&props);
2069  return NULL;
2070  }
2071 
2072  avctx->coded_side_data = tmp;
2073  avctx->nb_coded_side_data++;
2074 
2076  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
2077  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
2078 
2079  return props;
2080 }
2081 
2083 {
2084  av_freep(&par->extradata);
2085 
2086  memset(par, 0, sizeof(*par));
2087 
2089  par->codec_id = AV_CODEC_ID_NONE;
2090  par->format = -1;
2097  par->sample_aspect_ratio = (AVRational){ 0, 1 };
2098  par->profile = FF_PROFILE_UNKNOWN;
2099  par->level = FF_LEVEL_UNKNOWN;
2100 }
2101 
2103 {
2104  AVCodecParameters *par = av_mallocz(sizeof(*par));
2105 
2106  if (!par)
2107  return NULL;
2109  return par;
2110 }
2111 
2113 {
2114  AVCodecParameters *par = *ppar;
2115 
2116  if (!par)
2117  return;
2119 
2120  av_freep(ppar);
2121 }
2122 
2124 {
2126  memcpy(dst, src, sizeof(*dst));
2127 
2128  dst->extradata = NULL;
2129  dst->extradata_size = 0;
2130  if (src->extradata) {
2132  if (!dst->extradata)
2133  return AVERROR(ENOMEM);
2134  memcpy(dst->extradata, src->extradata, src->extradata_size);
2135  dst->extradata_size = src->extradata_size;
2136  }
2137 
2138  return 0;
2139 }
2140 
2142  const AVCodecContext *codec)
2143 {
2145 
2146  par->codec_type = codec->codec_type;
2147  par->codec_id = codec->codec_id;
2148  par->codec_tag = codec->codec_tag;
2149 
2150  par->bit_rate = codec->bit_rate;
2153  par->profile = codec->profile;
2154  par->level = codec->level;
2155 
2156  switch (par->codec_type) {
2157  case AVMEDIA_TYPE_VIDEO:
2158  par->format = codec->pix_fmt;
2159  par->width = codec->width;
2160  par->height = codec->height;
2161  par->field_order = codec->field_order;
2162  par->color_range = codec->color_range;
2163  par->color_primaries = codec->color_primaries;
2164  par->color_trc = codec->color_trc;
2165  par->color_space = codec->colorspace;
2168  par->video_delay = codec->has_b_frames;
2169  break;
2170  case AVMEDIA_TYPE_AUDIO:
2171  par->format = codec->sample_fmt;
2172  par->channel_layout = codec->channel_layout;
2173  par->channels = codec->channels;
2174  par->sample_rate = codec->sample_rate;
2175  par->block_align = codec->block_align;
2176  par->frame_size = codec->frame_size;
2177  par->initial_padding = codec->initial_padding;
2178  par->trailing_padding = codec->trailing_padding;
2179  par->seek_preroll = codec->seek_preroll;
2180  break;
2181  case AVMEDIA_TYPE_SUBTITLE:
2182  par->width = codec->width;
2183  par->height = codec->height;
2184  break;
2185  }
2186 
2187  if (codec->extradata) {
2189  if (!par->extradata)
2190  return AVERROR(ENOMEM);
2191  memcpy(par->extradata, codec->extradata, codec->extradata_size);
2192  par->extradata_size = codec->extradata_size;
2193  }
2194 
2195  return 0;
2196 }
2197 
2199  const AVCodecParameters *par)
2200 {
2201  codec->codec_type = par->codec_type;
2202  codec->codec_id = par->codec_id;
2203  codec->codec_tag = par->codec_tag;
2204 
2205  codec->bit_rate = par->bit_rate;
2208  codec->profile = par->profile;
2209  codec->level = par->level;
2210 
2211  switch (par->codec_type) {
2212  case AVMEDIA_TYPE_VIDEO:
2213  codec->pix_fmt = par->format;
2214  codec->width = par->width;
2215  codec->height = par->height;
2216  codec->field_order = par->field_order;
2217  codec->color_range = par->color_range;
2218  codec->color_primaries = par->color_primaries;
2219  codec->color_trc = par->color_trc;
2220  codec->colorspace = par->color_space;
2223  codec->has_b_frames = par->video_delay;
2224  break;
2225  case AVMEDIA_TYPE_AUDIO:
2226  codec->sample_fmt = par->format;
2227  codec->channel_layout = par->channel_layout;
2228  codec->channels = par->channels;
2229  codec->sample_rate = par->sample_rate;
2230  codec->block_align = par->block_align;
2231  codec->frame_size = par->frame_size;
2232  codec->delay =
2233  codec->initial_padding = par->initial_padding;
2234  codec->trailing_padding = par->trailing_padding;
2235  codec->seek_preroll = par->seek_preroll;
2236  break;
2237  case AVMEDIA_TYPE_SUBTITLE:
2238  codec->width = par->width;
2239  codec->height = par->height;
2240  break;
2241  }
2242 
2243  if (par->extradata) {
2244  av_freep(&codec->extradata);
2246  if (!codec->extradata)
2247  return AVERROR(ENOMEM);
2248  memcpy(codec->extradata, par->extradata, par->extradata_size);
2249  codec->extradata_size = par->extradata_size;
2250  }
2251 
2252  return 0;
2253 }
2254 
2255 static unsigned bcd2uint(uint8_t bcd)
2256 {
2257  unsigned low = bcd & 0xf;
2258  unsigned high = bcd >> 4;
2259  if (low > 9 || high > 9)
2260  return 0;
2261  return low + 10*high;
2262 }
2263 
2264 int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len,
2265  void **data, size_t *sei_size)
2266 {
2267  AVFrameSideData *sd = NULL;
2268  uint8_t *sei_data;
2269  PutBitContext pb;
2270  uint32_t *tc;
2271  int m;
2272 
2273  if (frame)
2275 
2276  if (!sd) {
2277  *data = NULL;
2278  return 0;
2279  }
2280  tc = (uint32_t*)sd->data;
2281  m = tc[0] & 3;
2282 
2283  *sei_size = sizeof(uint32_t) * 4;
2284  *data = av_mallocz(*sei_size + prefix_len);
2285  if (!*data)
2286  return AVERROR(ENOMEM);
2287  sei_data = (uint8_t*)*data + prefix_len;
2288 
2289  init_put_bits(&pb, sei_data, *sei_size);
2290  put_bits(&pb, 2, m); // num_clock_ts
2291 
2292  for (int j = 1; j <= m; j++) {
2293  uint32_t tcsmpte = tc[j];
2294  unsigned hh = bcd2uint(tcsmpte & 0x3f); // 6-bit hours
2295  unsigned mm = bcd2uint(tcsmpte>>8 & 0x7f); // 7-bit minutes
2296  unsigned ss = bcd2uint(tcsmpte>>16 & 0x7f); // 7-bit seconds
2297  unsigned ff = bcd2uint(tcsmpte>>24 & 0x3f); // 6-bit frames
2298  unsigned drop = tcsmpte & 1<<30 && !0; // 1-bit drop if not arbitrary bit
2299 
2300  /* Calculate frame number of HEVC by SMPTE ST 12-1:2014 Sec 12.2 if rate > 30FPS */
2301  if (av_cmp_q(rate, (AVRational) {30, 1}) == 1) {
2302  unsigned pc;
2303  ff *= 2;
2304  if (av_cmp_q(rate, (AVRational) {50, 1}) == 0)
2305  pc = !!(tcsmpte & 1 << 7);
2306  else
2307  pc = !!(tcsmpte & 1 << 23);
2308  ff = (ff + pc) & 0x7f;
2309  }
2310 
2311  put_bits(&pb, 1, 1); // clock_timestamp_flag
2312  put_bits(&pb, 1, 1); // units_field_based_flag
2313  put_bits(&pb, 5, 0); // counting_type
2314  put_bits(&pb, 1, 1); // full_timestamp_flag
2315  put_bits(&pb, 1, 0); // discontinuity_flag
2316  put_bits(&pb, 1, drop);
2317  put_bits(&pb, 9, ff);
2318  put_bits(&pb, 6, ss);
2319  put_bits(&pb, 6, mm);
2320  put_bits(&pb, 5, hh);
2321  put_bits(&pb, 5, 0);
2322  }
2323  flush_put_bits(&pb);
2324 
2325  return 0;
2326 }
2327 
2329 {
2330  AVRational framerate = avctx->framerate;
2331  int bits_per_coded_sample = avctx->bits_per_coded_sample;
2332  int64_t bitrate;
2333 
2334  if (!(framerate.num && framerate.den))
2335  framerate = av_inv_q(avctx->time_base);
2336  if (!(framerate.num && framerate.den))
2337  return 0;
2338 
2339  if (!bits_per_coded_sample) {
2341  bits_per_coded_sample = av_get_bits_per_pixel(desc);
2342  }
2343  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
2344  framerate.num / framerate.den;
2345 
2346  return bitrate;
2347 }
2348 
2349 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
2350  const int * array_valid_values, int default_value)
2351 {
2352  int i = 0, ref_val;
2353 
2354  while (1) {
2355  ref_val = array_valid_values[i];
2356  if (ref_val == INT_MAX)
2357  break;
2358  if (val == ref_val)
2359  return val;
2360  i++;
2361  }
2362  /* val is not a valid value */
2363  av_log(ctx, AV_LOG_DEBUG,
2364  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
2365  return default_value;
2366 }
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:2328
#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:49
#define FF_SANE_NB_CHANNELS
Definition: internal.h:98
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1601
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:202
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:2111
#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:1323
const struct AVCodec * codec
Definition: avcodec.h:540
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:2062
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:2083
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:291
#define AV_NUM_DATA_POINTERS
Definition: frame.h:315
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:2110
static AVMutex mutex
Definition: log.c:44
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
Definition: avcodec.h:2091
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:314
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
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2123
AVFifoBuffer * pkt_props
Definition: internal.h:151
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:719
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:150
const char * desc
Definition: libsvtav1.c:79
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
AVFrame * f
Definition: thread.h:35
int64_t bit_rate
the average bitrate
Definition: avcodec.h:581
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:136
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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_S32, int32_t, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1<< 16)) 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,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
const char * g
Definition: vf_curves.c:117
#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:298
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:1439
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:303
#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:1358
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
Definition: utils.c:1525
uint32_t fourcc
Definition: vaapi_decode.c:239
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1166
int ff_decode_bsfs_init(AVCodecContext *avctx)
Called during avcodec_open2() to initialize avctx->internal->bsf.
Definition: decode.c:187
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:2109
static void ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
Definition: utils.c:532
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:100
const char * avcodec_license(void)
Return the libavcodec license.
Definition: utils.c:1530
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:910
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:741
#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:2679
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
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:102
#define FF_ARRAY_ELEMS(a)
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:1742
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: utils.c:1946
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:1908
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:1675
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:188
int trailing_padding
Audio only.
Definition: codec_par.h:196
int profile
profile
Definition: avcodec.h:1849
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:1228
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:4077
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:2663
enum AVColorSpace color_space
Definition: codec_par.h:149
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2961
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:654
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:738
AVSubtitleRect ** rects
Definition: avcodec.h:2680
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
Definition: avcodec.h:2529
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:1989
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:495
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:1976
#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:41
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:2337
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:1199
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:2901
void * thread_ctx
Definition: internal.h:141
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:2231
Multithreading support functions.
#define AV_NE(be, le)
Definition: common.h:50
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2102
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:2175
#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:282
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
#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:91
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:2198
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:2051
Public header for CRC hash function implementation.
void * frame_thread_encoder
Definition: internal.h:159
int initial_padding
Audio only.
Definition: codec_par.h:189
Structure to hold side data for an AVFrame.
Definition: frame.h:220
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
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:1597
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:1643
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1749
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:2255
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:1878
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:1735
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
static struct @321 state
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:2037
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1173
static void codec_parameters_reset(AVCodecParameters *par)
Definition: utils.c:2082
#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:2112
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:1600
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:1902
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:255
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:1173
AVBSFContext * bsf
Definition: internal.h:144
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:2982
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:372
#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:821
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1625
#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
const struct AVCodecHWConfigInternal *const * hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
Definition: codec.h:323
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:2349
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:90
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:1914
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:1382
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:2092
AVFrame * in_frame
Definition: internal.h:117
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1787
enum AVColorPrimaries color_primaries
Definition: codec_par.h:147
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1999
int video_delay
Video only.
Definition: codec_par.h:155
const char * r
Definition: vf_curves.c:116
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
Definition: avstring.c:451
AVFrame * buffer_frame
Definition: internal.h:182
int capabilities
Codec capabilities.
Definition: codec.h:209
int initial_padding
Audio only.
Definition: avcodec.h:2053
unsigned int pos
Definition: spdifenc.c:412
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:1857
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:425
#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:611
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:940
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:2239
const struct AVProfile * profiles
If non-NULL, an array of profiles recognized for this codec.
Definition: codec_desc.h:65
int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for S12M timecode side data and allocate and fill TC SEI message with timecode info...
Definition: utils.c:2264
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:103
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:1847
#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:2919
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
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:1396
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:235
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
int refs
number of reference frames
Definition: avcodec.h:1119
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:1779
#define FFMIN(a, b)
Definition: common.h:105
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2184
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:1536
AVFrame * compat_decode_frame
Definition: internal.h:193
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1993
int width
picture width / height.
Definition: avcodec.h:704
static void ff_unlock_avcodec(const AVCodec *codec)
Definition: utils.c:538
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2209
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1850
int priv_data_size
Definition: codec.h:238
int profile
Definition: codec.h:177
AVPacket * in_pkt
Definition: internal.h:113
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:1145
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:188
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:210
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:1975
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:1963
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
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:663
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:143
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:2100
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:2658
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:176
#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:1768
Full range content.
Definition: pixfmt.h:586
int sub_charenc_mode
Subtitles character encoding mode.
Definition: avcodec.h:2108
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:1094
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:387
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:1487
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1211
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:453
int(* decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt)
Definition: codec.h:284
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:2205
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:1897
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1692
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:539
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
EncodeSimpleContext es
Definition: internal.h:161
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:1603
enum AVCodecID codec_id
Definition: avcodec.h:541
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
int seek_preroll
Number of samples to skip after a discontinuity.
Definition: avcodec.h:2133
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1656
int sample_rate
samples per second
Definition: avcodec.h:1191
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1885
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
main external API structure.
Definition: avcodec.h:531
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
int skip_samples_multiplier
Definition: internal.h:199
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:1375
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1154
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:556
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:1902
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
Definition: encode_audio.c:95
uint8_t * data
Definition: frame.h:222
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:633
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1864
int nb_coded_side_data
Definition: avcodec.h:2185
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:719
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:194
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2176
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:1346
int(* init)(struct AVCodecContext *)
Definition: codec.h:269
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:726
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
int index
Definition: gxfenc.c:89
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
Definition: samplefmt.c:119
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1159
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1152
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:1957
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:2141
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:244
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian ...
Definition: pixfmt.h:345
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:256
char * codec_whitelist
&#39;,&#39; separated list of allowed decoders.
Definition: avcodec.h:2167
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:109
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:544
#define snprintf
Definition: snprintf.h:34
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1838
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:1363
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:945
AVBufferRef * pool
Definition: internal.h:139
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:93
mfxU16 profile
Definition: qsvenc.c: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
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:187
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int bits_per_raw_sample
This is the number of valid bits in each output sample.
Definition: 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:328
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:181
int64_t bitrate
Definition: h264_levels.c:131
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:75
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:247
Y , 8bpp.
Definition: pixfmt.h:74
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1611
const OptionDef options[]
Definition: ffmpeg_opt.c:3424
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
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:117
#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:61
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:2940
int(* encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: codec.h:270
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:171
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:1975
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1759
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:1967
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
static const uint64_t c2
Definition: murmur3.c:52
#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:308
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1250
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2174
attribute_deprecated int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:1803
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:64
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:1598
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:1292
#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:558
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:1271
int(* close)(struct AVCodecContext *)
Definition: codec.h:285
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.
uint8_t * dump_separator
dump format separator.
Definition: avcodec.h:2159
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:1922
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
#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:442
int len
int channels
number of audio channels
Definition: avcodec.h:1192
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:566
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Definition: utils.c:1515
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:2670
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:613
signed 64 bits, planar
Definition: samplefmt.h:72
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:618
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:157
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:1971
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:2093
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1222
int height
Definition: frame.h:372
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:2090
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:1188
signed 16 bits, planar
Definition: samplefmt.h:67
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:605
static float sub(float src0, float src1)
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:40
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:175
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
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:1951
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:1980
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:2004
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:1985
void av_fifo_reset(AVFifoBuffer *f)
Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied...
Definition: fifo.c:71
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:361
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:2261
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:156
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:1500
static int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
Definition: mem_internal.h:139
int delay
Codec delay.
Definition: avcodec.h:687
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:380
#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:1596
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:2069
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:104
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1778
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
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1411
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:2007
static uint8_t tmp[11]
Definition: aes_ctr.c:27
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:160
bitstream writer API