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