FFmpeg
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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/mem.h"
32 #include "libavutil/reverse.h"
33 #include "libavutil/thread.h"
34 #include "avcodec.h"
35 #include "bytestream.h"
36 #include "codec_internal.h"
37 #include "decode.h"
38 #include "encode.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  int sample_size;
247 } PCMDecode;
248 
249 static av_cold av_unused int pcm_decode_init(AVCodecContext *avctx)
250 {
251  PCMDecode *s = avctx->priv_data;
252  static const struct {
253  enum AVCodecID codec_id;
254  int8_t sample_fmt;
255  uint8_t sample_size;
256  uint8_t bits_per_sample;
257  } codec_id_to_samplefmt[] = {
258  #define ENTRY(CODEC_ID, SAMPLE_FMT, BITS_PER_SAMPLE) \
259  { AV_CODEC_ID_PCM_ ## CODEC_ID, AV_SAMPLE_FMT_ ## SAMPLE_FMT, \
260  BITS_PER_SAMPLE / 8, BITS_PER_SAMPLE }
261  ENTRY(S8, U8, 8), ENTRY(S8_PLANAR, U8P, 8),
262  ENTRY(S16BE, S16, 16), ENTRY(S16BE_PLANAR, S16P, 16),
263  ENTRY(S16LE, S16, 16), ENTRY(S16LE_PLANAR, S16P, 16),
264  ENTRY(S24DAUD, S16, 24), ENTRY(S24BE, S32, 24),
265  ENTRY(S24LE, S32, 24), ENTRY(S24LE_PLANAR, S32P, 24),
266  ENTRY(S32BE, S32, 32), ENTRY(S32LE, S32, 32),
267  ENTRY(S32LE_PLANAR, S32P, 32),
268  ENTRY(S64BE, S64, 64), ENTRY(S64LE, S64, 64),
269  ENTRY(SGA, U8, 8), ENTRY(U8, U8, 8),
270  ENTRY(U16BE, S16, 16), ENTRY(U16LE, S16, 16),
271  ENTRY(U24BE, S32, 24), ENTRY(U24LE, S32, 24),
272  ENTRY(U32BE, S32, 32), ENTRY(U32LE, S32, 32),
273  ENTRY(F32BE, FLT, 32), ENTRY(F32LE, FLT, 32),
274  ENTRY(F64BE, DBL, 64), ENTRY(F64LE, DBL, 64),
275  { .codec_id = AV_CODEC_ID_PCM_LXF, .sample_fmt = AV_SAMPLE_FMT_S32P, .sample_size = 5 },
276  };
277 
278  for (unsigned i = 0; i < FF_ARRAY_ELEMS(codec_id_to_samplefmt); ++i) {
279  if (codec_id_to_samplefmt[i].codec_id == avctx->codec_id) {
280  s->sample_size = codec_id_to_samplefmt[i].sample_size;
281  avctx->sample_fmt = codec_id_to_samplefmt[i].sample_fmt;
282  if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
283  avctx->bits_per_raw_sample = codec_id_to_samplefmt[i].bits_per_sample;
284  break;
285  }
286  av_assert1(i + 1 < FF_ARRAY_ELEMS(codec_id_to_samplefmt));
287  }
288 
289  return 0;
290 }
291 
292 typedef struct PCMScaleDecode {
293  PCMDecode base;
294  void (*vector_fmul_scalar)(float *dst, const float *src, float mul,
295  int len);
296  float scale;
297 } PCMScaleDecode;
298 
299 static av_cold av_unused int pcm_scale_decode_init(AVCodecContext *avctx)
300 {
301  PCMScaleDecode *s = avctx->priv_data;
302  AVFloatDSPContext *fdsp;
303 
304  avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
305  s->base.sample_size = 4;
306 
307  if (avctx->bits_per_coded_sample < 1 || avctx->bits_per_coded_sample > 24)
308  return AVERROR_INVALIDDATA;
309 
310  s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));
311  fdsp = avpriv_float_dsp_alloc(0);
312  if (!fdsp)
313  return AVERROR(ENOMEM);
314  s->vector_fmul_scalar = fdsp->vector_fmul_scalar;
315  av_free(fdsp);
316 
317  return 0;
318 }
319 
320 typedef struct PCMLUTDecode {
321  PCMDecode base;
322  int16_t table[256];
323 } PCMLUTDecode;
324 
325 static av_cold av_unused int pcm_lut_decode_init(AVCodecContext *avctx)
326 {
327  PCMLUTDecode *s = avctx->priv_data;
328 
329  switch (avctx->codec_id) {
330  default:
331  av_unreachable("pcm_lut_decode_init() only used with alaw, mulaw and vidc");
332  case AV_CODEC_ID_PCM_ALAW:
333  for (int i = 0; i < 256; i++)
334  s->table[i] = alaw2linear(i);
335  break;
336  case AV_CODEC_ID_PCM_MULAW:
337  for (int i = 0; i < 256; i++)
338  s->table[i] = ulaw2linear(i);
339  break;
340  case AV_CODEC_ID_PCM_VIDC:
341  for (int i = 0; i < 256; i++)
342  s->table[i] = vidc2linear(i);
343  break;
344  }
345 
346  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
347  s->base.sample_size = 1;
348 
349  return 0;
350 }
351 
352 /**
353  * Read PCM samples macro
354  * @param size Data size of native machine format
355  * @param endian bytestream_get_xxx() endian suffix
356  * @param src Source pointer (variable name)
357  * @param dst Destination pointer (variable name)
358  * @param n Total number of samples (variable name)
359  * @param shift Bitshift (bits)
360  * @param offset Sample value offset
361  */
362 #define DECODE(size, endian, src, dst, n, shift, offset) \
363  for (; n > 0; n--) { \
364  uint ## size ## _t v = bytestream_get_ ## endian(&src); \
365  AV_WN ## size ## A(dst, (uint ## size ## _t)(v - offset) << shift); \
366  dst += size / 8; \
367  }
368 
369 #define DECODE_PLANAR(size, endian, src, dst, n, shift, offset) \
370  n /= channels; \
371  for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \
372  int i; \
373  dst = frame->extended_data[c]; \
374  for (i = n; i > 0; i--) { \
375  uint ## size ## _t v = bytestream_get_ ## endian(&src); \
376  AV_WN ## size ## A(dst, (uint ## size ##_t)(v - offset) << shift); \
377  dst += size / 8; \
378  } \
379  }
380 
381 static int pcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
382  int *got_frame_ptr, AVPacket *avpkt)
383 {
384  const uint8_t *src = avpkt->data;
385  int buf_size = avpkt->size;
386  PCMDecode *s = avctx->priv_data;
387  int channels = avctx->ch_layout.nb_channels;
388  int sample_size = s->sample_size;
389  int c, n, ret, samples_per_block;
390  uint8_t *samples;
391  int32_t *dst_int32_t;
392 
393  samples_per_block = 1;
394  if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {
395  /* we process 40-bit blocks per channel for LXF */
396  samples_per_block = 2;
397  }
398 
399  if (channels == 0) {
400  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
401  return AVERROR(EINVAL);
402  }
403 
404  if (avctx->codec_id != avctx->codec->id) {
405  av_log(avctx, AV_LOG_ERROR, "codec ids mismatch\n");
406  return AVERROR(EINVAL);
407  }
408 
409  n = channels * sample_size;
410 
411  if (n && buf_size % n) {
412  if (buf_size < n) {
413  av_log(avctx, AV_LOG_ERROR,
414  "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",
415  buf_size, n);
416  return AVERROR_INVALIDDATA;
417  } else
418  buf_size -= buf_size % n;
419  }
420 
421  n = buf_size / sample_size;
422 
423  /* get output buffer */
424  frame->nb_samples = n * samples_per_block / channels;
425  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
426  return ret;
427  samples = frame->data[0];
428 
429  switch (avctx->codec_id) {
430  case AV_CODEC_ID_PCM_U32LE:
431  DECODE(32, le32, src, samples, n, 0, 0x80000000)
432  break;
433  case AV_CODEC_ID_PCM_U32BE:
434  DECODE(32, be32, src, samples, n, 0, 0x80000000)
435  break;
436  case AV_CODEC_ID_PCM_S24LE:
437  DECODE(32, le24, src, samples, n, 8, 0)
438  break;
439  case AV_CODEC_ID_PCM_S24LE_PLANAR:
440  DECODE_PLANAR(32, le24, src, samples, n, 8, 0);
441  break;
442  case AV_CODEC_ID_PCM_S24BE:
443  DECODE(32, be24, src, samples, n, 8, 0)
444  break;
445  case AV_CODEC_ID_PCM_U24LE:
446  DECODE(32, le24, src, samples, n, 8, 0x800000)
447  break;
448  case AV_CODEC_ID_PCM_U24BE:
449  DECODE(32, be24, src, samples, n, 8, 0x800000)
450  break;
451  case AV_CODEC_ID_PCM_S24DAUD:
452  for (; n > 0; n--) {
453  uint32_t v = bytestream_get_be24(&src);
454  v >>= 4; // sync flags are here
455  AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
456  (ff_reverse[v & 0xff] << 8));
457  samples += 2;
458  }
459  break;
460  case AV_CODEC_ID_PCM_U16LE:
461  DECODE(16, le16, src, samples, n, 0, 0x8000)
462  break;
463  case AV_CODEC_ID_PCM_U16BE:
464  DECODE(16, be16, src, samples, n, 0, 0x8000)
465  break;
466  case AV_CODEC_ID_PCM_S8:
467  for (; n > 0; n--)
468  *samples++ = *src++ + 128;
469  break;
470  case AV_CODEC_ID_PCM_SGA:
471  for (; n > 0; n--) {
472  int sign = *src >> 7;
473  int magn = *src & 0x7f;
474  *samples++ = sign ? 128 - magn : 128 + magn;
475  src++;
476  }
477  break;
478  case AV_CODEC_ID_PCM_S8_PLANAR:
479  n /= avctx->ch_layout.nb_channels;
480  for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
481  int i;
482  samples = frame->extended_data[c];
483  for (i = n; i > 0; i--)
484  *samples++ = *src++ + 128;
485  }
486  break;
487 #if HAVE_BIGENDIAN
488  case AV_CODEC_ID_PCM_S64LE:
489  case AV_CODEC_ID_PCM_F64LE:
490  DECODE(64, le64, src, samples, n, 0, 0)
491  break;
492  case AV_CODEC_ID_PCM_S32LE:
493  case AV_CODEC_ID_PCM_F32LE:
494  case AV_CODEC_ID_PCM_F24LE:
495  case AV_CODEC_ID_PCM_F16LE:
496  DECODE(32, le32, src, samples, n, 0, 0)
497  break;
498  case AV_CODEC_ID_PCM_S32LE_PLANAR:
499  DECODE_PLANAR(32, le32, src, samples, n, 0, 0);
500  break;
501  case AV_CODEC_ID_PCM_S16LE:
502  DECODE(16, le16, src, samples, n, 0, 0)
503  break;
504  case AV_CODEC_ID_PCM_S16LE_PLANAR:
505  DECODE_PLANAR(16, le16, src, samples, n, 0, 0);
506  break;
507  case AV_CODEC_ID_PCM_F64BE:
508  case AV_CODEC_ID_PCM_F32BE:
509  case AV_CODEC_ID_PCM_S64BE:
510  case AV_CODEC_ID_PCM_S32BE:
511  case AV_CODEC_ID_PCM_S16BE:
512 #else
513  case AV_CODEC_ID_PCM_S64BE:
514  case AV_CODEC_ID_PCM_F64BE:
515  DECODE(64, be64, src, samples, n, 0, 0)
516  break;
517  case AV_CODEC_ID_PCM_F32BE:
518  case AV_CODEC_ID_PCM_S32BE:
519  DECODE(32, be32, src, samples, n, 0, 0)
520  break;
521  case AV_CODEC_ID_PCM_S16BE:
522  DECODE(16, be16, src, samples, n, 0, 0)
523  break;
524  case AV_CODEC_ID_PCM_S16BE_PLANAR:
525  DECODE_PLANAR(16, be16, src, samples, n, 0, 0);
526  break;
527  case AV_CODEC_ID_PCM_F64LE:
528  case AV_CODEC_ID_PCM_F32LE:
529  case AV_CODEC_ID_PCM_F24LE:
530  case AV_CODEC_ID_PCM_F16LE:
531  case AV_CODEC_ID_PCM_S64LE:
532  case AV_CODEC_ID_PCM_S32LE:
533  case AV_CODEC_ID_PCM_S16LE:
534 #endif /* HAVE_BIGENDIAN */
535  case AV_CODEC_ID_PCM_U8:
536  memcpy(samples, src, n * sample_size);
537  break;
538 #if HAVE_BIGENDIAN
539  case AV_CODEC_ID_PCM_S16BE_PLANAR:
540 #else
541  case AV_CODEC_ID_PCM_S16LE_PLANAR:
542  case AV_CODEC_ID_PCM_S32LE_PLANAR:
543 #endif /* HAVE_BIGENDIAN */
544  n /= avctx->ch_layout.nb_channels;
545  for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
546  samples = frame->extended_data[c];
547  bytestream_get_buffer(&src, samples, n * sample_size);
548  }
549  break;
550  case AV_CODEC_ID_PCM_ALAW:
551  case AV_CODEC_ID_PCM_MULAW:
552  case AV_CODEC_ID_PCM_VIDC: {
553  const int16_t *const lut = ((PCMLUTDecode*)avctx->priv_data)->table;
554  int16_t *restrict samples_16 = (int16_t*)samples;
555 
556  for (; n > 0; n--)
557  *samples_16++ = lut[*src++];
558  break;
559  }
560  case AV_CODEC_ID_PCM_LXF:
561  {
562  int i;
563  n /= channels;
564  for (c = 0; c < channels; c++) {
565  dst_int32_t = (int32_t *)frame->extended_data[c];
566  for (i = 0; i < n; i++) {
567  // extract low 20 bits and expand to 32 bits
568  *dst_int32_t++ = ((uint32_t)src[2]<<28) |
569  (src[1] << 20) |
570  (src[0] << 12) |
571  ((src[2] & 0x0F) << 8) |
572  src[1];
573  // extract high 20 bits and expand to 32 bits
574  *dst_int32_t++ = ((uint32_t)src[4]<<24) |
575  (src[3] << 16) |
576  ((src[2] & 0xF0) << 8) |
577  (src[4] << 4) |
578  (src[3] >> 4);
579  src += 5;
580  }
581  }
582  break;
583  }
584  default:
585  return -1;
586  }
587 
588  if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
589  avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
590  PCMScaleDecode *s2 = avctx->priv_data;
591  s2->vector_fmul_scalar((float *)frame->extended_data[0],
592  (const float *)frame->extended_data[0],
593  s2->scale, FFALIGN(frame->nb_samples * avctx->ch_layout.nb_channels, 4));
594  }
595 
596  *got_frame_ptr = 1;
597 
598  return buf_size;
599 }
600 
601 #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
602 #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_) \
603 const FFCodec ff_ ## name_ ## _encoder = { \
604  .p.name = #name_, \
605  CODEC_LONG_NAME(long_name_), \
606  .p.type = AVMEDIA_TYPE_AUDIO, \
607  .p.id = id_, \
608  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | \
609  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, \
610  .init = pcm_encode_init, \
611  FF_CODEC_ENCODE_CB(pcm_encode_frame), \
612  CODEC_SAMPLEFMTS(sample_fmt_), \
613 }
614 
615 #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name) \
616  PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)
617 #define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name) \
618  PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)
619 #define PCM_ENCODER(id, sample_fmt, name, long_name) \
620  PCM_ENCODER_3(CONFIG_PCM_ ## id ## _ENCODER, AV_CODEC_ID_PCM_ ## id, \
621  AV_SAMPLE_FMT_ ## sample_fmt, pcm_ ## name, long_name)
622 
623 #define PCM_DECODER_0(id, sample_fmt, name, long_name, Context, init_func)
624 #define PCM_DECODER_1(id_, sample_fmt, name_, long_name, Context, init_func)\
625 const FFCodec ff_ ## name_ ## _decoder = { \
626  .p.name = #name_, \
627  CODEC_LONG_NAME(long_name), \
628  .p.type = AVMEDIA_TYPE_AUDIO, \
629  .p.id = id_, \
630  .priv_data_size = sizeof(Context), \
631  .init = init_func, \
632  FF_CODEC_DECODE_CB(pcm_decode_frame), \
633  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_PARAM_CHANGE, \
634 }
635 
636 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name, Context, init_func) \
637  PCM_DECODER_ ## cf(id, sample_fmt, name, long_name, Context, init_func)
638 #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name, Context, init_func) \
639  PCM_DECODER_2(cf, id, sample_fmt, name, long_name, Context, init_func)
640 #define PCM_DEC_EXT(id, sample_fmt, name, long_name, Context, init_func) \
641  PCM_DECODER_3(CONFIG_PCM_ ## id ## _DECODER, AV_CODEC_ID_PCM_ ## id, \
642  AV_SAMPLE_FMT_ ## sample_fmt, pcm_ ## name, long_name, \
643  Context, init_func)
644 
645 #define PCM_DECODER(id, sample_fmt, name, long_name) \
646  PCM_DEC_EXT(id, sample_fmt, name, long_name, PCMDecode, pcm_decode_init)
647 
648 #define PCM_CODEC(id, sample_fmt_, name, long_name_) \
649  PCM_ENCODER(id, sample_fmt_, name, long_name_); \
650  PCM_DECODER(id, sample_fmt_, name, long_name_)
651 
652 #define PCM_CODEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func) \
653  PCM_DEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func); \
654  PCM_ENCODER(id, sample_fmt, name, long_name)
655 
656 /* Note: Do not forget to add new entries to the Makefile and
657  * to the table in pcm_decode_init() as well. */
658 // AV_CODEC_ID_* pcm_* name
659 // AV_SAMPLE_FMT_* long name DecodeContext decode init func
660 PCM_CODEC_EXT(ALAW, S16, alaw, "PCM A-law / G.711 A-law", PCMLUTDecode, pcm_lut_decode_init);
661 PCM_DEC_EXT (F16LE, FLT, f16le, "PCM 16.8 floating point little-endian", PCMScaleDecode, pcm_scale_decode_init);
662 PCM_DEC_EXT (F24LE, FLT, f24le, "PCM 24.0 floating point little-endian", PCMScaleDecode, pcm_scale_decode_init);
663 PCM_CODEC (F32BE, FLT, f32be, "PCM 32-bit floating point big-endian");
664 PCM_CODEC (F32LE, FLT, f32le, "PCM 32-bit floating point little-endian");
665 PCM_CODEC (F64BE, DBL, f64be, "PCM 64-bit floating point big-endian");
666 PCM_CODEC (F64LE, DBL, f64le, "PCM 64-bit floating point little-endian");
667 PCM_DECODER (LXF, S32P,lxf, "PCM signed 20-bit little-endian planar");
668 PCM_CODEC_EXT(MULAW, S16, mulaw, "PCM mu-law / G.711 mu-law", PCMLUTDecode, pcm_lut_decode_init);
669 PCM_CODEC (S8, U8, s8, "PCM signed 8-bit");
670 PCM_CODEC (S8_PLANAR, U8P, s8_planar, "PCM signed 8-bit planar");
671 PCM_CODEC (S16BE, S16, s16be, "PCM signed 16-bit big-endian");
672 PCM_CODEC (S16BE_PLANAR, S16P,s16be_planar, "PCM signed 16-bit big-endian planar");
673 PCM_CODEC (S16LE, S16, s16le, "PCM signed 16-bit little-endian");
674 PCM_CODEC (S16LE_PLANAR, S16P,s16le_planar, "PCM signed 16-bit little-endian planar");
675 PCM_CODEC (S24BE, S32, s24be, "PCM signed 24-bit big-endian");
676 PCM_CODEC (S24DAUD, S16, s24daud, "PCM D-Cinema audio signed 24-bit");
677 PCM_CODEC (S24LE, S32, s24le, "PCM signed 24-bit little-endian");
678 PCM_CODEC (S24LE_PLANAR, S32P,s24le_planar, "PCM signed 24-bit little-endian planar");
679 PCM_CODEC (S32BE, S32, s32be, "PCM signed 32-bit big-endian");
680 PCM_CODEC (S32LE, S32, s32le, "PCM signed 32-bit little-endian");
681 PCM_CODEC (S32LE_PLANAR, S32P,s32le_planar, "PCM signed 32-bit little-endian planar");
682 PCM_CODEC (U8, U8, u8, "PCM unsigned 8-bit");
683 PCM_CODEC (U16BE, S16, u16be, "PCM unsigned 16-bit big-endian");
684 PCM_CODEC (U16LE, S16, u16le, "PCM unsigned 16-bit little-endian");
685 PCM_CODEC (U24BE, S32, u24be, "PCM unsigned 24-bit big-endian");
686 PCM_CODEC (U24LE, S32, u24le, "PCM unsigned 24-bit little-endian");
687 PCM_CODEC (U32BE, S32, u32be, "PCM unsigned 32-bit big-endian");
688 PCM_CODEC (U32LE, S32, u32le, "PCM unsigned 32-bit little-endian");
689 PCM_CODEC (S64BE, S64, s64be, "PCM signed 64-bit big-endian");
690 PCM_CODEC (S64LE, S64, s64le, "PCM signed 64-bit little-endian");
691 PCM_CODEC_EXT(VIDC, S16, vidc, "PCM Archimedes VIDC", PCMLUTDecode, pcm_lut_decode_init);
692 PCM_DECODER (SGA, U8, sga, "PCM SGA");
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:336
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1051
PCM_CODEC_EXT
#define PCM_CODEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func)
Definition: pcm.c:652
PCM_CODEC
#define PCM_CODEC(id, sample_fmt_, name, long_name_)
Definition: pcm.c:648
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:356
le32
uint64_t_TMPL AV_WL64 unsigned int_TMPL le32
Definition: bytestream.h:92
pcm_decode_init
static av_cold av_unused int pcm_decode_init(AVCodecContext *avctx)
Definition: pcm.c:249
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:1024
thread.h
vidc2linear
static av_cold int vidc2linear(unsigned char u_val)
Definition: pcm_tablegen.h:78
int64_t
long long int64_t
Definition: coverity.c:34
av_unused
#define av_unused
Definition: attributes.h:131
AV_CODEC_ID_PCM_S32LE_PLANAR
@ AV_CODEC_ID_PCM_S32LE_PLANAR
Definition: codec_id.h:365
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
AVPacket::data
uint8_t * data
Definition: packet.h:535
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:366
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:350
AV_CODEC_ID_PCM_SGA
@ AV_CODEC_ID_PCM_SGA
Definition: codec_id.h:372
reverse.h
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:354
AV_CODEC_ID_PCM_S64LE
@ AV_CODEC_ID_PCM_S64LE
Definition: codec_id.h:367
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:337
PCMScaleDecode::base
PCMDecode base
Definition: pcm.c:293
PCMScaleDecode::scale
float scale
Definition: pcm.c:296
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1039
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
PCMLUTDecode
Definition: pcm.c:320
PCMScaleDecode::vector_fmul_scalar
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Definition: pcm.c:294
PCM_DECODER
#define PCM_DECODER(id, sample_fmt, name, long_name)
Definition: pcm.c:645
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:547
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:340
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CODEC_ID_PCM_LXF
@ AV_CODEC_ID_PCM_LXF
Definition: codec_id.h:361
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:1553
AV_CODEC_ID_PCM_F24LE
@ AV_CODEC_ID_PCM_F24LE
Definition: codec_id.h:370
channels
channels
Definition: aptx.h:31
decode.h
AV_WN16A
#define AV_WN16A(p, v)
Definition: intreadwrite.h:530
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:342
AV_CODEC_ID_PCM_U16BE
@ AV_CODEC_ID_PCM_U16BE
Definition: codec_id.h:339
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:441
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:343
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
AV_CODEC_ID_PCM_U24BE
@ AV_CODEC_ID_PCM_U24BE
Definition: codec_id.h:351
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
ENTRY
#define ENTRY(CODEC_ID, SAMPLE_FMT, BITS_PER_SAMPLE)
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition: avassert.h:109
AV_CODEC_ID_PCM_U32BE
@ AV_CODEC_ID_PCM_U32BE
Definition: codec_id.h:347
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
AV_CODEC_ID_PCM_S64BE
@ AV_CODEC_ID_PCM_S64BE
Definition: codec_id.h:368
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
pcm_lut_decode_init
static av_cold av_unused int pcm_lut_decode_init(AVCodecContext *avctx)
Definition: pcm.c:325
DECODE_PLANAR
#define DECODE_PLANAR(size, endian, src, dst, n, shift, offset)
Definition: pcm.c:369
pcm_decode_frame
static int pcm_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: pcm.c:381
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
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:364
float_dsp.h
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AV_CODEC_ID_PCM_VIDC
@ AV_CODEC_ID_PCM_VIDC
Definition: codec_id.h:371
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:348
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1638
AVPacket::size
int size
Definition: packet.h:536
codec_internal.h
alaw2linear
static av_cold int alaw2linear(unsigned char a_val)
Definition: pcm_tablegen.h:46
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1031
AVFloatDSPContext
Definition: float_dsp.h:24
DECODE
#define DECODE(size, endian, src, dst, n, shift, offset)
Read PCM samples macro.
Definition: pcm.c:362
PCMLUTDecode::table
int16_t table[256]
Definition: pcm.c:322
ENCODE_PLANAR
#define ENCODE_PLANAR(type, endian, dst, n, shift, offset)
Definition: pcm.c:85
attributes.h
AVCodec::id
enum AVCodecID id
Definition: codec.h:186
PCMLUTDecode::base
PCMDecode base
Definition: pcm.c:321
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1546
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:256
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:358
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:345
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:369
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:1057
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
PCM_DEC_EXT
#define PCM_DEC_EXT(id, sample_fmt, name, long_name, Context, init_func)
Definition: pcm.c:640
linear_to_vidc
static uint8_t linear_to_vidc[16384]
Definition: pcm_tablegen.h:101
AVCodecContext
main external API structure.
Definition: avcodec.h:431
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:106
INIT_ONCE
#define INIT_ONCE(id, name)
AV_CODEC_ID_PCM_U32LE
@ AV_CODEC_ID_PCM_U32LE
Definition: codec_id.h:346
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:344
mem.h
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:341
AV_CODEC_ID_PCM_S24DAUD
@ AV_CODEC_ID_PCM_S24DAUD
Definition: codec_id.h:352
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:359
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AVPacket
This structure stores compressed data.
Definition: packet.h:512
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
PCMScaleDecode
Definition: pcm.c:292
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:363
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
AV_CODEC_ID_PCM_U16LE
@ AV_CODEC_ID_PCM_U16LE
Definition: codec_id.h:338
S8
static const uint32_t S8[256]
Definition: cast5.c:328
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:357
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
PCMDecode::sample_size
int sample_size
Definition: pcm.c:246
pcm_scale_decode_init
static av_cold av_unused int pcm_scale_decode_init(AVCodecContext *avctx)
Definition: pcm.c:299
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:349
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
src
#define src
Definition: vp8dsp.c:248
Generated on Thu Jun 5 2025 19:22:17 for FFmpeg by   doxygen 1.8.17