FFmpeg
pcm.c
Go to the documentation of this file.
1 /*
2  * PCM codecs
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * PCM codecs
25  */
26 
27 #include "libavutil/attributes.h"
28 #include "libavutil/float_dsp.h"
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "internal.h"
32 #include "mathops.h"
33 #include "pcm_tablegen.h"
34 
36 {
37  avctx->frame_size = 0;
38  switch (avctx->codec->id) {
41  break;
44  break;
47  break;
48  default:
49  break;
50  }
51 
53  avctx->block_align = avctx->channels * avctx->bits_per_coded_sample / 8;
54  avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate;
55 
56  return 0;
57 }
58 
59 /**
60  * Write PCM samples macro
61  * @param type Datatype of native machine format
62  * @param endian bytestream_put_xxx() suffix
63  * @param src Source pointer (variable name)
64  * @param dst Destination pointer (variable name)
65  * @param n Total number of samples (variable name)
66  * @param shift Bitshift (bits)
67  * @param offset Sample value offset
68  */
69 #define ENCODE(type, endian, src, dst, n, shift, offset) \
70  samples_ ## type = (const type *) src; \
71  for (; n > 0; n--) { \
72  register type v = (*samples_ ## type++ >> shift) + offset; \
73  bytestream_put_ ## endian(&dst, v); \
74  }
75 
76 #define ENCODE_PLANAR(type, endian, dst, n, shift, offset) \
77  n /= avctx->channels; \
78  for (c = 0; c < avctx->channels; c++) { \
79  int i; \
80  samples_ ## type = (const type *) frame->extended_data[c]; \
81  for (i = n; i > 0; i--) { \
82  register type v = (*samples_ ## type++ >> shift) + offset; \
83  bytestream_put_ ## endian(&dst, v); \
84  } \
85  }
86 
87 static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
88  const AVFrame *frame, int *got_packet_ptr)
89 {
90  int n, c, sample_size, v, ret;
91  const short *samples;
92  unsigned char *dst;
93  const uint8_t *samples_uint8_t;
94  const int16_t *samples_int16_t;
95  const int32_t *samples_int32_t;
96  const int64_t *samples_int64_t;
97  const uint16_t *samples_uint16_t;
98  const uint32_t *samples_uint32_t;
99 
100  sample_size = av_get_bits_per_sample(avctx->codec->id) / 8;
101  n = frame->nb_samples * avctx->channels;
102  samples = (const short *)frame->data[0];
103 
104  if ((ret = ff_alloc_packet2(avctx, avpkt, n * sample_size, n * sample_size)) < 0)
105  return ret;
106  dst = avpkt->data;
107 
108  switch (avctx->codec->id) {
110  ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
111  break;
113  ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
114  break;
116  ENCODE(int32_t, le24, samples, dst, n, 8, 0)
117  break;
119  ENCODE_PLANAR(int32_t, le24, dst, n, 8, 0)
120  break;
122  ENCODE(int32_t, be24, samples, dst, n, 8, 0)
123  break;
125  ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
126  break;
128  ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
129  break;
131  for (; n > 0; n--) {
132  uint32_t tmp = ff_reverse[(*samples >> 8) & 0xff] +
133  (ff_reverse[*samples & 0xff] << 8);
134  tmp <<= 4; // sync flags would go here
135  bytestream_put_be24(&dst, tmp);
136  samples++;
137  }
138  break;
140  ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
141  break;
143  ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
144  break;
145  case AV_CODEC_ID_PCM_S8:
146  ENCODE(uint8_t, byte, samples, dst, n, 0, -128)
147  break;
149  ENCODE_PLANAR(uint8_t, byte, dst, n, 0, -128)
150  break;
151 #if HAVE_BIGENDIAN
154  ENCODE(int64_t, le64, samples, dst, n, 0, 0)
155  break;
158  ENCODE(int32_t, le32, samples, dst, n, 0, 0)
159  break;
161  ENCODE_PLANAR(int32_t, le32, dst, n, 0, 0)
162  break;
164  ENCODE(int16_t, le16, samples, dst, n, 0, 0)
165  break;
167  ENCODE_PLANAR(int16_t, le16, dst, n, 0, 0)
168  break;
174 #else
177  ENCODE(int64_t, be64, samples, dst, n, 0, 0)
178  break;
181  ENCODE(int32_t, be32, samples, dst, n, 0, 0)
182  break;
184  ENCODE(int16_t, be16, samples, dst, n, 0, 0)
185  break;
187  ENCODE_PLANAR(int16_t, be16, dst, n, 0, 0)
188  break;
194 #endif /* HAVE_BIGENDIAN */
195  case AV_CODEC_ID_PCM_U8:
196  memcpy(dst, samples, n * sample_size);
197  break;
198 #if HAVE_BIGENDIAN
200 #else
203 #endif /* HAVE_BIGENDIAN */
204  n /= avctx->channels;
205  for (c = 0; c < avctx->channels; c++) {
206  const uint8_t *src = frame->extended_data[c];
207  bytestream_put_buffer(&dst, src, n * sample_size);
208  }
209  break;
211  for (; n > 0; n--) {
212  v = *samples++;
213  *dst++ = linear_to_alaw[(v + 32768) >> 2];
214  }
215  break;
217  for (; n > 0; n--) {
218  v = *samples++;
219  *dst++ = linear_to_ulaw[(v + 32768) >> 2];
220  }
221  break;
223  for (; n > 0; n--) {
224  v = *samples++;
225  *dst++ = linear_to_vidc[(v + 32768) >> 2];
226  }
227  break;
228  default:
229  return -1;
230  }
231 
232  *got_packet_ptr = 1;
233  return 0;
234 }
235 
236 typedef struct PCMDecode {
237  short table[256];
239  float scale;
240 } PCMDecode;
241 
243 {
244  PCMDecode *s = avctx->priv_data;
245  int i;
246 
247  if (avctx->channels <= 0) {
248  av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
249  return AVERROR(EINVAL);
250  }
251 
252  switch (avctx->codec_id) {
254  for (i = 0; i < 256; i++)
255  s->table[i] = alaw2linear(i);
256  break;
258  for (i = 0; i < 256; i++)
259  s->table[i] = ulaw2linear(i);
260  break;
262  for (i = 0; i < 256; i++)
263  s->table[i] = vidc2linear(i);
264  break;
267  s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));
269  if (!s->fdsp)
270  return AVERROR(ENOMEM);
271  break;
272  default:
273  break;
274  }
275 
276  avctx->sample_fmt = avctx->codec->sample_fmts[0];
277 
278  if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
280 
281  return 0;
282 }
283 
285 {
286  PCMDecode *s = avctx->priv_data;
287 
288  av_freep(&s->fdsp);
289 
290  return 0;
291 }
292 
293 /**
294  * Read PCM samples macro
295  * @param size Data size of native machine format
296  * @param endian bytestream_get_xxx() endian suffix
297  * @param src Source pointer (variable name)
298  * @param dst Destination pointer (variable name)
299  * @param n Total number of samples (variable name)
300  * @param shift Bitshift (bits)
301  * @param offset Sample value offset
302  */
303 #define DECODE(size, endian, src, dst, n, shift, offset) \
304  for (; n > 0; n--) { \
305  uint ## size ## _t v = bytestream_get_ ## endian(&src); \
306  AV_WN ## size ## A(dst, (v - offset) << shift); \
307  dst += size / 8; \
308  }
309 
310 #define DECODE_PLANAR(size, endian, src, dst, n, shift, offset) \
311  n /= avctx->channels; \
312  for (c = 0; c < avctx->channels; c++) { \
313  int i; \
314  dst = frame->extended_data[c]; \
315  for (i = n; i > 0; i--) { \
316  uint ## size ## _t v = bytestream_get_ ## endian(&src); \
317  AV_WN ## size ## A(dst, (v - offset) << shift); \
318  dst += size / 8; \
319  } \
320  }
321 
322 static int pcm_decode_frame(AVCodecContext *avctx, void *data,
323  int *got_frame_ptr, AVPacket *avpkt)
324 {
325  const uint8_t *src = avpkt->data;
326  int buf_size = avpkt->size;
327  PCMDecode *s = avctx->priv_data;
328  AVFrame *frame = data;
329  int sample_size, c, n, ret, samples_per_block;
330  uint8_t *samples;
331  int32_t *dst_int32_t;
332 
333  sample_size = av_get_bits_per_sample(avctx->codec_id) / 8;
334 
335  /* av_get_bits_per_sample returns 0 for AV_CODEC_ID_PCM_DVD */
336  samples_per_block = 1;
337  if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {
338  /* we process 40-bit blocks per channel for LXF */
339  samples_per_block = 2;
340  sample_size = 5;
341  }
342 
343  if (sample_size == 0) {
344  av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");
345  return AVERROR(EINVAL);
346  }
347 
348  if (avctx->channels == 0) {
349  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
350  return AVERROR(EINVAL);
351  }
352 
353  if (avctx->codec_id != avctx->codec->id) {
354  av_log(avctx, AV_LOG_ERROR, "codec ids mismatch\n");
355  return AVERROR(EINVAL);
356  }
357 
358  n = avctx->channels * sample_size;
359 
360  if (n && buf_size % n) {
361  if (buf_size < n) {
362  av_log(avctx, AV_LOG_ERROR,
363  "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",
364  buf_size, n);
365  return AVERROR_INVALIDDATA;
366  } else
367  buf_size -= buf_size % n;
368  }
369 
370  n = buf_size / sample_size;
371 
372  /* get output buffer */
373  frame->nb_samples = n * samples_per_block / avctx->channels;
374  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
375  return ret;
376  samples = frame->data[0];
377 
378  switch (avctx->codec_id) {
380  DECODE(32, le32, src, samples, n, 0, 0x80000000)
381  break;
383  DECODE(32, be32, src, samples, n, 0, 0x80000000)
384  break;
386  DECODE(32, le24, src, samples, n, 8, 0)
387  break;
389  DECODE_PLANAR(32, le24, src, samples, n, 8, 0);
390  break;
392  DECODE(32, be24, src, samples, n, 8, 0)
393  break;
395  DECODE(32, le24, src, samples, n, 8, 0x800000)
396  break;
398  DECODE(32, be24, src, samples, n, 8, 0x800000)
399  break;
401  for (; n > 0; n--) {
402  uint32_t v = bytestream_get_be24(&src);
403  v >>= 4; // sync flags are here
404  AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
405  (ff_reverse[v & 0xff] << 8));
406  samples += 2;
407  }
408  break;
410  DECODE(16, le16, src, samples, n, 0, 0x8000)
411  break;
413  DECODE(16, be16, src, samples, n, 0, 0x8000)
414  break;
415  case AV_CODEC_ID_PCM_S8:
416  for (; n > 0; n--)
417  *samples++ = *src++ + 128;
418  break;
420  n /= avctx->channels;
421  for (c = 0; c < avctx->channels; c++) {
422  int i;
423  samples = frame->extended_data[c];
424  for (i = n; i > 0; i--)
425  *samples++ = *src++ + 128;
426  }
427  break;
428 #if HAVE_BIGENDIAN
431  DECODE(64, le64, src, samples, n, 0, 0)
432  break;
437  DECODE(32, le32, src, samples, n, 0, 0)
438  break;
440  DECODE_PLANAR(32, le32, src, samples, n, 0, 0);
441  break;
443  DECODE(16, le16, src, samples, n, 0, 0)
444  break;
446  DECODE_PLANAR(16, le16, src, samples, n, 0, 0);
447  break;
453 #else
456  DECODE(64, be64, src, samples, n, 0, 0)
457  break;
460  DECODE(32, be32, src, samples, n, 0, 0)
461  break;
463  DECODE(16, be16, src, samples, n, 0, 0)
464  break;
466  DECODE_PLANAR(16, be16, src, samples, n, 0, 0);
467  break;
475 #endif /* HAVE_BIGENDIAN */
476  case AV_CODEC_ID_PCM_U8:
477  memcpy(samples, src, n * sample_size);
478  break;
479 #if HAVE_BIGENDIAN
481 #else
484 #endif /* HAVE_BIGENDIAN */
485  n /= avctx->channels;
486  for (c = 0; c < avctx->channels; c++) {
487  samples = frame->extended_data[c];
488  bytestream_get_buffer(&src, samples, n * sample_size);
489  }
490  break;
492  for (; n > 0; n--) {
493  int v = *src++;
494  if (v < 128)
495  v = 128 - v;
496  *samples++ = v;
497  }
498  break;
502  for (; n > 0; n--) {
503  AV_WN16A(samples, s->table[*src++]);
504  samples += 2;
505  }
506  break;
507  case AV_CODEC_ID_PCM_LXF:
508  {
509  int i;
510  n /= avctx->channels;
511  for (c = 0; c < avctx->channels; c++) {
512  dst_int32_t = (int32_t *)frame->extended_data[c];
513  for (i = 0; i < n; i++) {
514  // extract low 20 bits and expand to 32 bits
515  *dst_int32_t++ = (src[2] << 28) |
516  (src[1] << 20) |
517  (src[0] << 12) |
518  ((src[2] & 0x0F) << 8) |
519  src[1];
520  // extract high 20 bits and expand to 32 bits
521  *dst_int32_t++ = (src[4] << 24) |
522  (src[3] << 16) |
523  ((src[2] & 0xF0) << 8) |
524  (src[4] << 4) |
525  (src[3] >> 4);
526  src += 5;
527  }
528  }
529  break;
530  }
531  default:
532  return -1;
533  }
534 
535  if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
536  avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
537  s->fdsp->vector_fmul_scalar((float *)frame->extended_data[0],
538  (const float *)frame->extended_data[0],
539  s->scale, FFALIGN(frame->nb_samples * avctx->channels, 4));
540  emms_c();
541  }
542 
543  *got_frame_ptr = 1;
544 
545  return buf_size;
546 }
547 
548 #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
549 #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_) \
550 AVCodec ff_ ## name_ ## _encoder = { \
551  .name = #name_, \
552  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
553  .type = AVMEDIA_TYPE_AUDIO, \
554  .id = AV_CODEC_ID_ ## id_, \
555  .init = pcm_encode_init, \
556  .encode2 = pcm_encode_frame, \
557  .capabilities = AV_CODEC_CAP_VARIABLE_FRAME_SIZE, \
558  .sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_, \
559  AV_SAMPLE_FMT_NONE }, \
560 }
561 
562 #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name) \
563  PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)
564 #define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name) \
565  PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)
566 #define PCM_ENCODER(id, sample_fmt, name, long_name) \
567  PCM_ENCODER_3(CONFIG_ ## id ## _ENCODER, id, sample_fmt, name, long_name)
568 
569 #define PCM_DECODER_0(id, sample_fmt, name, long_name)
570 #define PCM_DECODER_1(id_, sample_fmt_, name_, long_name_) \
571 AVCodec ff_ ## name_ ## _decoder = { \
572  .name = #name_, \
573  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
574  .type = AVMEDIA_TYPE_AUDIO, \
575  .id = AV_CODEC_ID_ ## id_, \
576  .priv_data_size = sizeof(PCMDecode), \
577  .init = pcm_decode_init, \
578  .close = pcm_decode_close, \
579  .decode = pcm_decode_frame, \
580  .capabilities = AV_CODEC_CAP_DR1, \
581  .sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_, \
582  AV_SAMPLE_FMT_NONE }, \
583 }
584 
585 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name) \
586  PCM_DECODER_ ## cf(id, sample_fmt, name, long_name)
587 #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name) \
588  PCM_DECODER_2(cf, id, sample_fmt, name, long_name)
589 #define PCM_DECODER(id, sample_fmt, name, long_name) \
590  PCM_DECODER_3(CONFIG_ ## id ## _DECODER, id, sample_fmt, name, long_name)
591 
592 #define PCM_CODEC(id, sample_fmt_, name, long_name_) \
593  PCM_ENCODER(id, sample_fmt_, name, long_name_); \
594  PCM_DECODER(id, sample_fmt_, name, long_name_)
595 
596 /* Note: Do not forget to add new entries to the Makefile as well. */
597 PCM_CODEC (PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law / G.711 A-law");
598 PCM_DECODER(PCM_F16LE, AV_SAMPLE_FMT_FLT, pcm_f16le, "PCM 16.8 floating point little-endian");
599 PCM_DECODER(PCM_F24LE, AV_SAMPLE_FMT_FLT, pcm_f24le, "PCM 24.0 floating point little-endian");
600 PCM_CODEC (PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
601 PCM_CODEC (PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
602 PCM_CODEC (PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
603 PCM_CODEC (PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
604 PCM_DECODER(PCM_LXF, AV_SAMPLE_FMT_S32P,pcm_lxf, "PCM signed 20-bit little-endian planar");
605 PCM_CODEC (PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law / G.711 mu-law");
606 PCM_CODEC (PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");
607 PCM_CODEC (PCM_S8_PLANAR, AV_SAMPLE_FMT_U8P, pcm_s8_planar, "PCM signed 8-bit planar");
608 PCM_CODEC (PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
609 PCM_CODEC (PCM_S16BE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16be_planar, "PCM signed 16-bit big-endian planar");
610 PCM_CODEC (PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
611 PCM_CODEC (PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16le_planar, "PCM signed 16-bit little-endian planar");
612 PCM_CODEC (PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
613 PCM_CODEC (PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
614 PCM_CODEC (PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
615 PCM_CODEC (PCM_S24LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s24le_planar, "PCM signed 24-bit little-endian planar");
616 PCM_CODEC (PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
617 PCM_CODEC (PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
618 PCM_CODEC (PCM_S32LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s32le_planar, "PCM signed 32-bit little-endian planar");
619 PCM_CODEC (PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");
620 PCM_CODEC (PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
621 PCM_CODEC (PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
622 PCM_CODEC (PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
623 PCM_CODEC (PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
624 PCM_CODEC (PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
625 PCM_CODEC (PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
626 PCM_DECODER(PCM_ZORK, AV_SAMPLE_FMT_U8, pcm_zork, "PCM Zork");
627 PCM_CODEC (PCM_S64BE, AV_SAMPLE_FMT_S64, pcm_s64be, "PCM signed 64-bit big-endian");
628 PCM_CODEC (PCM_S64LE, AV_SAMPLE_FMT_S64, pcm_s64le, "PCM signed 64-bit little-endian");
629 PCM_CODEC (PCM_VIDC, AV_SAMPLE_FMT_S16, pcm_vidc, "PCM Archimedes VIDC");
const struct AVCodec * codec
Definition: avcodec.h:1577
static av_cold int vidc2linear(unsigned char u_val)
Definition: pcm_tablegen.h:78
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void pcm_alaw_tableinit(void)
Definition: pcm_tablegen.h:127
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
static void pcm_ulaw_tableinit(void)
Definition: pcm_tablegen.h:132
const uint8_t ff_reverse[256]
Definition: reverse.c:23
#define DECODE_PLANAR(size, endian, src, dst, n, shift, offset)
Definition: pcm.c:310
static av_cold int ulaw2linear(unsigned char u_val)
Definition: pcm_tablegen.h:61
static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: pcm.c:87
int size
Definition: avcodec.h:1481
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2799
#define src
Definition: vp8dsp.c:254
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:2265
Macro definitions for various function/variable attributes.
uint64_t_TMPL AV_WL64 unsigned int_TMPL le32
Definition: bytestream.h:87
Definition: pcm.c:236
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
short table[256]
Definition: pcm.c:237
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
uint8_t
#define av_cold
Definition: attributes.h:82
AV_SAMPLE_FMT_U8
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
static av_cold int pcm_decode_close(AVCodecContext *avctx)
Definition: pcm.c:284
uint8_t * data
Definition: avcodec.h:1480
static uint8_t linear_to_ulaw[16384]
Definition: pcm_tablegen.h:100
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2792
signed 32 bits
Definition: samplefmt.h:62
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_WB32 unsigned int_TMPL be24
Definition: bytestream.h:87
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
static int pcm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: pcm.c:322
enum AVCodecID id
Definition: avcodec.h:3498
#define PCM_CODEC(id, sample_fmt_, name, long_name_)
Definition: pcm.c:592
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1517
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
#define DECODE(size, endian, src, dst, n, shift, offset)
Read PCM samples macro.
Definition: pcm.c:303
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL be64
Definition: bytestream.h:87
#define ENCODE_PLANAR(type, endian, dst, n, shift, offset)
Definition: pcm.c:76
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_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL be16
Definition: bytestream.h:87
static void pcm_vidc_tableinit(void)
Definition: pcm_tablegen.h:137
#define ENCODE(type, endian, src, dst, n, shift, offset)
Write PCM samples macro.
Definition: pcm.c:69
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL le24
Definition: bytestream.h:87
static av_cold int pcm_encode_init(AVCodecContext *avctx)
Definition: pcm.c:35
static av_cold int alaw2linear(unsigned char a_val)
Definition: pcm_tablegen.h:46
signed 32 bits, planar
Definition: samplefmt.h:68
uint64_t_TMPL le64
Definition: bytestream.h:87
signed 64 bits
Definition: samplefmt.h:71
int32_t
float scale
Definition: pcm.c:239
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
unsigned 8 bits, planar
Definition: samplefmt.h:66
#define AV_WN16A(p, v)
Definition: intreadwrite.h:534
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
Definition: bytestream.h:359
if(ret)
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2248
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1578
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_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
int sample_rate
samples per second
Definition: avcodec.h:2228
main external API structure.
Definition: avcodec.h:1568
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1963
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 be32
Definition: bytestream.h:87
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL le16
Definition: bytestream.h:87
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:85
static av_cold int pcm_decode_init(AVCodecContext *avctx)
Definition: pcm.c:242
#define PCM_DECODER(id, sample_fmt, name, long_name)
Definition: pcm.c:589
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
common internal api header.
signed 16 bits
Definition: samplefmt.h:61
static uint8_t linear_to_vidc[16384]
Definition: pcm_tablegen.h:101
static uint8_t linear_to_alaw[16384]
Definition: pcm_tablegen.h:99
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
void * priv_data
Definition: avcodec.h:1595
int channels
number of audio channels
Definition: avcodec.h:2229
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
signed 16 bits, planar
Definition: samplefmt.h:67
AVFloatDSPContext * fdsp
Definition: pcm.c:238
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3507
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
This structure stores compressed data.
Definition: avcodec.h:1457
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
for(j=16;j >0;--j)
static uint8_t tmp[11]
Definition: aes_ctr.c:26