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/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mem_internal.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/pixfmt.h"
36 #include "avcodec.h"
37 #include "codec.h"
38 #include "hwconfig.h"
39 #include "thread.h"
40 #include "internal.h"
41 #include "put_bits.h"
42 #include "raw.h"
43 #include "version.h"
44 #include <stdlib.h>
45 #include <stdarg.h>
46 #include <stdatomic.h>
47 #include <limits.h>
48 #include <float.h>
49 
50 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
51 {
52  uint8_t **p = ptr;
53  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
54  av_freep(p);
55  *size = 0;
56  return;
57  }
58  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
59  memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
60 }
61 
62 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
63 {
64  uint8_t **p = ptr;
65  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
66  av_freep(p);
67  *size = 0;
68  return;
69  }
70  if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
71  memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
72 }
73 
74 int av_codec_is_encoder(const AVCodec *codec)
75 {
76  return codec && (codec->encode_sub || codec->encode2 || codec->receive_packet);
77 }
78 
79 int av_codec_is_decoder(const AVCodec *codec)
80 {
81  return codec && (codec->decode || codec->receive_frame);
82 }
83 
85 {
86  int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
87 
88  if (ret < 0)
89  width = height = 0;
90 
91  s->coded_width = width;
92  s->coded_height = height;
93  s->width = AV_CEIL_RSHIFT(width, s->lowres);
94  s->height = AV_CEIL_RSHIFT(height, s->lowres);
95 
96  return ret;
97 }
98 
100 {
101  int ret = av_image_check_sar(avctx->width, avctx->height, sar);
102 
103  if (ret < 0) {
104  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
105  sar.num, sar.den);
106  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
107  return ret;
108  } else {
109  avctx->sample_aspect_ratio = sar;
110  }
111  return 0;
112 }
113 
115  enum AVMatrixEncoding matrix_encoding)
116 {
117  AVFrameSideData *side_data;
118  enum AVMatrixEncoding *data;
119 
121  if (!side_data)
123  sizeof(enum AVMatrixEncoding));
124 
125  if (!side_data)
126  return AVERROR(ENOMEM);
127 
128  data = (enum AVMatrixEncoding*)side_data->data;
129  *data = matrix_encoding;
130 
131  return 0;
132 }
133 
135  int linesize_align[AV_NUM_DATA_POINTERS])
136 {
137  int i;
138  int w_align = 1;
139  int h_align = 1;
140  AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
141 
142  if (desc) {
143  w_align = 1 << desc->log2_chroma_w;
144  h_align = 1 << desc->log2_chroma_h;
145  }
146 
147  switch (s->pix_fmt) {
148  case AV_PIX_FMT_YUV420P:
149  case AV_PIX_FMT_YUYV422:
150  case AV_PIX_FMT_YVYU422:
151  case AV_PIX_FMT_UYVY422:
152  case AV_PIX_FMT_YUV422P:
153  case AV_PIX_FMT_YUV440P:
154  case AV_PIX_FMT_YUV444P:
155  case AV_PIX_FMT_GBRP:
156  case AV_PIX_FMT_GBRAP:
157  case AV_PIX_FMT_GRAY8:
158  case AV_PIX_FMT_GRAY16BE:
159  case AV_PIX_FMT_GRAY16LE:
160  case AV_PIX_FMT_YUVJ420P:
161  case AV_PIX_FMT_YUVJ422P:
162  case AV_PIX_FMT_YUVJ440P:
163  case AV_PIX_FMT_YUVJ444P:
164  case AV_PIX_FMT_YUVA420P:
165  case AV_PIX_FMT_YUVA422P:
166  case AV_PIX_FMT_YUVA444P:
223  case AV_PIX_FMT_GBRP9LE:
224  case AV_PIX_FMT_GBRP9BE:
225  case AV_PIX_FMT_GBRP10LE:
226  case AV_PIX_FMT_GBRP10BE:
227  case AV_PIX_FMT_GBRP12LE:
228  case AV_PIX_FMT_GBRP12BE:
229  case AV_PIX_FMT_GBRP14LE:
230  case AV_PIX_FMT_GBRP14BE:
231  case AV_PIX_FMT_GBRP16LE:
232  case AV_PIX_FMT_GBRP16BE:
237  w_align = 16; //FIXME assume 16 pixel per macroblock
238  h_align = 16 * 2; // interlaced needs 2 macroblocks height
239  break;
240  case AV_PIX_FMT_YUV411P:
241  case AV_PIX_FMT_YUVJ411P:
243  w_align = 32;
244  h_align = 16 * 2;
245  break;
246  case AV_PIX_FMT_YUV410P:
247  if (s->codec_id == AV_CODEC_ID_SVQ1) {
248  w_align = 64;
249  h_align = 64;
250  }
251  break;
252  case AV_PIX_FMT_RGB555:
253  if (s->codec_id == AV_CODEC_ID_RPZA) {
254  w_align = 4;
255  h_align = 4;
256  }
257  if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
258  w_align = 8;
259  h_align = 8;
260  }
261  break;
262  case AV_PIX_FMT_PAL8:
263  case AV_PIX_FMT_BGR8:
264  case AV_PIX_FMT_RGB8:
265  if (s->codec_id == AV_CODEC_ID_SMC ||
266  s->codec_id == AV_CODEC_ID_CINEPAK) {
267  w_align = 4;
268  h_align = 4;
269  }
270  if (s->codec_id == AV_CODEC_ID_JV ||
271  s->codec_id == AV_CODEC_ID_ARGO ||
272  s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
273  w_align = 8;
274  h_align = 8;
275  }
276  if (s->codec_id == AV_CODEC_ID_MJPEG ||
277  s->codec_id == AV_CODEC_ID_MJPEGB ||
278  s->codec_id == AV_CODEC_ID_LJPEG ||
279  s->codec_id == AV_CODEC_ID_SMVJPEG ||
280  s->codec_id == AV_CODEC_ID_AMV ||
281  s->codec_id == AV_CODEC_ID_SP5X ||
282  s->codec_id == AV_CODEC_ID_JPEGLS) {
283  w_align = 8;
284  h_align = 2*8;
285  }
286  break;
287  case AV_PIX_FMT_BGR24:
288  if ((s->codec_id == AV_CODEC_ID_MSZH) ||
289  (s->codec_id == AV_CODEC_ID_ZLIB)) {
290  w_align = 4;
291  h_align = 4;
292  }
293  break;
294  case AV_PIX_FMT_RGB24:
295  if (s->codec_id == AV_CODEC_ID_CINEPAK) {
296  w_align = 4;
297  h_align = 4;
298  }
299  break;
300  case AV_PIX_FMT_BGR0:
301  if (s->codec_id == AV_CODEC_ID_ARGO) {
302  w_align = 8;
303  h_align = 8;
304  }
305  break;
306  default:
307  break;
308  }
309 
310  if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
311  w_align = FFMAX(w_align, 8);
312  }
313 
314  *width = FFALIGN(*width, w_align);
315  *height = FFALIGN(*height, h_align);
316  if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
317  s->codec_id == AV_CODEC_ID_VP5 || s->codec_id == AV_CODEC_ID_VP6 ||
318  s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A
319  ) {
320  // some of the optimized chroma MC reads one line too much
321  // which is also done in mpeg decoders with lowres > 0
322  *height += 2;
323 
324  // H.264 uses edge emulation for out of frame motion vectors, for this
325  // it requires a temporary area large enough to hold a 21x21 block,
326  // increasing witdth ensure that the temporary area is large enough,
327  // the next rounded up width is 32
328  *width = FFMAX(*width, 32);
329  }
330 
331  for (i = 0; i < 4; i++)
332  linesize_align[i] = STRIDE_ALIGN;
333 }
334 
336 {
337  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
338  int chroma_shift = desc->log2_chroma_w;
339  int linesize_align[AV_NUM_DATA_POINTERS];
340  int align;
341 
342  avcodec_align_dimensions2(s, width, height, linesize_align);
343  align = FFMAX(linesize_align[0], linesize_align[3]);
344  linesize_align[1] <<= chroma_shift;
345  linesize_align[2] <<= chroma_shift;
346  align = FFMAX3(align, linesize_align[1], linesize_align[2]);
347  *width = FFALIGN(*width, align);
348 }
349 
350 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
351 {
352  if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
353  return AVERROR(EINVAL);
354  pos--;
355 
356  *xpos = (pos&1) * 128;
357  *ypos = ((pos>>1)^(pos<4)) * 128;
358 
359  return 0;
360 }
361 
363 {
364  int pos, xout, yout;
365 
367  if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
368  return pos;
369  }
371 }
372 
374  enum AVSampleFormat sample_fmt, const uint8_t *buf,
375  int buf_size, int align)
376 {
377  int ch, planar, needed_size, ret = 0;
378 
380  frame->nb_samples, sample_fmt,
381  align);
382  if (buf_size < needed_size)
383  return AVERROR(EINVAL);
384 
385  planar = av_sample_fmt_is_planar(sample_fmt);
387  if (!(frame->extended_data = av_mallocz_array(nb_channels,
388  sizeof(*frame->extended_data))))
389  return AVERROR(ENOMEM);
390  } else {
391  frame->extended_data = frame->data;
392  }
393 
394  if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
395  (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
396  sample_fmt, align)) < 0) {
397  if (frame->extended_data != frame->data)
398  av_freep(&frame->extended_data);
399  return ret;
400  }
401  if (frame->extended_data != frame->data) {
402  for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
403  frame->data[ch] = frame->extended_data[ch];
404  }
405 
406  return ret;
407 }
408 
409 void ff_color_frame(AVFrame *frame, const int c[4])
410 {
412  int p, y;
413 
415 
416  for (p = 0; p<desc->nb_components; p++) {
417  uint8_t *dst = frame->data[p];
418  int is_chroma = p == 1 || p == 2;
419  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
420  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
421  if (desc->comp[0].depth >= 9) {
422  ((uint16_t*)dst)[0] = c[p];
423  av_memcpy_backptr(dst + 2, 2, bytes - 2);
424  dst += frame->linesize[p];
425  for (y = 1; y < height; y++) {
426  memcpy(dst, frame->data[p], 2*bytes);
427  dst += frame->linesize[p];
428  }
429  } else {
430  for (y = 0; y < height; y++) {
431  memset(dst, c[p], bytes);
432  dst += frame->linesize[p];
433  }
434  }
435  }
436 }
437 
439  unsigned int fourcc)
440 {
441  while (tags->pix_fmt >= 0) {
442  if (tags->fourcc == fourcc)
443  return tags->pix_fmt;
444  tags++;
445  }
446  return AV_PIX_FMT_NONE;
447 }
448 
449 #if FF_API_CODEC_GET_SET
450 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
451 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
453 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
454 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
455 
457 {
458  return codec->properties;
459 }
460 
462 {
463  return codec->max_lowres;
464 }
465 #endif
466 
469 }
470 
471 const char *avcodec_get_name(enum AVCodecID id)
472 {
473  const AVCodecDescriptor *cd;
474  const AVCodec *codec;
475 
476  if (id == AV_CODEC_ID_NONE)
477  return "none";
478  cd = avcodec_descriptor_get(id);
479  if (cd)
480  return cd->name;
481  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
482  codec = avcodec_find_decoder(id);
483  if (codec)
484  return codec->name;
485  codec = avcodec_find_encoder(id);
486  if (codec)
487  return codec->name;
488  return "unknown_codec";
489 }
490 
491 #if FF_API_TAG_STRING
492 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
493 {
494  int i, len, ret = 0;
495 
496 #define TAG_PRINT(x) \
497  (((x) >= '0' && (x) <= '9') || \
498  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
499  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
500 
501  for (i = 0; i < 4; i++) {
502  len = snprintf(buf, buf_size,
503  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
504  buf += len;
505  buf_size = buf_size > len ? buf_size - len : 0;
506  ret += len;
507  codec_tag >>= 8;
508  }
509  return ret;
510 }
511 #endif
512 
513 const char *av_get_profile_name(const AVCodec *codec, int profile)
514 {
515  const AVProfile *p;
516  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
517  return NULL;
518 
519  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
520  if (p->profile == profile)
521  return p->name;
522 
523  return NULL;
524 }
525 
527 {
529  const AVProfile *p;
530 
531  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
532  return NULL;
533 
534  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
535  if (p->profile == profile)
536  return p->name;
537 
538  return NULL;
539 }
540 
542 {
543  switch (codec_id) {
559  return 4;
567  case AV_CODEC_ID_PCM_S8:
569  case AV_CODEC_ID_PCM_SGA:
570  case AV_CODEC_ID_PCM_U8:
573  return 8;
580  return 16;
587  return 24;
597  return 32;
602  return 64;
603  default:
604  return 0;
605  }
606 }
607 
609 {
610  static const enum AVCodecID map[][2] = {
622  };
623  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
624  return AV_CODEC_ID_NONE;
625  if (be < 0 || be > 1)
626  be = AV_NE(1, 0);
627  return map[fmt][be];
628 }
629 
631 {
632  switch (codec_id) {
634  return 2;
636  return 3;
642  return 4;
643  default:
645  }
646 }
647 
648 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
649  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
650  uint8_t * extradata, int frame_size, int frame_bytes)
651 {
653  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
654 
655  /* codecs with an exact constant bits per sample */
656  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
657  return (frame_bytes * 8LL) / (bps * ch);
658  bps = bits_per_coded_sample;
659 
660  /* codecs with a fixed packet duration */
661  switch (id) {
662  case AV_CODEC_ID_ADPCM_ADX: return 32;
663  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
664  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
665  case AV_CODEC_ID_AMR_NB:
666  case AV_CODEC_ID_EVRC:
667  case AV_CODEC_ID_GSM:
668  case AV_CODEC_ID_QCELP:
669  case AV_CODEC_ID_RA_288: return 160;
670  case AV_CODEC_ID_AMR_WB:
671  case AV_CODEC_ID_GSM_MS: return 320;
672  case AV_CODEC_ID_MP1: return 384;
673  case AV_CODEC_ID_ATRAC1: return 512;
674  case AV_CODEC_ID_ATRAC9:
675  case AV_CODEC_ID_ATRAC3:
676  if (framecount > INT_MAX/1024)
677  return 0;
678  return 1024 * framecount;
679  case AV_CODEC_ID_ATRAC3P: return 2048;
680  case AV_CODEC_ID_MP2:
681  case AV_CODEC_ID_MUSEPACK7: return 1152;
682  case AV_CODEC_ID_AC3: return 1536;
683  }
684 
685  if (sr > 0) {
686  /* calc from sample rate */
687  if (id == AV_CODEC_ID_TTA)
688  return 256 * sr / 245;
689  else if (id == AV_CODEC_ID_DST)
690  return 588 * sr / 44100;
691  else if (id == AV_CODEC_ID_BINKAUDIO_DCT) {
692  if (sr / 22050 > 22)
693  return 0;
694  return (480 << (sr / 22050));
695  }
696 
697  if (id == AV_CODEC_ID_MP3)
698  return sr <= 24000 ? 576 : 1152;
699  }
700 
701  if (ba > 0) {
702  /* calc from block_align */
703  if (id == AV_CODEC_ID_SIPR) {
704  switch (ba) {
705  case 20: return 160;
706  case 19: return 144;
707  case 29: return 288;
708  case 37: return 480;
709  }
710  } else if (id == AV_CODEC_ID_ILBC) {
711  switch (ba) {
712  case 38: return 160;
713  case 50: return 240;
714  }
715  }
716  }
717 
718  if (frame_bytes > 0) {
719  /* calc from frame_bytes only */
720  if (id == AV_CODEC_ID_TRUESPEECH)
721  return 240 * (frame_bytes / 32);
722  if (id == AV_CODEC_ID_NELLYMOSER)
723  return 256 * (frame_bytes / 64);
724  if (id == AV_CODEC_ID_RA_144)
725  return 160 * (frame_bytes / 20);
726 
727  if (bps > 0) {
728  /* calc from frame_bytes and bits_per_coded_sample */
730  return frame_bytes * 8 / bps;
731  }
732 
733  if (ch > 0 && ch < INT_MAX/16) {
734  /* calc from frame_bytes and channels */
735  switch (id) {
737  return frame_bytes / (40 * ch) * 256;
739  return (frame_bytes - 4 * ch) / (128 * ch) * 256;
741  return frame_bytes / (9 * ch) * 16;
744  frame_bytes /= 16 * ch;
745  if (frame_bytes > INT_MAX / 28)
746  return 0;
747  return frame_bytes * 28;
751  return (frame_bytes - 4 * ch) * 2 / ch;
753  return (frame_bytes - 4) * 2 / ch;
755  return (frame_bytes - 8) * 2;
758  if (extradata)
759  return frame_bytes * 14LL / (8 * ch);
760  break;
762  return (frame_bytes / 128) * 224 / ch;
764  return (frame_bytes - 6 - ch) / ch;
766  return (frame_bytes - 8) / ch;
768  return (frame_bytes - 2 * ch) / ch;
769  case AV_CODEC_ID_MACE3:
770  return 3 * frame_bytes / ch;
771  case AV_CODEC_ID_MACE6:
772  return 6 * frame_bytes / ch;
773  case AV_CODEC_ID_PCM_LXF:
774  return 2 * (frame_bytes / (5 * ch));
775  case AV_CODEC_ID_IAC:
776  case AV_CODEC_ID_IMC:
777  return 4 * frame_bytes / ch;
778  }
779 
780  if (tag) {
781  /* calc from frame_bytes, channels, and codec_tag */
782  if (id == AV_CODEC_ID_SOL_DPCM) {
783  if (tag == 3)
784  return frame_bytes / ch;
785  else
786  return frame_bytes * 2 / ch;
787  }
788  }
789 
790  if (ba > 0) {
791  /* calc from frame_bytes, channels, and block_align */
792  int blocks = frame_bytes / ba;
793  int64_t tmp = 0;
794  switch (id) {
796  if (bps < 2 || bps > 5)
797  return 0;
798  tmp = blocks * (1LL + (ba - 4 * ch) / (bps * ch) * 8);
799  break;
801  tmp = blocks * (((ba - 16LL) * 2 / 3 * 4) / ch);
802  break;
804  tmp = blocks * (1 + (ba - 4LL * ch) * 2 / ch);
805  break;
807  tmp = blocks * ((ba - 4LL * ch) * 2 / ch);
808  break;
810  tmp = blocks * (2 + (ba - 7LL * ch) * 2LL / ch);
811  break;
813  tmp = blocks * (ba - 16LL) * 2 / ch;
814  break;
815  }
816  if (tmp) {
817  if (tmp != (int)tmp)
818  return 0;
819  return tmp;
820  }
821  }
822 
823  if (bps > 0) {
824  /* calc from frame_bytes, channels, and bits_per_coded_sample */
825  switch (id) {
826  case AV_CODEC_ID_PCM_DVD:
827  if(bps<4 || frame_bytes<3)
828  return 0;
829  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
831  if(bps<4 || frame_bytes<4)
832  return 0;
833  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
834  case AV_CODEC_ID_S302M:
835  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
836  }
837  }
838  }
839  }
840 
841  /* Fall back on using frame_size */
842  if (frame_size > 1 && frame_bytes)
843  return frame_size;
844 
845  //For WMA we currently have no other means to calculate duration thus we
846  //do it here by assuming CBR, which is true for all known cases.
847  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
848  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
849  return (frame_bytes * 8LL * sr) / bitrate;
850  }
851 
852  return 0;
853 }
854 
855 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
856 {
858  avctx->channels, avctx->block_align,
859  avctx->codec_tag, avctx->bits_per_coded_sample,
860  avctx->bit_rate, avctx->extradata, avctx->frame_size,
861  frame_bytes);
862  return FFMAX(0, duration);
863 }
864 
866 {
868  par->channels, par->block_align,
869  par->codec_tag, par->bits_per_coded_sample,
870  par->bit_rate, par->extradata, par->frame_size,
871  frame_bytes);
872  return FFMAX(0, duration);
873 }
874 
875 #if !HAVE_THREADS
877 {
878  return -1;
879 }
880 
881 #endif
882 
883 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
884 {
885  unsigned int n = 0;
886 
887  while (v >= 0xff) {
888  *s++ = 0xff;
889  v -= 0xff;
890  n++;
891  }
892  *s = v;
893  n++;
894  return n;
895 }
896 
897 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
898 {
899  int i;
900  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
901  return i;
902 }
903 
905 {
906  int i;
907  if (!codec->hw_configs || index < 0)
908  return NULL;
909  for (i = 0; i <= index; i++)
910  if (!codec->hw_configs[i])
911  return NULL;
912  return &codec->hw_configs[index]->public;
913 }
914 
915 #if FF_API_USER_VISIBLE_AVHWACCEL
917 {
918  return NULL;
919 }
920 
922 {
923 }
924 #endif
925 
926 unsigned int avpriv_toupper4(unsigned int x)
927 {
928  return av_toupper(x & 0xFF) +
929  (av_toupper((x >> 8) & 0xFF) << 8) +
930  (av_toupper((x >> 16) & 0xFF) << 16) +
931 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
932 }
933 
935 {
936  int ret;
937 
938  dst->owner[0] = src->owner[0];
939  dst->owner[1] = src->owner[1];
940 
941  ret = av_frame_ref(dst->f, src->f);
942  if (ret < 0)
943  return ret;
944 
945  av_assert0(!dst->progress);
946 
947  if (src->progress &&
948  !(dst->progress = av_buffer_ref(src->progress))) {
949  ff_thread_release_buffer(dst->owner[0], dst);
950  return AVERROR(ENOMEM);
951  }
952 
953  return 0;
954 }
955 
956 #if !HAVE_THREADS
957 
959 {
960  return ff_get_format(avctx, fmt);
961 }
962 
964 {
965  f->owner[0] = f->owner[1] = avctx;
966  return ff_get_buffer(avctx, f->f, flags);
967 }
968 
970 {
971  if (f->f)
972  av_frame_unref(f->f);
973 }
974 
976 {
977 }
978 
979 void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
980 {
981 }
982 
983 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
984 {
985 }
986 
988 {
989  return 1;
990 }
991 
992 int ff_alloc_entries(AVCodecContext *avctx, int count)
993 {
994  return 0;
995 }
996 
998 {
999 }
1000 
1001 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
1002 {
1003 }
1004 
1005 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
1006 {
1007 }
1008 
1009 #endif
1010 
1011 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
1012  const uint8_t *end,
1013  uint32_t *av_restrict state)
1014 {
1015  int i;
1016 
1017  av_assert0(p <= end);
1018  if (p >= end)
1019  return end;
1020 
1021  for (i = 0; i < 3; i++) {
1022  uint32_t tmp = *state << 8;
1023  *state = tmp + *(p++);
1024  if (tmp == 0x100 || p == end)
1025  return p;
1026  }
1027 
1028  while (p < end) {
1029  if (p[-1] > 1 ) p += 3;
1030  else if (p[-2] ) p += 2;
1031  else if (p[-3]|(p[-1]-1)) p++;
1032  else {
1033  p++;
1034  break;
1035  }
1036  }
1037 
1038  p = FFMIN(p, end) - 4;
1039  *state = AV_RB32(p);
1040 
1041  return p + 4;
1042 }
1043 
1045 {
1046  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1047  if (!props)
1048  return NULL;
1049 
1050  if (size)
1051  *size = sizeof(*props);
1052 
1053  props->vbv_delay = UINT64_MAX;
1054 
1055  return props;
1056 }
1057 
1059 {
1061  AVCPBProperties *props;
1062  size_t size;
1063  int i;
1064 
1065  for (i = 0; i < avctx->nb_coded_side_data; i++)
1067  return (AVCPBProperties *)avctx->coded_side_data[i].data;
1068 
1069  props = av_cpb_properties_alloc(&size);
1070  if (!props)
1071  return NULL;
1072 
1073  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
1074  if (!tmp) {
1075  av_freep(&props);
1076  return NULL;
1077  }
1078 
1079  avctx->coded_side_data = tmp;
1080  avctx->nb_coded_side_data++;
1081 
1083  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
1084  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
1085 
1086  return props;
1087 }
1088 
1089 static unsigned bcd2uint(uint8_t bcd)
1090 {
1091  unsigned low = bcd & 0xf;
1092  unsigned high = bcd >> 4;
1093  if (low > 9 || high > 9)
1094  return 0;
1095  return low + 10*high;
1096 }
1097 
1098 int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len,
1099  void **data, size_t *sei_size)
1100 {
1101  AVFrameSideData *sd = NULL;
1102  uint8_t *sei_data;
1103  PutBitContext pb;
1104  uint32_t *tc;
1105  int m;
1106 
1107  if (frame)
1109 
1110  if (!sd) {
1111  *data = NULL;
1112  return 0;
1113  }
1114  tc = (uint32_t*)sd->data;
1115  m = tc[0] & 3;
1116 
1117  *sei_size = sizeof(uint32_t) * 4;
1118  *data = av_mallocz(*sei_size + prefix_len);
1119  if (!*data)
1120  return AVERROR(ENOMEM);
1121  sei_data = (uint8_t*)*data + prefix_len;
1122 
1123  init_put_bits(&pb, sei_data, *sei_size);
1124  put_bits(&pb, 2, m); // num_clock_ts
1125 
1126  for (int j = 1; j <= m; j++) {
1127  uint32_t tcsmpte = tc[j];
1128  unsigned hh = bcd2uint(tcsmpte & 0x3f); // 6-bit hours
1129  unsigned mm = bcd2uint(tcsmpte>>8 & 0x7f); // 7-bit minutes
1130  unsigned ss = bcd2uint(tcsmpte>>16 & 0x7f); // 7-bit seconds
1131  unsigned ff = bcd2uint(tcsmpte>>24 & 0x3f); // 6-bit frames
1132  unsigned drop = tcsmpte & 1<<30 && !0; // 1-bit drop if not arbitrary bit
1133 
1134  /* Calculate frame number of HEVC by SMPTE ST 12-1:2014 Sec 12.2 if rate > 30FPS */
1135  if (av_cmp_q(rate, (AVRational) {30, 1}) == 1) {
1136  unsigned pc;
1137  ff *= 2;
1138  if (av_cmp_q(rate, (AVRational) {50, 1}) == 0)
1139  pc = !!(tcsmpte & 1 << 7);
1140  else
1141  pc = !!(tcsmpte & 1 << 23);
1142  ff = (ff + pc) & 0x7f;
1143  }
1144 
1145  put_bits(&pb, 1, 1); // clock_timestamp_flag
1146  put_bits(&pb, 1, 1); // units_field_based_flag
1147  put_bits(&pb, 5, 0); // counting_type
1148  put_bits(&pb, 1, 1); // full_timestamp_flag
1149  put_bits(&pb, 1, 0); // discontinuity_flag
1150  put_bits(&pb, 1, drop);
1151  put_bits(&pb, 9, ff);
1152  put_bits(&pb, 6, ss);
1153  put_bits(&pb, 6, mm);
1154  put_bits(&pb, 5, hh);
1155  put_bits(&pb, 5, 0);
1156  }
1157  flush_put_bits(&pb);
1158 
1159  return 0;
1160 }
1161 
1163 {
1164  AVRational framerate = avctx->framerate;
1165  int bits_per_coded_sample = avctx->bits_per_coded_sample;
1166  int64_t bitrate;
1167 
1168  if (!(framerate.num && framerate.den))
1169  framerate = av_inv_q(avctx->time_base);
1170  if (!(framerate.num && framerate.den))
1171  return 0;
1172 
1173  if (!bits_per_coded_sample) {
1175  bits_per_coded_sample = av_get_bits_per_pixel(desc);
1176  }
1177  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
1178  framerate.num / framerate.den;
1179 
1180  return bitrate;
1181 }
1182 
1183 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
1184  const int * array_valid_values, int default_value)
1185 {
1186  int i = 0, ref_val;
1187 
1188  while (1) {
1189  ref_val = array_valid_values[i];
1190  if (ref_val == INT_MAX)
1191  break;
1192  if (val == ref_val)
1193  return val;
1194  i++;
1195  }
1196  /* val is not a valid value */
1198  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
1199  return default_value;
1200 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
hwconfig.h
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1216
AV_CODEC_ID_MACE6
@ AV_CODEC_ID_MACE6
Definition: codec_id.h:434
be
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
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
av_codec_get_codec_properties
unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
Definition: utils.c:456
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:141
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:333
AV_CODEC_ID_DSD_LSBF
@ AV_CODEC_ID_DSD_LSBF
Definition: codec_id.h:498
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
AV_CODEC_ID_ADPCM_MS
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:359
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_CODEC_ID_ADPCM_IMA_QT
@ AV_CODEC_ID_ADPCM_IMA_QT
Definition: codec_id.h:353
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:427
AVERROR
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
av_xiphlacing
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:883
AV_CODEC_ID_PCM_BLURAY
@ AV_CODEC_ID_PCM_BLURAY
Definition: codec_id.h:337
mem_internal.h
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1326
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: utils.c:963
AV_CODEC_ID_ADPCM_DTK
@ AV_CODEC_ID_ADPCM_DTK
Definition: codec_id.h:387
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
PixelFormatTag
Definition: raw.h:34
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:738
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:174
ff_thread_report_progress2
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:1005
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:185
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
AV_CODEC_ID_8SVX_EXP
@ AV_CODEC_ID_8SVX_EXP
Definition: codec_id.h:478
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:249
ff_thread_await_progress2
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:1001
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:926
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, buffer_size_t size)
Add a new side data to a frame.
Definition: frame.c:726
AVCodecDescriptor::name
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:2193
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: utils.c:987
av_samples_fill_arrays
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
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:57
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
state
static struct @321 state
AV_CODEC_ID_PCM_S32LE_PLANAR
@ AV_CODEC_ID_PCM_S32LE_PLANAR
Definition: codec_id.h:342
profile
mfxU16 profile
Definition: qsvenc.c:45
AV_CODEC_ID_FASTAUDIO
@ AV_CODEC_ID_FASTAUDIO
Definition: codec_id.h:519
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:410
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AV_PIX_FMT_YUVA444P10BE
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:188
pixdesc.h
AV_PIX_FMT_YUV440P12BE
@ AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:278
AVPacketSideData
Definition: packet.h:306
internal.h
ff_fast_malloc
static int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
Definition: mem_internal.h:139
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:343
av_codec_get_max_lowres
int av_codec_get_max_lowres(const AVCodec *codec)
Definition: utils.c:461
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:140
TAG_PRINT
#define TAG_PRINT(x)
b
#define b
Definition: input.c:41
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
data
const char data[16]
Definition: mxf.c:142
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:327
AV_PIX_FMT_YUV420P14BE
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:244
avcodec_align_dimensions
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:335
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:406
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:131
AV_CODEC_ID_ADPCM_AICA
@ AV_CODEC_ID_ADPCM_AICA
Definition: codec_id.h:392
AV_CODEC_ID_ADPCM_IMA_OKI
@ AV_CODEC_ID_ADPCM_IMA_OKI
Definition: codec_id.h:386
AV_CODEC_ID_PCM_SGA
@ AV_CODEC_ID_PCM_SGA
Definition: codec_id.h:350
version.h
AV_CODEC_ID_SOL_DPCM
@ AV_CODEC_ID_SOL_DPCM
Definition: codec_id.h:417
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
float.h
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:432
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:381
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:256
avcodec_profile_name
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:526
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
av_get_bits_per_pixel
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
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
AV_CODEC_ID_IMC
@ AV_CODEC_ID_IMC
Definition: codec_id.h:451
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:182
AV_PIX_FMT_YUV422P9BE
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:166
thread.h
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:331
AV_CODEC_ID_ADPCM_THP_LE
@ AV_CODEC_ID_ADPCM_THP_LE
Definition: codec_id.h:390
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:407
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:135
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:345
AVProfile
AVProfile.
Definition: codec.h:183
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:288
AV_CODEC_ID_DSD_MSBF_PLANAR
@ AV_CODEC_ID_DSD_MSBF_PLANAR
Definition: codec_id.h:501
AV_CODEC_ID_ADPCM_CT
@ AV_CODEC_ID_ADPCM_CT
Definition: codec_id.h:365
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2071
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
framerate
int framerate
Definition: h264_levels.c:65
AVCodec::max_lowres
uint8_t max_lowres
maximum value for lowres supported by the decoder
Definition: codec.h:222
avcodec_enum_to_chroma_pos
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
Definition: utils.c:350
AVPacketSideData::size
size_t size
Definition: packet.h:311
AVHWAccel
Definition: avcodec.h:2438
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AV_CODEC_ID_IFF_ILBM
@ AV_CODEC_ID_IFF_ILBM
Definition: codec_id.h:185
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:243
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:314
AV_FRAME_DATA_MATRIXENCODING
@ AV_FRAME_DATA_MATRIXENCODING
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
Definition: frame.h:67
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:118
MAKE_ACCESSORS
#define MAKE_ACCESSORS(str, name, type, field)
Definition: internal.h:90
AV_CODEC_ID_XAN_DPCM
@ AV_CODEC_ID_XAN_DPCM
Definition: codec_id.h:416
AV_CODEC_ID_MSZH
@ AV_CODEC_ID_MSZH
Definition: codec_id.h:102
AVCodec::encode_sub
int(* encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: codec.h:277
avpriv_find_start_code
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:1011
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:941
ThreadFrame::owner
AVCodecContext * owner[2]
Definition: thread.h:36
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:72
ff_thread_get_format
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: utils.c:958
AV_CODEC_ID_SMC
@ AV_CODEC_ID_SMC
Definition: codec_id.h:98
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:425
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:194
AV_CODEC_ID_8SVX_FIB
@ AV_CODEC_ID_8SVX_FIB
Definition: codec_id.h:479
codec.h
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_PIX_FMT_YUV444P10BE
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:164
av_image_check_size2
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
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:159
AV_CODEC_ID_ATRAC3
@ AV_CODEC_ID_ATRAC3
Definition: codec_id.h:455
PixelFormatTag::pix_fmt
enum AVPixelFormat pix_fmt
Definition: raw.h:35
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#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
raw.h
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:258
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:465
AV_CODEC_ID_ADPCM_SBPRO_2
@ AV_CODEC_ID_ADPCM_SBPRO_2
Definition: codec_id.h:370
AV_PIX_FMT_YUV422P12BE
@ AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:246
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:253
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:431
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:317
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
avassert.h
AV_CODEC_ID_MACE3
@ AV_CODEC_ID_MACE3
Definition: codec_id.h:433
AV_CODEC_ID_ATRAC3P
@ AV_CODEC_ID_ATRAC3P
Definition: codec_id.h:463
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AV_CODEC_ID_TTA
@ AV_CODEC_ID_TTA
Definition: codec_id.h:446
avpriv_find_pix_fmt
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:438
duration
int64_t duration
Definition: movenc.c:64
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:181
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:428
AV_CODEC_ID_S302M
@ AV_CODEC_ID_S302M
Definition: codec_id.h:339
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:216
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:364
FFMAX3
#define FFMAX3(a, b, c)
Definition: common.h:104
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:175
AV_CODEC_ID_PCM_LXF
@ AV_CODEC_ID_PCM_LXF
Definition: codec_id.h:338
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
height
static int height
Definition: utils.c:158
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
AV_CODEC_ID_ADPCM_AFC
@ AV_CODEC_ID_ADPCM_AFC
Definition: codec_id.h:385
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition: codec_id.h:376
frame_size
int frame_size
Definition: mxfenc.c:2206
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:424
AV_CODEC_ID_ADPCM_IMA_DK3
@ AV_CODEC_ID_ADPCM_IMA_DK3
Definition: codec_id.h:355
AV_CODEC_ID_ARGO
@ AV_CODEC_ID_ARGO
Definition: codec_id.h:306
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:255
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
AV_CODEC_ID_ADPCM_IMA_APC
@ AV_CODEC_ID_ADPCM_IMA_APC
Definition: codec_id.h:382
AV_CODEC_ID_ATRAC9
@ AV_CODEC_ID_ATRAC9
Definition: codec_id.h:513
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:190
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
ff_side_data_update_matrix_encoding
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:114
AVPacketSideData::data
uint8_t * data
Definition: packet.h:307
AV_CODEC_ID_ADPCM_IMA_ISS
@ AV_CODEC_ID_ADPCM_IMA_ISS
Definition: codec_id.h:380
AV_CODEC_ID_BINKAUDIO_DCT
@ AV_CODEC_ID_BINKAUDIO_DCT
Definition: codec_id.h:472
ctx
AVFormatContext * ctx
Definition: movenc.c:48
avcodec_fill_audio_frame
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:373
ff_alloc_entries
int ff_alloc_entries(AVCodecContext *avctx, int count)
Definition: utils.c:992
AV_CODEC_ID_PCM_F24LE
@ AV_CODEC_ID_PCM_F24LE
Definition: codec_id.h:348
limits.h
avcodec_align_dimensions2
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:134
AV_CODEC_ID_DERF_DPCM
@ AV_CODEC_ID_DERF_DPCM
Definition: codec_id.h:421
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:319
field
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
Definition: writing_filters.txt:78
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:316
AV_CODEC_ID_ADPCM_IMA_SMJPEG
@ AV_CODEC_ID_ADPCM_IMA_SMJPEG
Definition: codec_id.h:358
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:173
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:332
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:453
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
PutBitContext
Definition: put_bits.h:44
av_get_codec_tag_string
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:492
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:546
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:165
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:187
ThreadFrame::progress
AVBufferRef * progress
Definition: thread.h:39
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:934
AVMatrixEncoding
AVMatrixEncoding
Definition: channel_layout.h:120
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:162
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:320
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:160
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:133
AV_CODEC_ID_ADPCM_EA_XAS
@ AV_CODEC_ID_ADPCM_EA_XAS
Definition: codec_id.h:378
ff_match_2uint16
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:897
AV_CODEC_ID_SP5X
@ AV_CODEC_ID_SP5X
Definition: codec_id.h:59
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:287
NULL
#define NULL
Definition: coverity.c:32
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:969
AV_CODEC_ID_DST
@ AV_CODEC_ID_DST
Definition: codec_id.h:506
AV_CODEC_ID_INTERPLAY_VIDEO
@ AV_CODEC_ID_INTERPLAY_VIDEO
Definition: codec_id.h:88
AV_CODEC_ID_ADPCM_YAMAHA
@ AV_CODEC_ID_ADPCM_YAMAHA
Definition: codec_id.h:367
AV_CODEC_ID_ADPCM_IMA_WS
@ AV_CODEC_ID_ADPCM_IMA_WS
Definition: codec_id.h:357
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:328
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_CODEC_ID_INTERPLAY_DPCM
@ AV_CODEC_ID_INTERPLAY_DPCM
Definition: codec_id.h:415
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:324
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:2194
AV_CODEC_ID_ADPCM_ARGO
@ AV_CODEC_ID_ADPCM_ARGO
Definition: codec_id.h:396
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
AV_CODEC_ID_ADPCM_IMA_DK4
@ AV_CODEC_ID_ADPCM_IMA_DK4
Definition: codec_id.h:356
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:586
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:313
AV_PIX_FMT_YUVA422P12LE
@ AV_PIX_FMT_YUVA422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:344
AV_CODEC_ID_CINEPAK
@ AV_CODEC_ID_CINEPAK
Definition: codec_id.h:92
src
#define src
Definition: vp8dsp.c:255
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:346
AV_CODEC_ID_ZLIB
@ AV_CODEC_ID_ZLIB
Definition: codec_id.h:103
AV_PIX_FMT_YUVA444P12BE
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:345
AVCodec::profiles
const AVProfile * profiles
array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
Definition: codec.h:224
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:183
AV_CODEC_ID_ADPCM_IMA_AMV
@ AV_CODEC_ID_ADPCM_IMA_AMV
Definition: codec_id.h:372
lowres
static int lowres
Definition: ffplay.c:336
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:191
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
AV_CODEC_ID_ROQ_DPCM
@ AV_CODEC_ID_ROQ_DPCM
Definition: codec_id.h:414
AV_PIX_FMT_YUV440P10LE
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:275
AVProfile::profile
int profile
Definition: codec.h:184
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:179
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:155
av_cpb_properties_alloc
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
Definition: utils.c:1044
AV_SAMPLE_FMT_U8
AV_SAMPLE_FMT_U8
Definition: audio_convert.c:194
ff_color_frame
void ff_color_frame(AVFrame *frame, const int c[4])
Definition: utils.c:409
index
int index
Definition: gxfenc.c:89
c
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
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:245
AV_CODEC_ID_PCM_S24LE_PLANAR
@ AV_CODEC_ID_PCM_S24LE_PLANAR
Definition: codec_id.h:341
AV_CODEC_ID_ADPCM_XA
@ AV_CODEC_ID_ADPCM_XA
Definition: codec_id.h:361
AV_CODEC_ID_GSM
@ AV_CODEC_ID_GSM
as in Berlin toast format
Definition: codec_id.h:442
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AV_CODEC_ID_PCM_VIDC
@ AV_CODEC_ID_PCM_VIDC
Definition: codec_id.h:349
AV_PIX_FMT_YUV444P14BE
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:252
AV_CODEC_ID_MJPEGB
@ AV_CODEC_ID_MJPEGB
Definition: codec_id.h:57
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:156
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:659
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:79
AV_CODEC_ID_QCELP
@ AV_CODEC_ID_QCELP
Definition: codec_id.h:448
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:630
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:325
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:277
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:362
av_frame_ref
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
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:66
AV_CODEC_ID_ADPCM_IMA_RAD
@ AV_CODEC_ID_ADPCM_IMA_RAD
Definition: codec_id.h:388
AV_PIX_FMT_YUV420P12BE
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:242
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:161
AV_CODEC_ID_DSD_MSBF
@ AV_CODEC_ID_DSD_MSBF
Definition: codec_id.h:499
AV_CODEC_ID_ADPCM_IMA_ALP
@ AV_CODEC_ID_ADPCM_IMA_ALP
Definition: codec_id.h:400
av_get_profile_name
const char * av_get_profile_name(const AVCodec *codec, int profile)
Return a name for the specified profile, if available.
Definition: utils.c:513
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AV_PIX_FMT_YUV422P14BE
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:248
bps
unsigned bps
Definition: movenc.c:1612
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:366
size
int size
Definition: twinvq_data.h:10344
AV_CODEC_ID_SMVJPEG
@ AV_CODEC_ID_SMVJPEG
Definition: codec_id.h:263
avpriv_codec_get_cap_skip_frame_fill_param
int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec)
Definition: utils.c:467
AVCodec::encode2
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:289
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:319
AV_RB32
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:96
AVCodec::receive_packet
int(* receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt)
Encode API with decoupled frame/packet dataflow.
Definition: codec.h:311
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:170
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1058
AVFrameSideData::data
uint8_t * data
Definition: frame.h:222
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:606
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:158
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:171
AV_NE
#define AV_NE(be, le)
Definition: common.h:50
AVCodec::receive_frame
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
Definition: codec.h:318
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
a
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:41
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
ff_reset_entries
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:997
bitrate
int64_t bitrate
Definition: h264_levels.c:131
ff_int_from_list_or_default
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:1183
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:185
av_hwaccel_next
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:916
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:71
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
ff_thread_await_progress
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: utils.c:983
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:605
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:186
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:74
AV_CODEC_ID_VP5
@ AV_CODEC_ID_VP5
Definition: codec_id.h:139
AVCPBProperties::vbv_delay
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
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:471
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
AV_PIX_FMT_YUVA444P12LE
@ AV_PIX_FMT_YUVA444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:346
AVCodec::hw_configs
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:343
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:180
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:470
AV_CODEC_ID_RA_288
@ AV_CODEC_ID_RA_288
Definition: codec_id.h:411
ff_thread_finish_setup
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:975
AV_CODEC_ID_ADPCM_MTAF
@ AV_CODEC_ID_ADPCM_MTAF
Definition: codec_id.h:394
i
int i
Definition: input.c:407
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
width
static int width
Definition: utils.c:158
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
AV_CODEC_ID_EVRC
@ AV_CODEC_ID_EVRC
Definition: codec_id.h:496
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
AV_CODEC_ID_DSD_LSBF_PLANAR
@ AV_CODEC_ID_DSD_LSBF_PLANAR
Definition: codec_id.h:500
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:335
av_fast_padded_malloc
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:50
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:387
av_toupper
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
Definition: avstring.h:236
AV_CODEC_ID_ADPCM_IMA_APM
@ AV_CODEC_ID_ADPCM_IMA_APM
Definition: codec_id.h:399
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:100
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:322
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:855
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
av_mallocz
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
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:145
AV_CODEC_ID_PCM_F16LE
@ AV_CODEC_ID_PCM_F16LE
Definition: codec_id.h:347
AV_CODEC_ID_ADPCM_IMA_DAT4
@ AV_CODEC_ID_ADPCM_IMA_DAT4
Definition: codec_id.h:393
len
int len
Definition: vorbis_enc_data.h:452
av_register_hwaccel
void av_register_hwaccel(AVHWAccel *hwaccel)
Register the hardware accelerator hwaccel.
Definition: utils.c:921
av_samples_get_buffer_size
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
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:136
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
ff_guess_coded_bitrate
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:1162
av_get_exact_bits_per_sample
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:541
avcodec.h
AV_CODEC_ID_IAC
@ AV_CODEC_ID_IAC
Definition: codec_id.h:482
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:217
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AV_CODEC_ID_GSM_MS
@ AV_CODEC_ID_GSM_MS
Definition: codec_id.h:454
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:210
tag
uint32_t tag
Definition: movenc.c:1611
ret
ret
Definition: filter_design.txt:187
AVCodec::caps_internal
int caps_internal
Internal codec capabilities.
Definition: codec.h:328
AVCodecContext::block_align
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
Definition: avcodec.h:1233
pixfmt.h
get_audio_frame_duration
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:648
frame
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
Definition: filter_design.txt:264
avcodec_find_decoder
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
pos
unsigned int pos
Definition: spdifenc.c:412
AV_CODEC_ID_JV
@ AV_CODEC_ID_JV
Definition: codec_id.h:198
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
AV_PIX_FMT_YUV444P12BE
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:250
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:156
AVCodecContext
main external API structure.
Definition: avcodec.h:536
ThreadFrame
Definition: thread.h:34
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:389
av_get_pcm_codec
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
Definition: utils.c:608
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_CODEC_ID_JPEGLS
@ AV_CODEC_ID_JPEGLS
Definition: codec_id.h:60
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:163
av_fast_padded_mallocz
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:62
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:70
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:323
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
av_get_audio_frame_duration2
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:865
avcodec_chroma_pos_to_enum
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
Converts swscale x/y chroma position to AVChromaLocation.
Definition: utils.c:362
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AV_PIX_FMT_YUVA420P10BE
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:184
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:904
AV_PIX_FMT_YUV420P16BE
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:132
AV_CODEC_ID_TRUESPEECH
@ AV_CODEC_ID_TRUESPEECH
Definition: codec_id.h:445
shift
static int shift(int a, int b)
Definition: sonic.c:82
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
AV_CODEC_ID_ADPCM_THP
@ AV_CODEC_ID_ADPCM_THP
Definition: codec_id.h:371
AV_PIX_FMT_YUV422P16BE
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:134
tc
#define tc
Definition: regdef.h:69
desc
const char * desc
Definition: libsvtav1.c:79
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:321
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
bcd2uint
static unsigned bcd2uint(uint8_t bcd)
Definition: utils.c:1089
AV_CODEC_ID_ADPCM_SBPRO_4
@ AV_CODEC_ID_ADPCM_SBPRO_4
Definition: codec_id.h:368
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:318
AV_CODEC_ID_RPZA
@ AV_CODEC_ID_RPZA
Definition: codec_id.h:91
AV_CODEC_ID_SDX2_DPCM
@ AV_CODEC_ID_SDX2_DPCM
Definition: codec_id.h:419
ff_set_dimensions
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:84
ff_set_sar
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:99
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:189
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:220
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:110
AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_PCM_S24DAUD
Definition: codec_id.h:329
AV_CODEC_ID_ADPCM_IMA_SSI
@ AV_CODEC_ID_ADPCM_IMA_SSI
Definition: codec_id.h:397
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:336
ff_alloc_timecode_sei
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:1098
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:561
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AV_CODEC_ID_ADPCM_IMA_MOFLEX
@ AV_CODEC_ID_ADPCM_IMA_MOFLEX
Definition: codec_id.h:403
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AV_CODEC_ID_ADPCM_IMA_WAV
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition: codec_id.h:354
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
AV_PIX_FMT_YUV440P10BE
@ AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:276
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:192
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:167
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:193
PixelFormatTag::fourcc
unsigned int fourcc
Definition: raw.h:36
AV_CODEC_ID_ILBC
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:483
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:257
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:340
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:315
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCHROMA_LOC_NB
@ AVCHROMA_LOC_NB
Not part of ABI.
Definition: pixfmt.h:613
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:334
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
AVCodec::decode
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:303
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVCodecHWConfig
Definition: codec.h:443
AV_CODEC_ID_ADPCM_4XM
@ AV_CODEC_ID_ADPCM_4XM
Definition: codec_id.h:360
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3501
av_image_check_sar
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
avstring.h
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:195
AV_CODEC_ID_MUSEPACK7
@ AV_CODEC_ID_MUSEPACK7
Definition: codec_id.h:452
AV_CODEC_ID_ADPCM_PSX
@ AV_CODEC_ID_ADPCM_PSX
Definition: codec_id.h:391
planar
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
AV_PIX_FMT_YUVA422P12BE
@ AV_PIX_FMT_YUVA422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:343
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:34
put_bits.h
ff_thread_report_progress
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:979
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
fourcc
uint32_t fourcc
Definition: vaapi_decode.c:239
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: codec_id.h:58
snprintf
#define snprintf
Definition: snprintf.h:34
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:466
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:247
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:326
ff_thread_init
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:876
AV_PIX_FMT_YUVA420P9BE
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:178
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
AVCodecContext::sample_aspect_ratio
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:915
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:457
AV_PIX_FMT_UYYVYY411
@ AV_PIX_FMT_UYYVYY411
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Definition: pixfmt.h:82
AV_CODEC_ID_ADPCM_SBPRO_3
@ AV_CODEC_ID_ADPCM_SBPRO_3
Definition: codec_id.h:369
nb_channels
int nb_channels
Definition: channel_layout.c:81
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:181