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"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mem.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 "codec_internal.h"
39 #include "hwconfig.h"
40 #include "thread.h"
41 #include "threadframe.h"
42 #include "internal.h"
43 #include "put_bits.h"
44 #include "startcode.h"
45 #include <stdlib.h>
46 #include <limits.h>
47 
48 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
49 {
50  uint8_t **p = ptr;
51  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
52  av_freep(p);
53  *size = 0;
54  return;
55  }
57  if (*p)
58  memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
59 }
60 
61 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
62 {
63  uint8_t **p = ptr;
64  if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
65  av_freep(p);
66  *size = 0;
67  return;
68  }
70  if (*p)
71  memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
72 }
73 
74 int av_codec_is_encoder(const AVCodec *avcodec)
75 {
76  const FFCodec *const codec = ffcodec(avcodec);
77  return codec && (codec->cb_type == FF_CODEC_CB_TYPE_ENCODE ||
80 }
81 
82 int av_codec_is_decoder(const AVCodec *avcodec)
83 {
84  const FFCodec *const codec = ffcodec(avcodec);
85  return codec && (codec->cb_type == FF_CODEC_CB_TYPE_DECODE ||
88 }
89 
91 {
92  int ret = av_image_check_size2(width, height, s->max_pixels, AV_PIX_FMT_NONE, 0, s);
93 
94  if (ret < 0)
95  width = height = 0;
96 
97  s->coded_width = width;
98  s->coded_height = height;
99  s->width = AV_CEIL_RSHIFT(width, s->lowres);
100  s->height = AV_CEIL_RSHIFT(height, s->lowres);
101 
102  return ret;
103 }
104 
106 {
107  int ret = av_image_check_sar(avctx->width, avctx->height, sar);
108 
109  if (ret < 0) {
110  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
111  sar.num, sar.den);
112  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
113  return ret;
114  } else {
115  avctx->sample_aspect_ratio = sar;
116  }
117  return 0;
118 }
119 
121  enum AVMatrixEncoding matrix_encoding)
122 {
123  AVFrameSideData *side_data;
124  enum AVMatrixEncoding *data;
125 
127  if (!side_data)
129  sizeof(enum AVMatrixEncoding));
130 
131  if (!side_data)
132  return AVERROR(ENOMEM);
133 
134  data = (enum AVMatrixEncoding*)side_data->data;
135  *data = matrix_encoding;
136 
137  return 0;
138 }
139 
141  int linesize_align[AV_NUM_DATA_POINTERS])
142 {
143  int i;
144  int w_align = 1;
145  int h_align = 1;
146  AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
147 
148  if (desc) {
149  w_align = 1 << desc->log2_chroma_w;
150  h_align = 1 << desc->log2_chroma_h;
151  }
152 
153  switch (s->pix_fmt) {
154  case AV_PIX_FMT_YUV420P:
155  case AV_PIX_FMT_YUYV422:
156  case AV_PIX_FMT_YVYU422:
157  case AV_PIX_FMT_UYVY422:
158  case AV_PIX_FMT_YUV422P:
159  case AV_PIX_FMT_YUV440P:
160  case AV_PIX_FMT_YUV444P:
161  case AV_PIX_FMT_GBRP:
162  case AV_PIX_FMT_GBRAP:
163  case AV_PIX_FMT_GRAY8:
164  case AV_PIX_FMT_GRAY16BE:
165  case AV_PIX_FMT_GRAY16LE:
166  case AV_PIX_FMT_YUVJ420P:
167  case AV_PIX_FMT_YUVJ422P:
168  case AV_PIX_FMT_YUVJ440P:
169  case AV_PIX_FMT_YUVJ444P:
170  case AV_PIX_FMT_YUVA420P:
171  case AV_PIX_FMT_YUVA422P:
172  case AV_PIX_FMT_YUVA444P:
229  case AV_PIX_FMT_GBRP9LE:
230  case AV_PIX_FMT_GBRP9BE:
231  case AV_PIX_FMT_GBRP10LE:
232  case AV_PIX_FMT_GBRP10BE:
233  case AV_PIX_FMT_GBRP12LE:
234  case AV_PIX_FMT_GBRP12BE:
235  case AV_PIX_FMT_GBRP14LE:
236  case AV_PIX_FMT_GBRP14BE:
237  case AV_PIX_FMT_GBRP16LE:
238  case AV_PIX_FMT_GBRP16BE:
243  w_align = 16; //FIXME assume 16 pixel per macroblock
244  h_align = 16 * 2; // interlaced needs 2 macroblocks height
245  break;
246  case AV_PIX_FMT_YUV411P:
247  case AV_PIX_FMT_YUVJ411P:
249  w_align = 32;
250  h_align = 16 * 2;
251  break;
252  case AV_PIX_FMT_YUV410P:
253  if (s->codec_id == AV_CODEC_ID_SVQ1) {
254  w_align = 64;
255  h_align = 64;
256  }
257  break;
258  case AV_PIX_FMT_RGB555:
259  if (s->codec_id == AV_CODEC_ID_RPZA) {
260  w_align = 4;
261  h_align = 4;
262  }
263  if (s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
264  w_align = 8;
265  h_align = 8;
266  }
267  break;
268  case AV_PIX_FMT_PAL8:
269  case AV_PIX_FMT_BGR8:
270  case AV_PIX_FMT_RGB8:
271  if (s->codec_id == AV_CODEC_ID_SMC ||
272  s->codec_id == AV_CODEC_ID_CINEPAK) {
273  w_align = 4;
274  h_align = 4;
275  }
276  if (s->codec_id == AV_CODEC_ID_JV ||
277  s->codec_id == AV_CODEC_ID_ARGO ||
278  s->codec_id == AV_CODEC_ID_INTERPLAY_VIDEO) {
279  w_align = 8;
280  h_align = 8;
281  }
282  if (s->codec_id == AV_CODEC_ID_MJPEG ||
283  s->codec_id == AV_CODEC_ID_MJPEGB ||
284  s->codec_id == AV_CODEC_ID_LJPEG ||
285  s->codec_id == AV_CODEC_ID_SMVJPEG ||
286  s->codec_id == AV_CODEC_ID_AMV ||
287  s->codec_id == AV_CODEC_ID_SP5X ||
288  s->codec_id == AV_CODEC_ID_JPEGLS) {
289  w_align = 8;
290  h_align = 2*8;
291  }
292  break;
293  case AV_PIX_FMT_BGR24:
294  if ((s->codec_id == AV_CODEC_ID_MSZH) ||
295  (s->codec_id == AV_CODEC_ID_ZLIB)) {
296  w_align = 4;
297  h_align = 4;
298  }
299  break;
300  case AV_PIX_FMT_RGB24:
301  if (s->codec_id == AV_CODEC_ID_CINEPAK) {
302  w_align = 4;
303  h_align = 4;
304  }
305  break;
306  case AV_PIX_FMT_BGR0:
307  if (s->codec_id == AV_CODEC_ID_ARGO) {
308  w_align = 8;
309  h_align = 8;
310  }
311  break;
312  default:
313  break;
314  }
315 
316  if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
317  w_align = FFMAX(w_align, 8);
318  }
319 
320  *width = FFALIGN(*width, w_align);
321  *height = FFALIGN(*height, h_align);
322  if (s->codec_id == AV_CODEC_ID_H264 || s->lowres ||
323  s->codec_id == AV_CODEC_ID_VP5 || s->codec_id == AV_CODEC_ID_VP6 ||
324  s->codec_id == AV_CODEC_ID_VP6F || s->codec_id == AV_CODEC_ID_VP6A
325  ) {
326  // some of the optimized chroma MC reads one line too much
327  // which is also done in mpeg decoders with lowres > 0
328  *height += 2;
329 
330  // H.264 uses edge emulation for out of frame motion vectors, for this
331  // it requires a temporary area large enough to hold a 21x21 block,
332  // increasing witdth ensure that the temporary area is large enough,
333  // the next rounded up width is 32
334  *width = FFMAX(*width, 32);
335  }
336 
337  for (i = 0; i < 4; i++)
338  linesize_align[i] = STRIDE_ALIGN;
339 }
340 
342 {
343  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
344  int chroma_shift = desc->log2_chroma_w;
345  int linesize_align[AV_NUM_DATA_POINTERS];
346  int align;
347 
348  avcodec_align_dimensions2(s, width, height, linesize_align);
349  align = FFMAX(linesize_align[0], linesize_align[3]);
350  linesize_align[1] <<= chroma_shift;
351  linesize_align[2] <<= chroma_shift;
352  align = FFMAX3(align, linesize_align[1], linesize_align[2]);
353  *width = FFALIGN(*width, align);
354 }
355 
356 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
357 {
358  if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
359  return AVERROR(EINVAL);
360  pos--;
361 
362  *xpos = (pos&1) * 128;
363  *ypos = ((pos>>1)^(pos<4)) * 128;
364 
365  return 0;
366 }
367 
369 {
370  int pos, xout, yout;
371 
373  if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
374  return pos;
375  }
377 }
378 
379 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
380  enum AVSampleFormat sample_fmt, const uint8_t *buf,
381  int buf_size, int align)
382 {
383  int ch, planar, needed_size, ret = 0;
384 
385  needed_size = av_samples_get_buffer_size(NULL, nb_channels,
386  frame->nb_samples, sample_fmt,
387  align);
388  if (buf_size < needed_size)
389  return AVERROR(EINVAL);
390 
391  planar = av_sample_fmt_is_planar(sample_fmt);
392  if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
393  if (!FF_ALLOCZ_TYPED_ARRAY(frame->extended_data, nb_channels))
394  return AVERROR(ENOMEM);
395  } else {
396  frame->extended_data = frame->data;
397  }
398 
399  if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
400  (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
401  sample_fmt, align)) < 0) {
402  if (frame->extended_data != frame->data)
403  av_freep(&frame->extended_data);
404  return ret;
405  }
406  if (frame->extended_data != frame->data) {
407  for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
408  frame->data[ch] = frame->extended_data[ch];
409  }
410 
411  return ret;
412 }
413 
414 void ff_color_frame(AVFrame *frame, const int c[4])
415 {
417  int p, y;
418 
420 
421  for (p = 0; p<desc->nb_components; p++) {
422  uint8_t *dst = frame->data[p];
423  int is_chroma = p == 1 || p == 2;
424  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
425  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
426  if (desc->comp[0].depth >= 9) {
427  ((uint16_t*)dst)[0] = c[p];
428  av_memcpy_backptr(dst + 2, 2, bytes - 2);
429  dst += frame->linesize[p];
430  for (y = 1; y < height; y++) {
431  memcpy(dst, frame->data[p], 2*bytes);
432  dst += frame->linesize[p];
433  }
434  } else {
435  for (y = 0; y < height; y++) {
436  memset(dst, c[p], bytes);
437  dst += frame->linesize[p];
438  }
439  }
440  }
441 }
442 
445 }
446 
447 const char *avcodec_get_name(enum AVCodecID id)
448 {
449  const AVCodecDescriptor *cd;
450  const AVCodec *codec;
451 
452  if (id == AV_CODEC_ID_NONE)
453  return "none";
454  cd = avcodec_descriptor_get(id);
455  if (cd)
456  return cd->name;
457  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
458  codec = avcodec_find_decoder(id);
459  if (codec)
460  return codec->name;
461  codec = avcodec_find_encoder(id);
462  if (codec)
463  return codec->name;
464  return "unknown_codec";
465 }
466 
467 const char *av_get_profile_name(const AVCodec *codec, int profile)
468 {
469  const AVProfile *p;
470  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
471  return NULL;
472 
473  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
474  if (p->profile == profile)
475  return p->name;
476 
477  return NULL;
478 }
479 
481 {
483  const AVProfile *p;
484 
485  if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
486  return NULL;
487 
488  for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
489  if (p->profile == profile)
490  return p->name;
491 
492  return NULL;
493 }
494 
496 {
497  switch (codec_id) {
513  return 4;
521  case AV_CODEC_ID_PCM_S8:
523  case AV_CODEC_ID_PCM_SGA:
524  case AV_CODEC_ID_PCM_U8:
527  return 8;
534  return 16;
541  return 24;
551  return 32;
556  return 64;
557  default:
558  return 0;
559  }
560 }
561 
563 {
564  static const enum AVCodecID map[][2] = {
576  };
577  if (fmt < 0 || fmt >= FF_ARRAY_ELEMS(map))
578  return AV_CODEC_ID_NONE;
579  if (be < 0 || be > 1)
580  be = AV_NE(1, 0);
581  return map[fmt][be];
582 }
583 
585 {
586  switch (codec_id) {
587  case AV_CODEC_ID_DFPWM:
588  return 1;
590  return 2;
592  return 3;
598  return 4;
599  default:
601  }
602 }
603 
604 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
605  uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
606  uint8_t * extradata, int frame_size, int frame_bytes)
607 {
609  int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
610 
611  /* codecs with an exact constant bits per sample */
612  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
613  return (frame_bytes * 8LL) / (bps * ch);
614  bps = bits_per_coded_sample;
615 
616  /* codecs with a fixed packet duration */
617  switch (id) {
618  case AV_CODEC_ID_ADPCM_ADX: return 32;
619  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
620  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
621  case AV_CODEC_ID_AMR_NB:
622  case AV_CODEC_ID_EVRC:
623  case AV_CODEC_ID_GSM:
624  case AV_CODEC_ID_QCELP:
625  case AV_CODEC_ID_RA_288: return 160;
626  case AV_CODEC_ID_AMR_WB:
627  case AV_CODEC_ID_GSM_MS: return 320;
628  case AV_CODEC_ID_MP1: return 384;
629  case AV_CODEC_ID_ATRAC1: return 512;
630  case AV_CODEC_ID_ATRAC9:
631  case AV_CODEC_ID_ATRAC3:
632  if (framecount > INT_MAX/1024)
633  return 0;
634  return 1024 * framecount;
635  case AV_CODEC_ID_ATRAC3P: return 2048;
636  case AV_CODEC_ID_MP2:
637  case AV_CODEC_ID_MUSEPACK7: return 1152;
638  case AV_CODEC_ID_AC3: return 1536;
639  }
640 
641  if (sr > 0) {
642  /* calc from sample rate */
643  if (id == AV_CODEC_ID_TTA)
644  return 256 * sr / 245;
645  else if (id == AV_CODEC_ID_DST)
646  return 588 * sr / 44100;
647  else if (id == AV_CODEC_ID_BINKAUDIO_DCT) {
648  if (sr / 22050 > 22)
649  return 0;
650  return (480 << (sr / 22050));
651  }
652 
653  if (id == AV_CODEC_ID_MP3)
654  return sr <= 24000 ? 576 : 1152;
655  }
656 
657  if (ba > 0) {
658  /* calc from block_align */
659  if (id == AV_CODEC_ID_SIPR) {
660  switch (ba) {
661  case 20: return 160;
662  case 19: return 144;
663  case 29: return 288;
664  case 37: return 480;
665  }
666  } else if (id == AV_CODEC_ID_ILBC) {
667  switch (ba) {
668  case 38: return 160;
669  case 50: return 240;
670  }
671  }
672  }
673 
674  if (frame_bytes > 0) {
675  /* calc from frame_bytes only */
676  if (id == AV_CODEC_ID_TRUESPEECH)
677  return 240 * (frame_bytes / 32);
678  if (id == AV_CODEC_ID_NELLYMOSER)
679  return 256 * (frame_bytes / 64);
680  if (id == AV_CODEC_ID_RA_144)
681  return 160 * (frame_bytes / 20);
682 
683  if (bps > 0) {
684  /* calc from frame_bytes and bits_per_coded_sample */
686  return frame_bytes * 8 / bps;
687  }
688 
689  if (ch > 0 && ch < INT_MAX/16) {
690  /* calc from frame_bytes and channels */
691  switch (id) {
693  return frame_bytes / (40 * ch) * 256;
695  return (frame_bytes - 4 * ch) / (128 * ch) * 256;
697  return frame_bytes / (9 * ch) * 16;
700  frame_bytes /= 16 * ch;
701  if (frame_bytes > INT_MAX / 28)
702  return 0;
703  return frame_bytes * 28;
708  return (frame_bytes - 4 * ch) * 2 / ch;
710  return (frame_bytes - 4) * 2 / ch;
712  return (frame_bytes - 8) * 2;
715  if (extradata)
716  return frame_bytes * 14LL / (8 * ch);
717  break;
719  return (frame_bytes / 128) * 224 / ch;
721  return (frame_bytes - 6 - ch) / ch;
723  return (frame_bytes - 8) / ch;
725  return (frame_bytes - 2 * ch) / ch;
726  case AV_CODEC_ID_MACE3:
727  return 3 * frame_bytes / ch;
728  case AV_CODEC_ID_MACE6:
729  return 6 * frame_bytes / ch;
730  case AV_CODEC_ID_PCM_LXF:
731  return 2 * (frame_bytes / (5 * ch));
732  case AV_CODEC_ID_IAC:
733  case AV_CODEC_ID_IMC:
734  return 4 * frame_bytes / ch;
735  }
736 
737  if (tag) {
738  /* calc from frame_bytes, channels, and codec_tag */
739  if (id == AV_CODEC_ID_SOL_DPCM) {
740  if (tag == 3)
741  return frame_bytes / ch;
742  else
743  return frame_bytes * 2 / ch;
744  }
745  }
746 
747  if (ba > 0) {
748  /* calc from frame_bytes, channels, and block_align */
749  int blocks = frame_bytes / ba;
750  int64_t tmp = 0;
751  switch (id) {
753  if (bps < 2 || bps > 5)
754  return 0;
755  tmp = blocks * (1LL + (ba - 4 * ch) / (bps * ch) * 8);
756  break;
758  tmp = blocks * (((ba - 16LL) * 2 / 3 * 4) / ch);
759  break;
761  tmp = blocks * (1 + (ba - 4LL * ch) * 2 / ch);
762  break;
764  tmp = blocks * ((ba - 4LL * ch) * 2 / ch);
765  break;
767  tmp = blocks * (2 + (ba - 7LL * ch) * 2LL / ch);
768  break;
770  tmp = blocks * (ba - 16LL) * 2 / ch;
771  break;
772  }
773  if (tmp) {
774  if (tmp != (int)tmp)
775  return 0;
776  return tmp;
777  }
778  }
779 
780  if (bps > 0) {
781  /* calc from frame_bytes, channels, and bits_per_coded_sample */
782  switch (id) {
783  case AV_CODEC_ID_PCM_DVD:
784  if(bps<4 || frame_bytes<3)
785  return 0;
786  return 2 * ((frame_bytes - 3) / ((bps * 2 / 8) * ch));
788  if(bps<4 || frame_bytes<4)
789  return 0;
790  return (frame_bytes - 4) / ((FFALIGN(ch, 2) * bps) / 8);
791  case AV_CODEC_ID_S302M:
792  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
793  }
794  }
795  }
796  }
797 
798  /* Fall back on using frame_size */
799  if (frame_size > 1 && frame_bytes)
800  return frame_size;
801 
802  //For WMA we currently have no other means to calculate duration thus we
803  //do it here by assuming CBR, which is true for all known cases.
804  if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
805  if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
806  return (frame_bytes * 8LL * sr) / bitrate;
807  }
808 
809  return 0;
810 }
811 
812 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
813 {
814  int channels = avctx->ch_layout.nb_channels;
815  int duration;
816 #if FF_API_OLD_CHANNEL_LAYOUT
818  if (!channels)
819  channels = avctx->channels;
821 #endif
823  channels, avctx->block_align,
824  avctx->codec_tag, avctx->bits_per_coded_sample,
825  avctx->bit_rate, avctx->extradata, avctx->frame_size,
826  frame_bytes);
827  return FFMAX(0, duration);
828 }
829 
831 {
832  int channels = par->ch_layout.nb_channels;
833  int duration;
834 #if FF_API_OLD_CHANNEL_LAYOUT
836  if (!channels)
837  channels = par->channels;
839 #endif
841  channels, par->block_align,
842  par->codec_tag, par->bits_per_coded_sample,
843  par->bit_rate, par->extradata, par->frame_size,
844  frame_bytes);
845  return FFMAX(0, duration);
846 }
847 
848 #if !HAVE_THREADS
850 {
851  return -1;
852 }
853 
854 #endif
855 
856 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
857 {
858  unsigned int n = 0;
859 
860  while (v >= 0xff) {
861  *s++ = 0xff;
862  v -= 0xff;
863  n++;
864  }
865  *s = v;
866  n++;
867  return n;
868 }
869 
870 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
871 {
872  int i;
873  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
874  return i;
875 }
876 
878 {
879  const FFCodec *const codec = ffcodec(avcodec);
880  int i;
881  if (!codec->hw_configs || index < 0)
882  return NULL;
883  for (i = 0; i <= index; i++)
884  if (!codec->hw_configs[i])
885  return NULL;
886  return &codec->hw_configs[index]->public;
887 }
888 
890 {
891  int ret;
892 
893  dst->owner[0] = src->owner[0];
894  dst->owner[1] = src->owner[1];
895 
896  ret = av_frame_ref(dst->f, src->f);
897  if (ret < 0)
898  return ret;
899 
900  av_assert0(!dst->progress);
901 
902  if (src->progress &&
903  !(dst->progress = av_buffer_ref(src->progress))) {
904  ff_thread_release_ext_buffer(dst->owner[0], dst);
905  return AVERROR(ENOMEM);
906  }
907 
908  return 0;
909 }
910 
911 #if !HAVE_THREADS
912 
914 {
915  return ff_get_format(avctx, fmt);
916 }
917 
919 {
920  return ff_get_buffer(avctx, f, flags);
921 }
922 
924 {
925  f->owner[0] = f->owner[1] = avctx;
926  return ff_get_buffer(avctx, f->f, flags);
927 }
928 
930 {
931  if (f)
932  av_frame_unref(f);
933 }
934 
936 {
937  f->owner[0] = f->owner[1] = NULL;
938  if (f->f)
939  av_frame_unref(f->f);
940 }
941 
943 {
944 }
945 
946 void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
947 {
948 }
949 
950 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
951 {
952 }
953 
955 {
956  return 1;
957 }
958 
959 int ff_alloc_entries(AVCodecContext *avctx, int count)
960 {
961  return 0;
962 }
963 
965 {
966 }
967 
968 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
969 {
970 }
971 
972 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
973 {
974 }
975 
976 #endif
977 
978 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
979  const uint8_t *end,
980  uint32_t *av_restrict state)
981 {
982  int i;
983 
984  av_assert0(p <= end);
985  if (p >= end)
986  return end;
987 
988  for (i = 0; i < 3; i++) {
989  uint32_t tmp = *state << 8;
990  *state = tmp + *(p++);
991  if (tmp == 0x100 || p == end)
992  return p;
993  }
994 
995  while (p < end) {
996  if (p[-1] > 1 ) p += 3;
997  else if (p[-2] ) p += 2;
998  else if (p[-3]|(p[-1]-1)) p++;
999  else {
1000  p++;
1001  break;
1002  }
1003  }
1004 
1005  p = FFMIN(p, end) - 4;
1006  *state = AV_RB32(p);
1007 
1008  return p + 4;
1009 }
1010 
1012 {
1013  AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1014  if (!props)
1015  return NULL;
1016 
1017  if (size)
1018  *size = sizeof(*props);
1019 
1020  props->vbv_delay = UINT64_MAX;
1021 
1022  return props;
1023 }
1024 
1026 {
1028  AVCPBProperties *props;
1029  size_t size;
1030  int i;
1031 
1032  for (i = 0; i < avctx->nb_coded_side_data; i++)
1034  return (AVCPBProperties *)avctx->coded_side_data[i].data;
1035 
1036  props = av_cpb_properties_alloc(&size);
1037  if (!props)
1038  return NULL;
1039 
1040  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
1041  if (!tmp) {
1042  av_freep(&props);
1043  return NULL;
1044  }
1045 
1046  avctx->coded_side_data = tmp;
1047  avctx->nb_coded_side_data++;
1048 
1050  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
1051  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
1052 
1053  return props;
1054 }
1055 
1056 static unsigned bcd2uint(uint8_t bcd)
1057 {
1058  unsigned low = bcd & 0xf;
1059  unsigned high = bcd >> 4;
1060  if (low > 9 || high > 9)
1061  return 0;
1062  return low + 10*high;
1063 }
1064 
1065 int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len,
1066  void **data, size_t *sei_size)
1067 {
1068  AVFrameSideData *sd = NULL;
1069  uint8_t *sei_data;
1070  PutBitContext pb;
1071  uint32_t *tc;
1072  int m;
1073 
1074  if (frame)
1076 
1077  if (!sd) {
1078  *data = NULL;
1079  return 0;
1080  }
1081  tc = (uint32_t*)sd->data;
1082  m = tc[0] & 3;
1083 
1084  *sei_size = sizeof(uint32_t) * 4;
1085  *data = av_mallocz(*sei_size + prefix_len);
1086  if (!*data)
1087  return AVERROR(ENOMEM);
1088  sei_data = (uint8_t*)*data + prefix_len;
1089 
1090  init_put_bits(&pb, sei_data, *sei_size);
1091  put_bits(&pb, 2, m); // num_clock_ts
1092 
1093  for (int j = 1; j <= m; j++) {
1094  uint32_t tcsmpte = tc[j];
1095  unsigned hh = bcd2uint(tcsmpte & 0x3f); // 6-bit hours
1096  unsigned mm = bcd2uint(tcsmpte>>8 & 0x7f); // 7-bit minutes
1097  unsigned ss = bcd2uint(tcsmpte>>16 & 0x7f); // 7-bit seconds
1098  unsigned ff = bcd2uint(tcsmpte>>24 & 0x3f); // 6-bit frames
1099  unsigned drop = tcsmpte & 1<<30 && !0; // 1-bit drop if not arbitrary bit
1100 
1101  /* Calculate frame number of HEVC by SMPTE ST 12-1:2014 Sec 12.2 if rate > 30FPS */
1102  if (av_cmp_q(rate, (AVRational) {30, 1}) == 1) {
1103  unsigned pc;
1104  ff *= 2;
1105  if (av_cmp_q(rate, (AVRational) {50, 1}) == 0)
1106  pc = !!(tcsmpte & 1 << 7);
1107  else
1108  pc = !!(tcsmpte & 1 << 23);
1109  ff = (ff + pc) & 0x7f;
1110  }
1111 
1112  put_bits(&pb, 1, 1); // clock_timestamp_flag
1113  put_bits(&pb, 1, 1); // units_field_based_flag
1114  put_bits(&pb, 5, 0); // counting_type
1115  put_bits(&pb, 1, 1); // full_timestamp_flag
1116  put_bits(&pb, 1, 0); // discontinuity_flag
1117  put_bits(&pb, 1, drop);
1118  put_bits(&pb, 9, ff);
1119  put_bits(&pb, 6, ss);
1120  put_bits(&pb, 6, mm);
1121  put_bits(&pb, 5, hh);
1122  put_bits(&pb, 5, 0);
1123  }
1124  flush_put_bits(&pb);
1125 
1126  return 0;
1127 }
1128 
1130 {
1131  AVRational framerate = avctx->framerate;
1132  int bits_per_coded_sample = avctx->bits_per_coded_sample;
1133  int64_t bitrate;
1134 
1135  if (!(framerate.num && framerate.den))
1136  framerate = av_inv_q(avctx->time_base);
1137  if (!(framerate.num && framerate.den))
1138  return 0;
1139 
1140  if (!bits_per_coded_sample) {
1142  bits_per_coded_sample = av_get_bits_per_pixel(desc);
1143  }
1144  bitrate = (int64_t)bits_per_coded_sample * avctx->width * avctx->height *
1145  framerate.num / framerate.den;
1146 
1147  return bitrate;
1148 }
1149 
1150 int ff_int_from_list_or_default(void *ctx, const char * val_name, int val,
1151  const int * array_valid_values, int default_value)
1152 {
1153  int i = 0, ref_val;
1154 
1155  while (1) {
1156  ref_val = array_valid_values[i];
1157  if (ref_val == INT_MAX)
1158  break;
1159  if (val == ref_val)
1160  return val;
1161  i++;
1162  }
1163  /* val is not a valid value */
1165  "%s %d are not supported. Set to default value : %d\n", val_name, val, default_value);
1166  return default_value;
1167 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:316
hwconfig.h
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1026
AV_CODEC_ID_MACE6
@ AV_CODEC_ID_MACE6
Definition: codec_id.h:435
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:196
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
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:147
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:142
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:336
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:75
AV_CODEC_ID_ADPCM_MS
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:361
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_CODEC_ID_ADPCM_IMA_QT
@ AV_CODEC_ID_ADPCM_IMA_QT
Definition: codec_id.h:355
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:428
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_CODEC_ID_PCM_BLURAY
@ AV_CODEC_ID_PCM_BLURAY
Definition: codec_id.h:340
FF_CODEC_CB_TYPE_RECEIVE_PACKET
@ FF_CODEC_CB_TYPE_RECEIVE_PACKET
Definition: codec_internal.h:109
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: utils.c:929
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1100
AV_CODEC_ID_ADPCM_DTK
@ AV_CODEC_ID_ADPCM_DTK
Definition: codec_id.h:388
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:684
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:672
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:53
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:164
ff_thread_report_progress2
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
Definition: utils.c:972
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:162
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:190
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
AV_CODEC_ID_8SVX_EXP
@ AV_CODEC_ID_8SVX_EXP
Definition: codec_id.h:479
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:239
ff_thread_await_progress2
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
Definition: utils.c:968
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:1856
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: utils.c:954
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:153
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
AV_CODEC_ID_PCM_S32LE_PLANAR
@ AV_CODEC_ID_PCM_S32LE_PLANAR
Definition: codec_id.h:345
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:926
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:412
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
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:178
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:270
AVPacketSideData
Definition: packet.h:315
internal.h
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:346
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:141
b
#define b
Definition: input.c:34
AV_SAMPLE_FMT_S32P
@ AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:65
data
const char data[16]
Definition: mxf.c:143
AV_CODEC_ID_PCM_U24LE
@ AV_CODEC_ID_PCM_U24LE
Definition: codec_id.h:330
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:234
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:341
AV_CODEC_ID_AMR_NB
@ AV_CODEC_ID_AMR_NB
Definition: codec_id.h:408
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:121
AV_CODEC_ID_ADPCM_AICA
@ AV_CODEC_ID_ADPCM_AICA
Definition: codec_id.h:393
AV_CODEC_ID_ADPCM_IMA_OKI
@ AV_CODEC_ID_ADPCM_IMA_OKI
Definition: codec_id.h:387
AV_CODEC_ID_PCM_SGA
@ AV_CODEC_ID_PCM_SGA
Definition: codec_id.h:352
FFCodec
Definition: codec_internal.h:112
AV_CODEC_ID_SOL_DPCM
@ AV_CODEC_ID_SOL_DPCM
Definition: codec_id.h:419
AV_CODEC_ID_WMAV2
@ AV_CODEC_ID_WMAV2
Definition: codec_id.h:433
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:383
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:246
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:2614
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:65
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
FF_CODEC_CB_TYPE_ENCODE_SUB
@ FF_CODEC_CB_TYPE_ENCODE_SUB
Definition: codec_internal.h:106
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_ID_IMC
@ AV_CODEC_ID_IMC
Definition: codec_id.h:452
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
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:172
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:156
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:480
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
thread.h
ThreadFrame::f
AVFrame * f
Definition: threadframe.h:28
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:334
AV_CODEC_ID_ADPCM_THP_LE
@ AV_CODEC_ID_ADPCM_THP_LE
Definition: codec_id.h:391
AV_CODEC_ID_AMR_WB
@ AV_CODEC_ID_AMR_WB
Definition: codec_id.h:409
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:125
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:347
AVProfile
AVProfile.
Definition: codec.h:188
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:280
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:367
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1733
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_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:356
AVPacketSideData::size
size_t size
Definition: packet.h:317
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
AV_CODEC_ID_IFF_ILBM
@ AV_CODEC_ID_IFF_ILBM
Definition: codec_id.h:186
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:233
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:317
AV_FRAME_DATA_MATRIXENCODING
@ AV_FRAME_DATA_MATRIXENCODING
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
Definition: frame.h:68
STRIDE_ALIGN
#define STRIDE_ALIGN
Definition: internal.h:45
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
AV_CODEC_ID_XAN_DPCM
@ AV_CODEC_ID_XAN_DPCM
Definition: codec_id.h:418
AV_CODEC_ID_MSZH
@ AV_CODEC_ID_MSZH
Definition: codec_id.h:103
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:978
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
ThreadFrame::owner
AVCodecContext * owner[2]
Definition: threadframe.h:29
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_SAMPLE_FMT_S64P
@ AV_SAMPLE_FMT_S64P
signed 64 bits, planar
Definition: samplefmt.h:69
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:913
AV_CODEC_ID_SMC
@ AV_CODEC_ID_SMC
Definition: codec_id.h:99
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:426
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:260
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:184
AV_CODEC_ID_8SVX_FIB
@ AV_CODEC_ID_8SVX_FIB
Definition: codec_id.h:480
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:154
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:289
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:149
AV_CODEC_ID_ATRAC3
@ AV_CODEC_ID_ATRAC3
Definition: codec_id.h:456
FF_CODEC_CB_TYPE_DECODE
@ FF_CODEC_CB_TYPE_DECODE
Definition: codec_internal.h:94
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:241
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:248
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:584
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:466
AV_CODEC_ID_ADPCM_SBPRO_2
@ AV_CODEC_ID_ADPCM_SBPRO_2
Definition: codec_id.h:372
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:236
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:243
AV_CODEC_ID_WMAV1
@ AV_CODEC_ID_WMAV1
Definition: codec_id.h:432
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:320
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:434
AV_CODEC_ID_ATRAC3P
@ AV_CODEC_ID_ATRAC3P
Definition: codec_id.h:464
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:447
duration
int64_t duration
Definition: movenc.c:64
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:188
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:455
AV_CODEC_ID_S302M
@ AV_CODEC_ID_S302M
Definition: codec_id.h:342
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:206
AV_CODEC_ID_ADPCM_IMA_ACORN
@ AV_CODEC_ID_ADPCM_IMA_ACORN
Definition: codec_id.h:405
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:366
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:256
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:165
AV_CODEC_ID_PCM_LXF
@ AV_CODEC_ID_PCM_LXF
Definition: codec_id.h:341
AV_NE
#define AV_NE(be, le)
Definition: macros.h:33
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:50
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:225
AV_CODEC_ID_ADPCM_AFC
@ AV_CODEC_ID_ADPCM_AFC
Definition: codec_id.h:386
AV_CODEC_ID_ADPCM_IMA_EA_SEAD
@ AV_CODEC_ID_ADPCM_IMA_EA_SEAD
Definition: codec_id.h:378
frame_size
int frame_size
Definition: mxfenc.c:2201
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:425
AV_CODEC_ID_ADPCM_IMA_DK3
@ AV_CODEC_ID_ADPCM_IMA_DK3
Definition: codec_id.h:357
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:245
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1549
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:114
AV_CODEC_ID_ADPCM_IMA_APC
@ AV_CODEC_ID_ADPCM_IMA_APC
Definition: codec_id.h:384
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:180
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
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:120
AVPacketSideData::data
uint8_t * data
Definition: packet.h:316
AV_CODEC_ID_ADPCM_IMA_ISS
@ AV_CODEC_ID_ADPCM_IMA_ISS
Definition: codec_id.h:382
AV_CODEC_ID_BINKAUDIO_DCT
@ AV_CODEC_ID_BINKAUDIO_DCT
Definition: codec_id.h:473
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:379
FF_CODEC_CB_TYPE_ENCODE
@ FF_CODEC_CB_TYPE_ENCODE
Definition: codec_internal.h:103
ff_alloc_entries
int ff_alloc_entries(AVCodecContext *avctx, int count)
Definition: utils.c:959
AV_CODEC_ID_PCM_F24LE
@ AV_CODEC_ID_PCM_F24LE
Definition: codec_id.h:350
channels
channels
Definition: aptx.h:32
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: utils.c:918
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:140
AV_CODEC_ID_DERF_DPCM
@ AV_CODEC_ID_DERF_DPCM
Definition: codec_id.h:422
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:322
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:319
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: utils.c:935
AV_CODEC_ID_ADPCM_IMA_SMJPEG
@ AV_CODEC_ID_ADPCM_IMA_SMJPEG
Definition: codec_id.h:360
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:163
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:371
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:335
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: defs.h:104
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
PutBitContext
Definition: put_bits.h:50
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:399
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:155
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:177
ThreadFrame::progress
AVBufferRef * progress
Definition: threadframe.h:32
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:889
AVMatrixEncoding
AVMatrixEncoding
Definition: channel_layout.h:234
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:152
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:323
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:150
threadframe.h
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:123
AV_CODEC_ID_ADPCM_EA_XAS
@ AV_CODEC_ID_ADPCM_EA_XAS
Definition: codec_id.h:380
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:870
AV_CODEC_ID_SP5X
@ AV_CODEC_ID_SP5X
Definition: codec_id.h:60
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:279
NULL
#define NULL
Definition: coverity.c:32
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:89
AV_CODEC_ID_ADPCM_YAMAHA
@ AV_CODEC_ID_ADPCM_YAMAHA
Definition: codec_id.h:369
AV_CODEC_ID_ADPCM_IMA_WS
@ AV_CODEC_ID_ADPCM_IMA_WS
Definition: codec_id.h:359
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:331
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:417
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:327
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1857
AV_CODEC_ID_ADPCM_ARGO
@ AV_CODEC_ID_ADPCM_ARGO
Definition: codec_id.h:397
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
FF_CODEC_CB_TYPE_DECODE_SUB
@ FF_CODEC_CB_TYPE_DECODE_SUB
Definition: codec_internal.h:97
AV_CODEC_ID_ADPCM_IMA_DK4
@ AV_CODEC_ID_ADPCM_IMA_DK4
Definition: codec_id.h:358
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:439
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:318
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:336
AV_CODEC_ID_CINEPAK
@ AV_CODEC_ID_CINEPAK
Definition: codec_id.h:93
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:348
AV_CODEC_ID_ZLIB
@ AV_CODEC_ID_ZLIB
Definition: codec_id.h:104
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:337
AVCodec::profiles
const AVProfile * profiles
array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
Definition: codec.h:229
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:566
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:173
AV_CODEC_ID_ADPCM_IMA_AMV
@ AV_CODEC_ID_ADPCM_IMA_AMV
Definition: codec_id.h:374
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:181
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:230
AV_CODEC_ID_ROQ_DPCM
@ AV_CODEC_ID_ROQ_DPCM
Definition: codec_id.h:416
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:267
AVProfile::profile
int profile
Definition: codec.h:189
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
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:169
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:156
ff_color_frame
void ff_color_frame(AVFrame *frame, const int c[4])
Definition: utils.c:414
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:177
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:235
AV_CODEC_ID_PCM_S24LE_PLANAR
@ AV_CODEC_ID_PCM_S24LE_PLANAR
Definition: codec_id.h:344
AV_CODEC_ID_ADPCM_XA
@ AV_CODEC_ID_ADPCM_XA
Definition: codec_id.h:363
AV_CODEC_ID_GSM
@ AV_CODEC_ID_GSM
as in Berlin toast format
Definition: codec_id.h:443
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
AV_CODEC_ID_PCM_VIDC
@ AV_CODEC_ID_PCM_VIDC
Definition: codec_id.h:351
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:242
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:931
AV_CODEC_ID_MJPEGB
@ AV_CODEC_ID_MJPEGB
Definition: codec_id.h:58
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:146
startcode.h
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:512
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *avcodec)
Definition: utils.c:82
AV_CODEC_ID_QCELP
@ AV_CODEC_ID_QCELP
Definition: codec_id.h:449
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:495
f
f
Definition: af_crystalizer.c:122
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:328
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1403
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:269
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:364
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:343
AV_SAMPLE_FMT_U8P
@ AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:63
codec_internal.h
AV_CODEC_ID_ADPCM_IMA_RAD
@ AV_CODEC_ID_ADPCM_IMA_RAD
Definition: codec_id.h:389
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:232
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:151
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:401
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:238
bps
unsigned bps
Definition: movenc.c:1631
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:368
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:443
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:326
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
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: codec_internal.h:51
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:160
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:1025
AVFrameSideData::data
uint8_t * data
Definition: frame.h:233
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:273
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:619
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:148
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:161
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:167
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: utils.c:923
ff_reset_entries
void ff_reset_entries(AVCodecContext *avctx)
Definition: utils.c:964
FFCodec::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_internal.h:246
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:1150
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:175
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:72
AV_SAMPLE_FMT_S16P
@ AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:64
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:950
AVChromaLocation
AVChromaLocation
Location of chroma samples.
Definition: pixfmt.h:618
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:176
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *avcodec)
Definition: utils.c:74
AV_CODEC_ID_VP5
@ AV_CODEC_ID_VP5
Definition: codec_id.h:140
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: defs.h:134
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:447
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1441
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:338
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:170
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:121
AV_CODEC_ID_ATRAC1
@ AV_CODEC_ID_ATRAC1
Definition: codec_id.h:471
AV_CODEC_ID_RA_288
@ AV_CODEC_ID_RA_288
Definition: codec_id.h:413
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:942
AV_CODEC_ID_ADPCM_MTAF
@ AV_CODEC_ID_ADPCM_MTAF
Definition: codec_id.h:395
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:467
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:490
AV_SAMPLE_FMT_U8
@ AV_SAMPLE_FMT_U8
unsigned 8 bits
Definition: samplefmt.h:57
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:184
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:1011
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:55
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:338
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:48
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:394
av_xiphlacing
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:856
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_CODEC_ID_ADPCM_IMA_APM
@ AV_CODEC_ID_ADPCM_IMA_APM
Definition: codec_id.h:400
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:325
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:477
av_get_audio_frame_duration
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:812
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
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:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
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:146
AV_CODEC_ID_PCM_F16LE
@ AV_CODEC_ID_PCM_F16LE
Definition: codec_id.h:349
AV_CODEC_ID_ADPCM_IMA_DAT4
@ AV_CODEC_ID_ADPCM_IMA_DAT4
Definition: codec_id.h:394
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:121
profile
int profile
Definition: mxfenc.c:2005
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:126
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
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:1129
avcodec.h
AV_CODEC_ID_IAC
@ AV_CODEC_ID_IAC
Definition: codec_id.h:483
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:207
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:455
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:200
tag
uint32_t tag
Definition: movenc.c:1630
ret
ret
Definition: filter_design.txt:187
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:1043
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:604
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
pos
unsigned int pos
Definition: spdifenc.c:412
AV_CODEC_ID_JV
@ AV_CODEC_ID_JV
Definition: codec_id.h:199
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:244
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:240
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:157
AVCodecContext
main external API structure.
Definition: avcodec.h:389
ThreadFrame
Definition: threadframe.h:27
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:390
channel_layout.h
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:61
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:153
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:61
AV_SAMPLE_FMT_DBLP
@ AV_SAMPLE_FMT_DBLP
double, planar
Definition: samplefmt.h:67
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:326
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:132
FF_CODEC_CB_TYPE_RECEIVE_FRAME
@ FF_CODEC_CB_TYPE_RECEIVE_FRAME
Definition: codec_internal.h:100
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:368
FFCodec::cb_type
unsigned cb_type
This field determines the type of the codec (decoder/encoder) and also the exact callback cb implemen...
Definition: codec_internal.h:128
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:174
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 *avcodec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:877
state
static struct @326 state
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:122
AV_CODEC_ID_TRUESPEECH
@ AV_CODEC_ID_TRUESPEECH
Definition: codec_id.h:446
shift
static int shift(int a, int b)
Definition: sonic.c:88
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
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:562
AV_CODEC_ID_ADPCM_THP
@ AV_CODEC_ID_ADPCM_THP
Definition: codec_id.h:373
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:124
tc
#define tc
Definition: regdef.h:69
desc
const char * desc
Definition: libsvtav1.c:83
AV_CODEC_ID_PCM_S32LE
@ AV_CODEC_ID_PCM_S32LE
Definition: codec_id.h:324
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:103
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
mem.h
bcd2uint
static unsigned bcd2uint(uint8_t bcd)
Definition: utils.c:1056
AV_CODEC_ID_ADPCM_SBPRO_4
@ AV_CODEC_ID_ADPCM_SBPRO_4
Definition: codec_id.h:370
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:321
AV_CODEC_ID_RPZA
@ AV_CODEC_ID_RPZA
Definition: codec_id.h:92
AV_CODEC_ID_SDX2_DPCM
@ AV_CODEC_ID_SDX2_DPCM
Definition: codec_id.h:420
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:90
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:105
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:179
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:231
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_PCM_S24DAUD
Definition: codec_id.h:332
AV_CODEC_ID_ADPCM_IMA_SSI
@ AV_CODEC_ID_ADPCM_IMA_SSI
Definition: codec_id.h:398
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
AV_CODEC_ID_PCM_F64LE
@ AV_CODEC_ID_PCM_F64LE
Definition: codec_id.h:339
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:1065
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:414
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AV_CODEC_ID_ADPCM_IMA_MOFLEX
@ AV_CODEC_ID_ADPCM_IMA_MOFLEX
Definition: codec_id.h:404
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:61
AV_CODEC_ID_ADPCM_IMA_WAV
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition: codec_id.h:356
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:830
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:561
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:268
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:182
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
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:157
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:183
AV_CODEC_ID_ILBC
@ AV_CODEC_ID_ILBC
Definition: codec_id.h:484
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:247
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:343
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:318
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:626
AV_CODEC_ID_DFPWM
@ AV_CODEC_ID_DFPWM
Definition: codec_id.h:521
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:337
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:90
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVCodecHWConfig
Definition: codec.h:350
AV_CODEC_ID_ADPCM_4XM
@ AV_CODEC_ID_ADPCM_4XM
Definition: codec_id.h:362
AV_SAMPLE_FMT_DBL
@ AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:61
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3545
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:323
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:185
AV_CODEC_ID_MUSEPACK7
@ AV_CODEC_ID_MUSEPACK7
Definition: codec_id.h:453
AV_CODEC_ID_ADPCM_PSX
@ AV_CODEC_ID_ADPCM_PSX
Definition: codec_id.h:392
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:335
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:946
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: codec_id.h:59
AV_CODEC_ID_MP1
@ AV_CODEC_ID_MP1
Definition: codec_id.h:467
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:237
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:329
ff_thread_init
int ff_thread_init(AVCodecContext *s)
Definition: utils.c:849
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:168
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
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:759
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:166
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:458
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:371
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:171