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 
35 static av_cold int pcm_encode_init(AVCodecContext *avctx)
36 {
37  avctx->frame_size = 0;
38  switch (avctx->codec->id) {
39  case AV_CODEC_ID_PCM_ALAW:
40  pcm_alaw_tableinit();
41  break;
42  case AV_CODEC_ID_PCM_MULAW:
43  pcm_ulaw_tableinit();
44  break;
45  case AV_CODEC_ID_PCM_VIDC:
46  pcm_vidc_tableinit();
47  break;
48  default:
49  break;
50  }
51 
52  avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
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) {
109  case AV_CODEC_ID_PCM_U32LE:
110  ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
111  break;
112  case AV_CODEC_ID_PCM_U32BE:
113  ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
114  break;
115  case AV_CODEC_ID_PCM_S24LE:
116  ENCODE(int32_t, le24, samples, dst, n, 8, 0)
117  break;
118  case AV_CODEC_ID_PCM_S24LE_PLANAR:
119  ENCODE_PLANAR(int32_t, le24, dst, n, 8, 0)
120  break;
121  case AV_CODEC_ID_PCM_S24BE:
122  ENCODE(int32_t, be24, samples, dst, n, 8, 0)
123  break;
124  case AV_CODEC_ID_PCM_U24LE:
125  ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
126  break;
127  case AV_CODEC_ID_PCM_U24BE:
128  ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
129  break;
130  case AV_CODEC_ID_PCM_S24DAUD:
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;
139  case AV_CODEC_ID_PCM_U16LE:
140  ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
141  break;
142  case AV_CODEC_ID_PCM_U16BE:
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;
148  case AV_CODEC_ID_PCM_S8_PLANAR:
149  ENCODE_PLANAR(uint8_t, byte, dst, n, 0, -128)
150  break;
151 #if HAVE_BIGENDIAN
152  case AV_CODEC_ID_PCM_S64LE:
153  case AV_CODEC_ID_PCM_F64LE:
154  ENCODE(int64_t, le64, samples, dst, n, 0, 0)
155  break;
156  case AV_CODEC_ID_PCM_S32LE:
157  case AV_CODEC_ID_PCM_F32LE:
158  ENCODE(int32_t, le32, samples, dst, n, 0, 0)
159  break;
160  case AV_CODEC_ID_PCM_S32LE_PLANAR:
161  ENCODE_PLANAR(int32_t, le32, dst, n, 0, 0)
162  break;
163  case AV_CODEC_ID_PCM_S16LE:
164  ENCODE(int16_t, le16, samples, dst, n, 0, 0)
165  break;
166  case AV_CODEC_ID_PCM_S16LE_PLANAR:
167  ENCODE_PLANAR(int16_t, le16, dst, n, 0, 0)
168  break;
169  case AV_CODEC_ID_PCM_F64BE:
170  case AV_CODEC_ID_PCM_F32BE:
171  case AV_CODEC_ID_PCM_S64BE:
172  case AV_CODEC_ID_PCM_S32BE:
173  case AV_CODEC_ID_PCM_S16BE:
174 #else
175  case AV_CODEC_ID_PCM_S64BE:
176  case AV_CODEC_ID_PCM_F64BE:
177  ENCODE(int64_t, be64, samples, dst, n, 0, 0)
178  break;
179  case AV_CODEC_ID_PCM_F32BE:
180  case AV_CODEC_ID_PCM_S32BE:
181  ENCODE(int32_t, be32, samples, dst, n, 0, 0)
182  break;
183  case AV_CODEC_ID_PCM_S16BE:
184  ENCODE(int16_t, be16, samples, dst, n, 0, 0)
185  break;
186  case AV_CODEC_ID_PCM_S16BE_PLANAR:
187  ENCODE_PLANAR(int16_t, be16, dst, n, 0, 0)
188  break;
189  case AV_CODEC_ID_PCM_F64LE:
190  case AV_CODEC_ID_PCM_F32LE:
191  case AV_CODEC_ID_PCM_S64LE:
192  case AV_CODEC_ID_PCM_S32LE:
193  case AV_CODEC_ID_PCM_S16LE:
194 #endif /* HAVE_BIGENDIAN */
195  case AV_CODEC_ID_PCM_U8:
196  memcpy(dst, samples, n * sample_size);
197  break;
198 #if HAVE_BIGENDIAN
199  case AV_CODEC_ID_PCM_S16BE_PLANAR:
200 #else
201  case AV_CODEC_ID_PCM_S16LE_PLANAR:
202  case AV_CODEC_ID_PCM_S32LE_PLANAR:
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;
210  case AV_CODEC_ID_PCM_ALAW:
211  for (; n > 0; n--) {
212  v = *samples++;
213  *dst++ = linear_to_alaw[(v + 32768) >> 2];
214  }
215  break;
216  case AV_CODEC_ID_PCM_MULAW:
217  for (; n > 0; n--) {
218  v = *samples++;
219  *dst++ = linear_to_ulaw[(v + 32768) >> 2];
220  }
221  break;
222  case AV_CODEC_ID_PCM_VIDC:
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];
238  AVFloatDSPContext *fdsp;
239  float scale;
240 } PCMDecode;
241 
242 static av_cold int pcm_decode_init(AVCodecContext *avctx)
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) {
253  case AV_CODEC_ID_PCM_ALAW:
254  for (i = 0; i < 256; i++)
255  s->table[i] = alaw2linear(i);
256  break;
257  case AV_CODEC_ID_PCM_MULAW:
258  for (i = 0; i < 256; i++)
259  s->table[i] = ulaw2linear(i);
260  break;
261  case AV_CODEC_ID_PCM_VIDC:
262  for (i = 0; i < 256; i++)
263  s->table[i] = vidc2linear(i);
264  break;
265  case AV_CODEC_ID_PCM_F16LE:
266  case AV_CODEC_ID_PCM_F24LE:
267  if (avctx->bits_per_coded_sample < 1 || avctx->bits_per_coded_sample > 24)
268  return AVERROR_INVALIDDATA;
269 
270  s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));
271  s->fdsp = avpriv_float_dsp_alloc(0);
272  if (!s->fdsp)
273  return AVERROR(ENOMEM);
274  break;
275  default:
276  break;
277  }
278 
279  avctx->sample_fmt = avctx->codec->sample_fmts[0];
280 
281  if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
282  avctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec_id);
283 
284  return 0;
285 }
286 
287 static av_cold int pcm_decode_close(AVCodecContext *avctx)
288 {
289  PCMDecode *s = avctx->priv_data;
290 
291  av_freep(&s->fdsp);
292 
293  return 0;
294 }
295 
296 /**
297  * Read PCM samples macro
298  * @param size Data size of native machine format
299  * @param endian bytestream_get_xxx() endian suffix
300  * @param src Source pointer (variable name)
301  * @param dst Destination pointer (variable name)
302  * @param n Total number of samples (variable name)
303  * @param shift Bitshift (bits)
304  * @param offset Sample value offset
305  */
306 #define DECODE(size, endian, src, dst, n, shift, offset) \
307  for (; n > 0; n--) { \
308  uint ## size ## _t v = bytestream_get_ ## endian(&src); \
309  AV_WN ## size ## A(dst, (uint ## size ## _t)(v - offset) << shift); \
310  dst += size / 8; \
311  }
312 
313 #define DECODE_PLANAR(size, endian, src, dst, n, shift, offset) \
314  n /= avctx->channels; \
315  for (c = 0; c < avctx->channels; c++) { \
316  int i; \
317  dst = frame->extended_data[c]; \
318  for (i = n; i > 0; i--) { \
319  uint ## size ## _t v = bytestream_get_ ## endian(&src); \
320  AV_WN ## size ## A(dst, (uint ## size ##_t)(v - offset) << shift); \
321  dst += size / 8; \
322  } \
323  }
324 
325 static int pcm_decode_frame(AVCodecContext *avctx, void *data,
326  int *got_frame_ptr, AVPacket *avpkt)
327 {
328  const uint8_t *src = avpkt->data;
329  int buf_size = avpkt->size;
330  PCMDecode *s = avctx->priv_data;
331  AVFrame *frame = data;
332  int sample_size, c, n, ret, samples_per_block;
333  uint8_t *samples;
334  int32_t *dst_int32_t;
335 
336  sample_size = av_get_bits_per_sample(avctx->codec_id) / 8;
337 
338  /* av_get_bits_per_sample returns 0 for AV_CODEC_ID_PCM_DVD */
339  samples_per_block = 1;
340  if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {
341  /* we process 40-bit blocks per channel for LXF */
342  samples_per_block = 2;
343  sample_size = 5;
344  }
345 
346  if (sample_size == 0) {
347  av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");
348  return AVERROR(EINVAL);
349  }
350 
351  if (avctx->channels == 0) {
352  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
353  return AVERROR(EINVAL);
354  }
355 
356  if (avctx->codec_id != avctx->codec->id) {
357  av_log(avctx, AV_LOG_ERROR, "codec ids mismatch\n");
358  return AVERROR(EINVAL);
359  }
360 
361  n = avctx->channels * sample_size;
362 
363  if (n && buf_size % n) {
364  if (buf_size < n) {
365  av_log(avctx, AV_LOG_ERROR,
366  "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",
367  buf_size, n);
368  return AVERROR_INVALIDDATA;
369  } else
370  buf_size -= buf_size % n;
371  }
372 
373  n = buf_size / sample_size;
374 
375  /* get output buffer */
376  frame->nb_samples = n * samples_per_block / avctx->channels;
377  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
378  return ret;
379  samples = frame->data[0];
380 
381  switch (avctx->codec_id) {
382  case AV_CODEC_ID_PCM_U32LE:
383  DECODE(32, le32, src, samples, n, 0, 0x80000000)
384  break;
385  case AV_CODEC_ID_PCM_U32BE:
386  DECODE(32, be32, src, samples, n, 0, 0x80000000)
387  break;
388  case AV_CODEC_ID_PCM_S24LE:
389  DECODE(32, le24, src, samples, n, 8, 0)
390  break;
391  case AV_CODEC_ID_PCM_S24LE_PLANAR:
392  DECODE_PLANAR(32, le24, src, samples, n, 8, 0);
393  break;
394  case AV_CODEC_ID_PCM_S24BE:
395  DECODE(32, be24, src, samples, n, 8, 0)
396  break;
397  case AV_CODEC_ID_PCM_U24LE:
398  DECODE(32, le24, src, samples, n, 8, 0x800000)
399  break;
400  case AV_CODEC_ID_PCM_U24BE:
401  DECODE(32, be24, src, samples, n, 8, 0x800000)
402  break;
403  case AV_CODEC_ID_PCM_S24DAUD:
404  for (; n > 0; n--) {
405  uint32_t v = bytestream_get_be24(&src);
406  v >>= 4; // sync flags are here
407  AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
408  (ff_reverse[v & 0xff] << 8));
409  samples += 2;
410  }
411  break;
412  case AV_CODEC_ID_PCM_U16LE:
413  DECODE(16, le16, src, samples, n, 0, 0x8000)
414  break;
415  case AV_CODEC_ID_PCM_U16BE:
416  DECODE(16, be16, src, samples, n, 0, 0x8000)
417  break;
418  case AV_CODEC_ID_PCM_S8:
419  for (; n > 0; n--)
420  *samples++ = *src++ + 128;
421  break;
422  case AV_CODEC_ID_PCM_S8_PLANAR:
423  n /= avctx->channels;
424  for (c = 0; c < avctx->channels; c++) {
425  int i;
426  samples = frame->extended_data[c];
427  for (i = n; i > 0; i--)
428  *samples++ = *src++ + 128;
429  }
430  break;
431 #if HAVE_BIGENDIAN
432  case AV_CODEC_ID_PCM_S64LE:
433  case AV_CODEC_ID_PCM_F64LE:
434  DECODE(64, le64, src, samples, n, 0, 0)
435  break;
436  case AV_CODEC_ID_PCM_S32LE:
437  case AV_CODEC_ID_PCM_F32LE:
438  case AV_CODEC_ID_PCM_F24LE:
439  case AV_CODEC_ID_PCM_F16LE:
440  DECODE(32, le32, src, samples, n, 0, 0)
441  break;
442  case AV_CODEC_ID_PCM_S32LE_PLANAR:
443  DECODE_PLANAR(32, le32, src, samples, n, 0, 0);
444  break;
445  case AV_CODEC_ID_PCM_S16LE:
446  DECODE(16, le16, src, samples, n, 0, 0)
447  break;
448  case AV_CODEC_ID_PCM_S16LE_PLANAR:
449  DECODE_PLANAR(16, le16, src, samples, n, 0, 0);
450  break;
451  case AV_CODEC_ID_PCM_F64BE:
452  case AV_CODEC_ID_PCM_F32BE:
453  case AV_CODEC_ID_PCM_S64BE:
454  case AV_CODEC_ID_PCM_S32BE:
455  case AV_CODEC_ID_PCM_S16BE:
456 #else
457  case AV_CODEC_ID_PCM_S64BE:
458  case AV_CODEC_ID_PCM_F64BE:
459  DECODE(64, be64, src, samples, n, 0, 0)
460  break;
461  case AV_CODEC_ID_PCM_F32BE:
462  case AV_CODEC_ID_PCM_S32BE:
463  DECODE(32, be32, src, samples, n, 0, 0)
464  break;
465  case AV_CODEC_ID_PCM_S16BE:
466  DECODE(16, be16, src, samples, n, 0, 0)
467  break;
468  case AV_CODEC_ID_PCM_S16BE_PLANAR:
469  DECODE_PLANAR(16, be16, src, samples, n, 0, 0);
470  break;
471  case AV_CODEC_ID_PCM_F64LE:
472  case AV_CODEC_ID_PCM_F32LE:
473  case AV_CODEC_ID_PCM_F24LE:
474  case AV_CODEC_ID_PCM_F16LE:
475  case AV_CODEC_ID_PCM_S64LE:
476  case AV_CODEC_ID_PCM_S32LE:
477  case AV_CODEC_ID_PCM_S16LE:
478 #endif /* HAVE_BIGENDIAN */
479  case AV_CODEC_ID_PCM_U8:
480  memcpy(samples, src, n * sample_size);
481  break;
482 #if HAVE_BIGENDIAN
483  case AV_CODEC_ID_PCM_S16BE_PLANAR:
484 #else
485  case AV_CODEC_ID_PCM_S16LE_PLANAR:
486  case AV_CODEC_ID_PCM_S32LE_PLANAR:
487 #endif /* HAVE_BIGENDIAN */
488  n /= avctx->channels;
489  for (c = 0; c < avctx->channels; c++) {
490  samples = frame->extended_data[c];
491  bytestream_get_buffer(&src, samples, n * sample_size);
492  }
493  break;
494  case AV_CODEC_ID_PCM_ALAW:
495  case AV_CODEC_ID_PCM_MULAW:
496  case AV_CODEC_ID_PCM_VIDC:
497  for (; n > 0; n--) {
498  AV_WN16A(samples, s->table[*src++]);
499  samples += 2;
500  }
501  break;
502  case AV_CODEC_ID_PCM_LXF:
503  {
504  int i;
505  n /= avctx->channels;
506  for (c = 0; c < avctx->channels; c++) {
507  dst_int32_t = (int32_t *)frame->extended_data[c];
508  for (i = 0; i < n; i++) {
509  // extract low 20 bits and expand to 32 bits
510  *dst_int32_t++ = ((uint32_t)src[2]<<28) |
511  (src[1] << 20) |
512  (src[0] << 12) |
513  ((src[2] & 0x0F) << 8) |
514  src[1];
515  // extract high 20 bits and expand to 32 bits
516  *dst_int32_t++ = ((uint32_t)src[4]<<24) |
517  (src[3] << 16) |
518  ((src[2] & 0xF0) << 8) |
519  (src[4] << 4) |
520  (src[3] >> 4);
521  src += 5;
522  }
523  }
524  break;
525  }
526  default:
527  return -1;
528  }
529 
530  if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
531  avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
532  s->fdsp->vector_fmul_scalar((float *)frame->extended_data[0],
533  (const float *)frame->extended_data[0],
534  s->scale, FFALIGN(frame->nb_samples * avctx->channels, 4));
535  emms_c();
536  }
537 
538  *got_frame_ptr = 1;
539 
540  return buf_size;
541 }
542 
543 #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
544 #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_) \
545 AVCodec ff_ ## name_ ## _encoder = { \
546  .name = #name_, \
547  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
548  .type = AVMEDIA_TYPE_AUDIO, \
549  .id = AV_CODEC_ID_ ## id_, \
550  .init = pcm_encode_init, \
551  .encode2 = pcm_encode_frame, \
552  .capabilities = AV_CODEC_CAP_VARIABLE_FRAME_SIZE, \
553  .sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_, \
554  AV_SAMPLE_FMT_NONE }, \
555 }
556 
557 #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name) \
558  PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)
559 #define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name) \
560  PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)
561 #define PCM_ENCODER(id, sample_fmt, name, long_name) \
562  PCM_ENCODER_3(CONFIG_ ## id ## _ENCODER, id, sample_fmt, name, long_name)
563 
564 #define PCM_DECODER_0(id, sample_fmt, name, long_name)
565 #define PCM_DECODER_1(id_, sample_fmt_, name_, long_name_) \
566 AVCodec ff_ ## name_ ## _decoder = { \
567  .name = #name_, \
568  .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
569  .type = AVMEDIA_TYPE_AUDIO, \
570  .id = AV_CODEC_ID_ ## id_, \
571  .priv_data_size = sizeof(PCMDecode), \
572  .init = pcm_decode_init, \
573  .close = pcm_decode_close, \
574  .decode = pcm_decode_frame, \
575  .capabilities = AV_CODEC_CAP_DR1, \
576  .sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_, \
577  AV_SAMPLE_FMT_NONE }, \
578 }
579 
580 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name) \
581  PCM_DECODER_ ## cf(id, sample_fmt, name, long_name)
582 #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name) \
583  PCM_DECODER_2(cf, id, sample_fmt, name, long_name)
584 #define PCM_DECODER(id, sample_fmt, name, long_name) \
585  PCM_DECODER_3(CONFIG_ ## id ## _DECODER, id, sample_fmt, name, long_name)
586 
587 #define PCM_CODEC(id, sample_fmt_, name, long_name_) \
588  PCM_ENCODER(id, sample_fmt_, name, long_name_); \
589  PCM_DECODER(id, sample_fmt_, name, long_name_)
590 
591 /* Note: Do not forget to add new entries to the Makefile as well. */
592 PCM_CODEC (PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law / G.711 A-law");
593 PCM_DECODER(PCM_F16LE, AV_SAMPLE_FMT_FLT, pcm_f16le, "PCM 16.8 floating point little-endian");
594 PCM_DECODER(PCM_F24LE, AV_SAMPLE_FMT_FLT, pcm_f24le, "PCM 24.0 floating point little-endian");
595 PCM_CODEC (PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
596 PCM_CODEC (PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
597 PCM_CODEC (PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
598 PCM_CODEC (PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
599 PCM_DECODER(PCM_LXF, AV_SAMPLE_FMT_S32P,pcm_lxf, "PCM signed 20-bit little-endian planar");
600 PCM_CODEC (PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law / G.711 mu-law");
601 PCM_CODEC (PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");
602 PCM_CODEC (PCM_S8_PLANAR, AV_SAMPLE_FMT_U8P, pcm_s8_planar, "PCM signed 8-bit planar");
603 PCM_CODEC (PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
604 PCM_CODEC (PCM_S16BE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16be_planar, "PCM signed 16-bit big-endian planar");
605 PCM_CODEC (PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
606 PCM_CODEC (PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16le_planar, "PCM signed 16-bit little-endian planar");
607 PCM_CODEC (PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
608 PCM_CODEC (PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
609 PCM_CODEC (PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
610 PCM_CODEC (PCM_S24LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s24le_planar, "PCM signed 24-bit little-endian planar");
611 PCM_CODEC (PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
612 PCM_CODEC (PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
613 PCM_CODEC (PCM_S32LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s32le_planar, "PCM signed 32-bit little-endian planar");
614 PCM_CODEC (PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");
615 PCM_CODEC (PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
616 PCM_CODEC (PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
617 PCM_CODEC (PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
618 PCM_CODEC (PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
619 PCM_CODEC (PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
620 PCM_CODEC (PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
621 PCM_CODEC (PCM_S64BE, AV_SAMPLE_FMT_S64, pcm_s64be, "PCM signed 64-bit big-endian");
622 PCM_CODEC (PCM_S64LE, AV_SAMPLE_FMT_S64, pcm_s64le, "PCM signed 64-bit little-endian");
623 PCM_CODEC (PCM_VIDC, AV_SAMPLE_FMT_S16, pcm_vidc, "PCM Archimedes VIDC");
AV_CODEC_ID_PCM_S24BE
Definition: avcodec.h:482
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:1630
vidc2linear
static av_cold int vidc2linear(unsigned char u_val)
Definition: pcm_tablegen.h:78
AV_CODEC_ID_PCM_S24DAUD
Definition: avcodec.h:485
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AV_CODEC_ID_PCM_S8
Definition: avcodec.h:473
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
AV_CODEC_ID_PCM_U16LE
Definition: avcodec.h:471
pcm_alaw_tableinit
static void pcm_alaw_tableinit(void)
Definition: pcm_tablegen.h:127
AV_CODEC_ID_PCM_S32LE_PLANAR
Definition: avcodec.h:498
ret
ret
Definition: filter_design.txt:187
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1671
pcm_ulaw_tableinit
static void pcm_ulaw_tableinit(void)
Definition: pcm_tablegen.h:132
ff_reverse
const uint8_t ff_reverse[256]
Definition: reverse.c:23
DECODE_PLANAR
#define DECODE_PLANAR(size, endian, src, dst, n, shift, offset)
Definition: pcm.c:313
ulaw2linear
static av_cold int ulaw2linear(unsigned char u_val)
Definition: pcm_tablegen.h:61
pcm_encode_frame
static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: pcm.c:87
AVPacket::size
int size
Definition: avcodec.h:1534
float_dsp.h
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2852
AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
src
#define src
Definition: vp8dsp.c:254
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:2318
AV_CODEC_ID_PCM_S24LE_PLANAR
Definition: avcodec.h:497
attributes.h
Macro definitions for various function/variable attributes.
le32
uint64_t_TMPL AV_WL64 unsigned int_TMPL le32
Definition: bytestream.h:87
PCMDecode
Definition: pcm.c:236
ff_alloc_packet2
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
PCMDecode::table
short table[256]
Definition: pcm.c:237
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2289
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
AV_SAMPLE_FMT_U8
AV_SAMPLE_FMT_U8
Definition: audio_convert.c:194
AV_CODEC_ID_PCM_S8_PLANAR
Definition: avcodec.h:496
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
AV_CODEC_ID_PCM_VIDC
Definition: avcodec.h:505
AV_CODEC_ID_PCM_S64LE
Definition: avcodec.h:501
AV_CODEC_ID_PCM_U24LE
Definition: avcodec.h:483
pcm_decode_close
static av_cold int pcm_decode_close(AVCodecContext *avctx)
Definition: pcm.c:287
AVPacket::data
uint8_t * data
Definition: avcodec.h:1533
linear_to_ulaw
static uint8_t linear_to_ulaw[16384]
Definition: pcm_tablegen.h:100
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2845
AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
be24
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
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: avcodec.h:487
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
pcm_decode_frame
static int pcm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: pcm.c:325
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3569
PCM_CODEC
#define PCM_CODEC(id, sample_fmt_, name, long_name_)
Definition: pcm.c:587
AV_CODEC_ID_PCM_ALAW
Definition: avcodec.h:476
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1539
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
DECODE
#define DECODE(size, endian, src, dst, n, shift, offset)
Read PCM samples macro.
Definition: pcm.c:306
be64
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
ENCODE_PLANAR
#define ENCODE_PLANAR(type, endian, dst, n, shift, offset)
Definition: pcm.c:76
be16
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
pcm_vidc_tableinit
static void pcm_vidc_tableinit(void)
Definition: pcm_tablegen.h:137
ENCODE
#define ENCODE(type, endian, src, dst, n, shift, offset)
Write PCM samples macro.
Definition: pcm.c:69
le24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL le24
Definition: bytestream.h:87
pcm_encode_init
static av_cold int pcm_encode_init(AVCodecContext *avctx)
Definition: pcm.c:35
AV_CODEC_ID_PCM_U24BE
Definition: avcodec.h:484
alaw2linear
static av_cold int alaw2linear(unsigned char a_val)
Definition: pcm_tablegen.h:46
AV_SAMPLE_FMT_S32P
signed 32 bits, planar
Definition: samplefmt.h:68
le64
uint64_t_TMPL le64
Definition: bytestream.h:87
AV_SAMPLE_FMT_S64
signed 64 bits
Definition: samplefmt.h:71
AV_CODEC_ID_PCM_S64BE
Definition: avcodec.h:502
int32_t
int32_t
Definition: audio_convert.c:194
AV_CODEC_ID_PCM_U16BE
Definition: avcodec.h:472
PCMDecode::scale
float scale
Definition: pcm.c:239
AV_CODEC_ID_PCM_F64BE
Definition: avcodec.h:491
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:255
s
#define s(width, name)
Definition: cbs_vp9.c:257
n
int n
Definition: avisynth_c.h:760
AV_SAMPLE_FMT_DBL
double
Definition: samplefmt.h:64
AV_SAMPLE_FMT_U8P
unsigned 8 bits, planar
Definition: samplefmt.h:66
AV_WN16A
#define AV_WN16A(p, v)
Definition: intreadwrite.h:534
bytestream_get_buffer
static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)
Definition: bytestream.h:359
pcm_tablegen.h
AV_CODEC_ID_PCM_S16BE
Definition: avcodec.h:470
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_ID_PCM_U8
Definition: avcodec.h:474
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2301
avcodec.h
Libavcodec external API header.
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1631
byte
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
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:2281
AVCodecContext
main external API structure.
Definition: avcodec.h:1621
AV_CODEC_ID_PCM_MULAW
Definition: avcodec.h:475
AV_CODEC_ID_PCM_U32LE
Definition: avcodec.h:479
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1969
AV_CODEC_ID_PCM_F32BE
Definition: avcodec.h:489
be32
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
AV_CODEC_ID_PCM_LXF
Definition: avcodec.h:494
le16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL le16
Definition: bytestream.h:87
AVFloatDSPContext::vector_fmul_scalar
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
pcm_decode_init
static av_cold int pcm_decode_init(AVCodecContext *avctx)
Definition: pcm.c:242
AV_CODEC_ID_PCM_S24LE
Definition: avcodec.h:481
PCM_DECODER
#define PCM_DECODER(id, sample_fmt, name, long_name)
Definition: pcm.c:584
AV_CODEC_ID_PCM_F64LE
Definition: avcodec.h:492
AV_CODEC_ID_PCM_F24LE
Definition: avcodec.h:504
AV_CODEC_ID_PCM_F16LE
Definition: avcodec.h:503
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
AV_CODEC_ID_PCM_F32LE
Definition: avcodec.h:490
internal.h
common internal api header.
AV_CODEC_ID_PCM_U32BE
Definition: avcodec.h:480
AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AV_CODEC_ID_PCM_S16LE
Definition: avcodec.h:469
linear_to_vidc
static uint8_t linear_to_vidc[16384]
Definition: pcm_tablegen.h:101
linear_to_alaw
static uint8_t linear_to_alaw[16384]
Definition: pcm_tablegen.h:99
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1648
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:2282
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:2
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_SAMPLE_FMT_S16P
signed 16 bits, planar
Definition: samplefmt.h:67
AV_CODEC_ID_PCM_S32LE
Definition: avcodec.h:477
PCMDecode::fdsp
AVFloatDSPContext * fdsp
Definition: pcm.c:238
AVCodec::sample_fmts
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:3578
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
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1510
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: avcodec.h:499
AV_CODEC_ID_PCM_S32BE
Definition: avcodec.h:478
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
Generated on Mon Mar 30 2020 19:21:26 for FFmpeg by   doxygen 1.8.11