FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/pcm.c
Date: 2026-01-23 14:02:51
Exec Total Coverage
Lines: 217 283 76.7%
Functions: 5 6 83.3%
Branches: 151 186 81.2%
Line Branch Exec Source
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 1164 av_unused av_cold static int pcm_encode_init(AVCodecContext *avctx)
42 {
43 1164 avctx->frame_size = 0;
44 #if !CONFIG_HARDCODED_TABLES
45
3/4
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1155 times.
 1164 switch (avctx->codec->id) {
46 #if CONFIG_PCM_ALAW_ENCODER
47 7 case AV_CODEC_ID_PCM_ALAW: {
48 static AVOnce once_alaw = AV_ONCE_INIT;
49 7 ff_thread_once(&once_alaw, pcm_alaw_tableinit);
50 7 break;
51 }
52 #endif
53 #if CONFIG_PCM_MULAW_ENCODER
54 2 case AV_CODEC_ID_PCM_MULAW: {
55 static AVOnce once_mulaw = AV_ONCE_INIT;
56 2 ff_thread_once(&once_mulaw, pcm_ulaw_tableinit);
57 2 break;
58 }
59 #endif
60 #if CONFIG_PCM_VIDC_ENCODER
61 ✗ case AV_CODEC_ID_PCM_VIDC: {
62 static AVOnce once_vidc = AV_ONCE_INIT;
63 ✗ ff_thread_once(&once_vidc, pcm_vidc_tableinit);
64 ✗ break;
65 }
66 #endif
67 1155 default:
68 1155 break;
69 }
70 #endif
71
72 1164 avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
73 1164 avctx->block_align = avctx->ch_layout.nb_channels * avctx->bits_per_coded_sample / 8;
74 1164 avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate;
75
76 1164 return 0;
77 }
78
79 /**
80 * Write PCM samples macro
81 * @param type Datatype of native machine format
82 * @param endian bytestream_put_xxx() suffix
83 * @param src Source pointer (variable name)
84 * @param dst Destination pointer (variable name)
85 * @param n Total number of samples (variable name)
86 * @param shift Bitshift (bits)
87 * @param offset Sample value offset
88 */
89 #define ENCODE(type, endian, src, dst, n, shift, offset) \
90 samples_ ## type = (const type *) src; \
91 for (; n > 0; n--) { \
92 register type v = (*samples_ ## type++ >> shift) + offset; \
93 bytestream_put_ ## endian(&dst, v); \
94 }
95
96 #define ENCODE_PLANAR(type, endian, dst, n, shift, offset) \
97 n /= avctx->ch_layout.nb_channels; \
98 for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \
99 int i; \
100 samples_ ## type = (const type *) frame->extended_data[c]; \
101 for (i = n; i > 0; i--) { \
102 register type v = (*samples_ ## type++ >> shift) + offset; \
103 bytestream_put_ ## endian(&dst, v); \
104 } \
105 }
106
107 241208 av_unused static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
108 const AVFrame *frame, int *got_packet_ptr)
109 {
110 int n, c, sample_size, ret;
111 const short *samples;
112 unsigned char *dst;
113 const uint8_t *samples_uint8_t;
114 const int16_t *samples_int16_t;
115 const int32_t *samples_int32_t;
116 const int64_t *samples_int64_t;
117 const uint16_t *samples_uint16_t;
118 const uint32_t *samples_uint32_t;
119
120 241208 sample_size = av_get_bits_per_sample(avctx->codec->id) / 8;
121 241208 n = frame->nb_samples * avctx->ch_layout.nb_channels;
122 241208 samples = (const short *)frame->data[0];
123
124
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 241208 times.
 241208 if ((ret = ff_get_encode_buffer(avctx, avpkt, n * sample_size, 0)) < 0)
125 ✗ return ret;
126 241208 dst = avpkt->data;
127
128
20/22
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 5861 times.
✓ Branch 3 taken 65 times.
✓ Branch 4 taken 313 times.
✓ Branch 5 taken 65 times.
✓ Branch 6 taken 65 times.
✓ Branch 7 taken 20 times.
✓ Branch 8 taken 65 times.
✓ Branch 9 taken 65 times.
✓ Branch 10 taken 172 times.
✓ Branch 11 taken 65 times.
✓ Branch 12 taken 65 times.
✓ Branch 13 taken 174 times.
✓ Branch 14 taken 104 times.
✓ Branch 15 taken 83 times.
✓ Branch 16 taken 233559 times.
✓ Branch 17 taken 130 times.
✓ Branch 18 taken 131 times.
✓ Branch 19 taken 76 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 241208 switch (avctx->codec->id) {
129 65 case AV_CODEC_ID_PCM_U32LE:
130
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
131 65 break;
132 65 case AV_CODEC_ID_PCM_U32BE:
133
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
134 65 break;
135 5861 case AV_CODEC_ID_PCM_S24LE:
136
2/2
✓ Branch 1 taken 39500794 times.
✓ Branch 2 taken 5861 times.
 39506655 ENCODE(int32_t, le24, samples, dst, n, 8, 0)
137 5861 break;
138 65 case AV_CODEC_ID_PCM_S24LE_PLANAR:
139
4/4
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 130 times.
✓ Branch 3 taken 130 times.
✓ Branch 4 taken 65 times.
 529395 ENCODE_PLANAR(int32_t, le24, dst, n, 8, 0)
140 65 break;
141 313 case AV_CODEC_ID_PCM_S24BE:
142
2/2
✓ Branch 1 taken 8497686 times.
✓ Branch 2 taken 313 times.
 8497999 ENCODE(int32_t, be24, samples, dst, n, 8, 0)
143 313 break;
144 65 case AV_CODEC_ID_PCM_U24LE:
145
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
146 65 break;
147 65 case AV_CODEC_ID_PCM_U24BE:
148
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
149 65 break;
150 20 case AV_CODEC_ID_PCM_S24DAUD:
151
2/2
✓ Branch 0 taken 983040 times.
✓ Branch 1 taken 20 times.
 983060 for (; n > 0; n--) {
152 983040 uint32_t tmp = ff_reverse[(*samples >> 8) & 0xff] +
153 983040 (ff_reverse[*samples & 0xff] << 8);
154 983040 tmp <<= 4; // sync flags would go here
155 983040 bytestream_put_be24(&dst, tmp);
156 983040 samples++;
157 }
158 20 break;
159 65 case AV_CODEC_ID_PCM_U16LE:
160
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
161 65 break;
162 65 case AV_CODEC_ID_PCM_U16BE:
163
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
164 65 break;
165 172 case AV_CODEC_ID_PCM_S8:
166
2/2
✓ Branch 1 taken 7726268 times.
✓ Branch 2 taken 172 times.
 7726440 ENCODE(uint8_t, byte, samples, dst, n, 0, -128)
167 172 break;
168 65 case AV_CODEC_ID_PCM_S8_PLANAR:
169
4/4
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 130 times.
✓ Branch 3 taken 130 times.
✓ Branch 4 taken 65 times.
 529395 ENCODE_PLANAR(uint8_t, byte, dst, n, 0, -128)
170 65 break;
171 #if HAVE_BIGENDIAN
172 case AV_CODEC_ID_PCM_S64LE:
173 case AV_CODEC_ID_PCM_F64LE:
174 ENCODE(int64_t, le64, samples, dst, n, 0, 0)
175 break;
176 case AV_CODEC_ID_PCM_S32LE:
177 case AV_CODEC_ID_PCM_F32LE:
178 ENCODE(int32_t, le32, samples, dst, n, 0, 0)
179 break;
180 case AV_CODEC_ID_PCM_S32LE_PLANAR:
181 ENCODE_PLANAR(int32_t, le32, dst, n, 0, 0)
182 break;
183 case AV_CODEC_ID_PCM_S16LE:
184 ENCODE(int16_t, le16, samples, dst, n, 0, 0)
185 break;
186 case AV_CODEC_ID_PCM_S16LE_PLANAR:
187 ENCODE_PLANAR(int16_t, le16, dst, n, 0, 0)
188 break;
189 case AV_CODEC_ID_PCM_F64BE:
190 case AV_CODEC_ID_PCM_F32BE:
191 case AV_CODEC_ID_PCM_S64BE:
192 case AV_CODEC_ID_PCM_S32BE:
193 case AV_CODEC_ID_PCM_S16BE:
194 #else
195 65 case AV_CODEC_ID_PCM_S64BE:
196 case AV_CODEC_ID_PCM_F64BE:
197
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(int64_t, be64, samples, dst, n, 0, 0)
198 65 break;
199 174 case AV_CODEC_ID_PCM_F32BE:
200 case AV_CODEC_ID_PCM_S32BE:
201
2/2
✓ Branch 1 taken 1159776 times.
✓ Branch 2 taken 174 times.
 1159950 ENCODE(int32_t, be32, samples, dst, n, 0, 0)
202 174 break;
203 104 case AV_CODEC_ID_PCM_S16BE:
204
2/2
✓ Branch 1 taken 673696 times.
✓ Branch 2 taken 104 times.
 673800 ENCODE(int16_t, be16, samples, dst, n, 0, 0)
205 104 break;
206 83 case AV_CODEC_ID_PCM_S16BE_PLANAR:
207
4/4
✓ Branch 1 taken 673400 times.
✓ Branch 2 taken 159 times.
✓ Branch 3 taken 159 times.
✓ Branch 4 taken 83 times.
 673642 ENCODE_PLANAR(int16_t, be16, dst, n, 0, 0)
208 83 break;
209 233559 case AV_CODEC_ID_PCM_F64LE:
210 case AV_CODEC_ID_PCM_F32LE:
211 case AV_CODEC_ID_PCM_S64LE:
212 case AV_CODEC_ID_PCM_S32LE:
213 case AV_CODEC_ID_PCM_S16LE:
214 #endif /* HAVE_BIGENDIAN */
215 case AV_CODEC_ID_PCM_U8:
216 233559 memcpy(dst, samples, n * sample_size);
217 233559 break;
218 #if HAVE_BIGENDIAN
219 case AV_CODEC_ID_PCM_S16BE_PLANAR:
220 #else
221 130 case AV_CODEC_ID_PCM_S16LE_PLANAR:
222 case AV_CODEC_ID_PCM_S32LE_PLANAR:
223 #endif /* HAVE_BIGENDIAN */
224 130 n /= avctx->ch_layout.nb_channels;
225
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 130 times.
 390 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
226 260 const uint8_t *src = frame->extended_data[c];
227 260 bytestream_put_buffer(&dst, src, n * sample_size);
228 }
229 130 break;
230 #if CONFIG_PCM_ALAW_ENCODER
231 131 case AV_CODEC_ID_PCM_ALAW:
232
2/2
✓ Branch 0 taken 793800 times.
✓ Branch 1 taken 131 times.
 793931 for (; n > 0; n--) {
233 793800 int v = *samples++;
234 793800 *dst++ = linear_to_alaw[(v + 32768) >> 2];
235 }
236 131 break;
237 #endif
238 #if CONFIG_PCM_MULAW_ENCODER
239 76 case AV_CODEC_ID_PCM_MULAW:
240
2/2
✓ Branch 0 taken 573300 times.
✓ Branch 1 taken 76 times.
 573376 for (; n > 0; n--) {
241 573300 int v = *samples++;
242 573300 *dst++ = linear_to_ulaw[(v + 32768) >> 2];
243 }
244 76 break;
245 #endif
246 #if CONFIG_PCM_VIDC_ENCODER
247 ✗ case AV_CODEC_ID_PCM_VIDC:
248 ✗ for (; n > 0; n--) {
249 ✗ int v = *samples++;
250 ✗ *dst++ = linear_to_vidc[(v + 32768) >> 2];
251 }
252 ✗ break;
253 #endif
254 ✗ default:
255 ✗ return -1;
256 }
257
258 241208 *got_packet_ptr = 1;
259 241208 return 0;
260 }
261
262 typedef struct PCMDecode {
263 int sample_size;
264 } PCMDecode;
265
266 1601 av_unused av_cold static int pcm_decode_init(AVCodecContext *avctx)
267 {
268 1601 PCMDecode *s = avctx->priv_data;
269 static const struct {
270 enum AVCodecID codec_id;
271 int8_t sample_fmt;
272 uint8_t sample_size;
273 uint8_t bits_per_sample;
274 } codec_id_to_samplefmt[] = {
275 #define ENTRY(CODEC_ID, SAMPLE_FMT, BITS_PER_SAMPLE) \
276 { AV_CODEC_ID_PCM_ ## CODEC_ID, AV_SAMPLE_FMT_ ## SAMPLE_FMT, \
277 BITS_PER_SAMPLE / 8, BITS_PER_SAMPLE }
278 ENTRY(S8, U8, 8), ENTRY(S8_PLANAR, U8P, 8),
279 ENTRY(S16BE, S16, 16), ENTRY(S16BE_PLANAR, S16P, 16),
280 ENTRY(S16LE, S16, 16), ENTRY(S16LE_PLANAR, S16P, 16),
281 ENTRY(S24DAUD, S16, 24), ENTRY(S24BE, S32, 24),
282 ENTRY(S24LE, S32, 24), ENTRY(S24LE_PLANAR, S32P, 24),
283 ENTRY(S32BE, S32, 32), ENTRY(S32LE, S32, 32),
284 ENTRY(S32LE_PLANAR, S32P, 32),
285 ENTRY(S64BE, S64, 64), ENTRY(S64LE, S64, 64),
286 ENTRY(SGA, U8, 8), ENTRY(U8, U8, 8),
287 ENTRY(U16BE, S16, 16), ENTRY(U16LE, S16, 16),
288 ENTRY(U24BE, S32, 24), ENTRY(U24LE, S32, 24),
289 ENTRY(U32BE, S32, 32), ENTRY(U32LE, S32, 32),
290 ENTRY(F32BE, FLT, 32), ENTRY(F32LE, FLT, 32),
291 ENTRY(F64BE, DBL, 64), ENTRY(F64LE, DBL, 64),
292 { .codec_id = AV_CODEC_ID_PCM_LXF, .sample_fmt = AV_SAMPLE_FMT_S32P, .sample_size = 5 },
293 };
294
295
1/2
✓ Branch 0 taken 10174 times.
✗ Branch 1 not taken.
 10174 for (unsigned i = 0; i < FF_ARRAY_ELEMS(codec_id_to_samplefmt); ++i) {
296
2/2
✓ Branch 0 taken 1601 times.
✓ Branch 1 taken 8573 times.
 10174 if (codec_id_to_samplefmt[i].codec_id == avctx->codec_id) {
297 1601 s->sample_size = codec_id_to_samplefmt[i].sample_size;
298 1601 avctx->sample_fmt = codec_id_to_samplefmt[i].sample_fmt;
299
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 1511 times.
 1601 if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
300 90 avctx->bits_per_raw_sample = codec_id_to_samplefmt[i].bits_per_sample;
301 1601 break;
302 }
303 av_assert1(i + 1 < FF_ARRAY_ELEMS(codec_id_to_samplefmt));
304 }
305
306 1601 return 0;
307 }
308
309 typedef struct PCMScaleDecode {
310 PCMDecode base;
311 void (*vector_fmul_scalar)(float *dst, const float *src, float mul,
312 int len);
313 float scale;
314 } PCMScaleDecode;
315
316 ✗ av_unused av_cold static int pcm_scale_decode_init(AVCodecContext *avctx)
317 {
318 ✗ PCMScaleDecode *s = avctx->priv_data;
319 AVFloatDSPContext *fdsp;
320
321 ✗ avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
322 ✗ s->base.sample_size = 4;
323
324 ✗ if (avctx->bits_per_coded_sample < 1 || avctx->bits_per_coded_sample > 24)
325 ✗ return AVERROR_INVALIDDATA;
326
327 ✗ s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));
328 ✗ fdsp = avpriv_float_dsp_alloc(0);
329 ✗ if (!fdsp)
330 ✗ return AVERROR(ENOMEM);
331 ✗ s->vector_fmul_scalar = fdsp->vector_fmul_scalar;
332 ✗ av_free(fdsp);
333
334 ✗ return 0;
335 }
336
337 typedef struct PCMLUTDecode {
338 PCMDecode base;
339 int16_t table[256];
340 } PCMLUTDecode;
341
342 41 av_unused av_cold static int pcm_lut_decode_init(AVCodecContext *avctx)
343 {
344 41 PCMLUTDecode *s = avctx->priv_data;
345
346
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
 41 switch (avctx->codec_id) {
347 ✗ default:
348 ✗ av_unreachable("pcm_lut_decode_init() only used with alaw, mulaw and vidc");
349 #if CONFIG_PCM_ALAW_DECODER
350 27 case AV_CODEC_ID_PCM_ALAW:
351
2/2
✓ Branch 0 taken 6912 times.
✓ Branch 1 taken 27 times.
 6939 for (int i = 0; i < 256; i++)
352 6912 s->table[i] = alaw2linear(i);
353 27 break;
354 #endif
355 #if CONFIG_PCM_MULAW_DECODER
356 14 case AV_CODEC_ID_PCM_MULAW:
357
2/2
✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 14 times.
 3598 for (int i = 0; i < 256; i++)
358 3584 s->table[i] = ulaw2linear(i);
359 14 break;
360 #endif
361 #if CONFIG_PCM_VIDC_DECODER
362 ✗ case AV_CODEC_ID_PCM_VIDC:
363 ✗ for (int i = 0; i < 256; i++)
364 ✗ s->table[i] = vidc2linear(i);
365 ✗ break;
366 #endif
367 }
368
369 41 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
370 41 s->base.sample_size = 1;
371
372 41 return 0;
373 }
374
375 /**
376 * Read PCM samples macro
377 * @param size Data size of native machine format
378 * @param endian bytestream_get_xxx() endian suffix
379 * @param src Source pointer (variable name)
380 * @param dst Destination pointer (variable name)
381 * @param n Total number of samples (variable name)
382 * @param shift Bitshift (bits)
383 * @param offset Sample value offset
384 */
385 #define DECODE(size, endian, src, dst, n, shift, offset) \
386 for (; n > 0; n--) { \
387 uint ## size ## _t v = bytestream_get_ ## endian(&src); \
388 AV_WN ## size ## A(dst, (uint ## size ## _t)(v - offset) << shift); \
389 dst += size / 8; \
390 }
391
392 #define DECODE_PLANAR(size, endian, src, dst, n, shift, offset) \
393 n /= channels; \
394 for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \
395 int i; \
396 dst = frame->extended_data[c]; \
397 for (i = n; i > 0; i--) { \
398 uint ## size ## _t v = bytestream_get_ ## endian(&src); \
399 AV_WN ## size ## A(dst, (uint ## size ##_t)(v - offset) << shift); \
400 dst += size / 8; \
401 } \
402 }
403
404 37134 static int pcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
405 int *got_frame_ptr, AVPacket *avpkt)
406 {
407 37134 const uint8_t *src = avpkt->data;
408 37134 int buf_size = avpkt->size;
409 37134 PCMDecode *s = avctx->priv_data;
410 37134 int channels = avctx->ch_layout.nb_channels;
411 37134 int sample_size = s->sample_size;
412 int c, n, ret, samples_per_block;
413 uint8_t *samples;
414 int32_t *dst_int32_t;
415
416 37134 samples_per_block = 1;
417
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37134 times.
 37134 if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {
418 /* we process 40-bit blocks per channel for LXF */
419 ✗ samples_per_block = 2;
420 }
421
422
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37134 times.
 37134 if (channels == 0) {
423 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
424 ✗ return AVERROR(EINVAL);
425 }
426
427
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37134 times.
 37134 if (avctx->codec_id != avctx->codec->id) {
428 ✗ av_log(avctx, AV_LOG_ERROR, "codec ids mismatch\n");
429 ✗ return AVERROR(EINVAL);
430 }
431
432 37134 n = channels * sample_size;
433
434
3/4
✓ Branch 0 taken 37134 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 37132 times.
 37134 if (n && buf_size % n) {
435
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (buf_size < n) {
436 1 av_log(avctx, AV_LOG_ERROR,
437 "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",
438 buf_size, n);
439 1 return AVERROR_INVALIDDATA;
440 } else
441 1 buf_size -= buf_size % n;
442 }
443
444 37133 n = buf_size / sample_size;
445
446 /* get output buffer */
447 37133 frame->nb_samples = n * samples_per_block / channels;
448
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 37133 times.
 37133 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
449 ✗ return ret;
450 37133 samples = frame->data[0];
451
452
19/22
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 920 times.
✓ Branch 3 taken 65 times.
✓ Branch 4 taken 259 times.
✓ Branch 5 taken 65 times.
✓ Branch 6 taken 65 times.
✓ Branch 7 taken 86 times.
✓ Branch 8 taken 65 times.
✓ Branch 9 taken 65 times.
✓ Branch 10 taken 259 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 65 times.
✓ Branch 13 taken 65 times.
✓ Branch 14 taken 324 times.
✓ Branch 15 taken 995 times.
✓ Branch 16 taken 76 times.
✓ Branch 17 taken 30660 times.
✓ Branch 18 taken 272 times.
✓ Branch 19 taken 2697 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 37133 switch (avctx->codec_id) {
453 65 case AV_CODEC_ID_PCM_U32LE:
454
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, le32, src, samples, n, 0, 0x80000000)
455 65 break;
456 65 case AV_CODEC_ID_PCM_U32BE:
457
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, be32, src, samples, n, 0, 0x80000000)
458 65 break;
459 920 case AV_CODEC_ID_PCM_S24LE:
460
2/2
✓ Branch 1 taken 27459284 times.
✓ Branch 2 taken 920 times.
 27460204 DECODE(32, le24, src, samples, n, 8, 0)
461 920 break;
462 65 case AV_CODEC_ID_PCM_S24LE_PLANAR:
463
4/4
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 130 times.
✓ Branch 3 taken 130 times.
✓ Branch 4 taken 65 times.
 529395 DECODE_PLANAR(32, le24, src, samples, n, 8, 0);
464 65 break;
465 259 case AV_CODEC_ID_PCM_S24BE:
466
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 259 times.
 529459 DECODE(32, be24, src, samples, n, 8, 0)
467 259 break;
468 65 case AV_CODEC_ID_PCM_U24LE:
469
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, le24, src, samples, n, 8, 0x800000)
470 65 break;
471 65 case AV_CODEC_ID_PCM_U24BE:
472
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, be24, src, samples, n, 8, 0x800000)
473 65 break;
474 86 case AV_CODEC_ID_PCM_S24DAUD:
475
2/2
✓ Branch 0 taken 1026720 times.
✓ Branch 1 taken 86 times.
 1026806 for (; n > 0; n--) {
476 1026720 uint32_t v = bytestream_get_be24(&src);
477 1026720 v >>= 4; // sync flags are here
478 1026720 AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
479 (ff_reverse[v & 0xff] << 8));
480 1026720 samples += 2;
481 }
482 86 break;
483 65 case AV_CODEC_ID_PCM_U16LE:
484
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(16, le16, src, samples, n, 0, 0x8000)
485 65 break;
486 65 case AV_CODEC_ID_PCM_U16BE:
487
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(16, be16, src, samples, n, 0, 0x8000)
488 65 break;
489 259 case AV_CODEC_ID_PCM_S8:
490
2/2
✓ Branch 0 taken 529200 times.
✓ Branch 1 taken 259 times.
 529459 for (; n > 0; n--)
491 529200 *samples++ = *src++ + 128;
492 259 break;
493 ✗ case AV_CODEC_ID_PCM_SGA:
494 ✗ for (; n > 0; n--) {
495 ✗ int sign = *src >> 7;
496 ✗ int magn = *src & 0x7f;
497 ✗ *samples++ = sign ? 128 - magn : 128 + magn;
498 ✗ src++;
499 }
500 ✗ break;
501 65 case AV_CODEC_ID_PCM_S8_PLANAR:
502 65 n /= avctx->ch_layout.nb_channels;
503
2/2
✓ Branch 0 taken 130 times.
✓ Branch 1 taken 65 times.
 195 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
504 int i;
505 130 samples = frame->extended_data[c];
506
2/2
✓ Branch 0 taken 529200 times.
✓ Branch 1 taken 130 times.
 529330 for (i = n; i > 0; i--)
507 529200 *samples++ = *src++ + 128;
508 }
509 65 break;
510 #if HAVE_BIGENDIAN
511 case AV_CODEC_ID_PCM_S64LE:
512 case AV_CODEC_ID_PCM_F64LE:
513 DECODE(64, le64, src, samples, n, 0, 0)
514 break;
515 case AV_CODEC_ID_PCM_S32LE:
516 case AV_CODEC_ID_PCM_F32LE:
517 case AV_CODEC_ID_PCM_F24LE:
518 case AV_CODEC_ID_PCM_F16LE:
519 DECODE(32, le32, src, samples, n, 0, 0)
520 break;
521 case AV_CODEC_ID_PCM_S32LE_PLANAR:
522 DECODE_PLANAR(32, le32, src, samples, n, 0, 0);
523 break;
524 case AV_CODEC_ID_PCM_S16LE:
525 DECODE(16, le16, src, samples, n, 0, 0)
526 break;
527 case AV_CODEC_ID_PCM_S16LE_PLANAR:
528 DECODE_PLANAR(16, le16, src, samples, n, 0, 0);
529 break;
530 case AV_CODEC_ID_PCM_F64BE:
531 case AV_CODEC_ID_PCM_F32BE:
532 case AV_CODEC_ID_PCM_S64BE:
533 case AV_CODEC_ID_PCM_S32BE:
534 case AV_CODEC_ID_PCM_S16BE:
535 #else
536 65 case AV_CODEC_ID_PCM_S64BE:
537 case AV_CODEC_ID_PCM_F64BE:
538
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(64, be64, src, samples, n, 0, 0)
539 65 break;
540 324 case AV_CODEC_ID_PCM_F32BE:
541 case AV_CODEC_ID_PCM_S32BE:
542
2/2
✓ Branch 1 taken 1058400 times.
✓ Branch 2 taken 324 times.
 1058724 DECODE(32, be32, src, samples, n, 0, 0)
543 324 break;
544 995 case AV_CODEC_ID_PCM_S16BE:
545
2/2
✓ Branch 1 taken 1887814 times.
✓ Branch 2 taken 995 times.
 1888809 DECODE(16, be16, src, samples, n, 0, 0)
546 995 break;
547 76 case AV_CODEC_ID_PCM_S16BE_PLANAR:
548
4/4
✓ Branch 1 taken 617400 times.
✓ Branch 2 taken 152 times.
✓ Branch 3 taken 152 times.
✓ Branch 4 taken 76 times.
 617628 DECODE_PLANAR(16, be16, src, samples, n, 0, 0);
549 76 break;
550 30660 case AV_CODEC_ID_PCM_F64LE:
551 case AV_CODEC_ID_PCM_F32LE:
552 case AV_CODEC_ID_PCM_F24LE:
553 case AV_CODEC_ID_PCM_F16LE:
554 case AV_CODEC_ID_PCM_S64LE:
555 case AV_CODEC_ID_PCM_S32LE:
556 case AV_CODEC_ID_PCM_S16LE:
557 #endif /* HAVE_BIGENDIAN */
558 case AV_CODEC_ID_PCM_U8:
559 30660 memcpy(samples, src, n * sample_size);
560 30660 break;
561 #if HAVE_BIGENDIAN
562 case AV_CODEC_ID_PCM_S16BE_PLANAR:
563 #else
564 272 case AV_CODEC_ID_PCM_S16LE_PLANAR:
565 case AV_CODEC_ID_PCM_S32LE_PLANAR:
566 #endif /* HAVE_BIGENDIAN */
567 272 n /= avctx->ch_layout.nb_channels;
568
2/2
✓ Branch 0 taken 544 times.
✓ Branch 1 taken 272 times.
 816 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
569 544 samples = frame->extended_data[c];
570 544 bytestream_get_buffer(&src, samples, n * sample_size);
571 }
572 272 break;
573 #if CONFIG_PCM_ALAW_DECODER || CONFIG_PCM_MULAW_DECODER || \
574 CONFIG_PCM_VIDC_DECODER
575 2697 case AV_CODEC_ID_PCM_ALAW:
576 case AV_CODEC_ID_PCM_MULAW:
577 case AV_CODEC_ID_PCM_VIDC: {
578 2697 const int16_t *const lut = ((PCMLUTDecode*)avctx->priv_data)->table;
579 2697 int16_t *restrict samples_16 = (int16_t*)samples;
580
581
2/2
✓ Branch 0 taken 5024313 times.
✓ Branch 1 taken 2697 times.
 5027010 for (; n > 0; n--)
582 5024313 *samples_16++ = lut[*src++];
583 2697 break;
584 }
585 #endif
586 ✗ case AV_CODEC_ID_PCM_LXF:
587 {
588 int i;
589 ✗ n /= channels;
590 ✗ for (c = 0; c < channels; c++) {
591 ✗ dst_int32_t = (int32_t *)frame->extended_data[c];
592 ✗ for (i = 0; i < n; i++) {
593 // extract low 20 bits and expand to 32 bits
594 ✗ *dst_int32_t++ = ((uint32_t)src[2]<<28) |
595 ✗ (src[1] << 20) |
596 ✗ (src[0] << 12) |
597 ✗ ((src[2] & 0x0F) << 8) |
598 ✗ src[1];
599 // extract high 20 bits and expand to 32 bits
600 ✗ *dst_int32_t++ = ((uint32_t)src[4]<<24) |
601 ✗ (src[3] << 16) |
602 ✗ ((src[2] & 0xF0) << 8) |
603 ✗ (src[4] << 4) |
604 ✗ (src[3] >> 4);
605 ✗ src += 5;
606 }
607 }
608 ✗ break;
609 }
610 ✗ default:
611 ✗ return -1;
612 }
613
614
1/2
✓ Branch 0 taken 37133 times.
✗ Branch 1 not taken.
 37133 if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
615
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 37133 times.
 37133 avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
616 ✗ PCMScaleDecode *s2 = avctx->priv_data;
617 ✗ s2->vector_fmul_scalar((float *)frame->extended_data[0],
618 ✗ (const float *)frame->extended_data[0],
619 ✗ s2->scale, FFALIGN(frame->nb_samples * avctx->ch_layout.nb_channels, 4));
620 }
621
622 37133 *got_frame_ptr = 1;
623
624 37133 return buf_size;
625 }
626
627 #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
628 #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_) \
629 const FFCodec ff_ ## name_ ## _encoder = { \
630 .p.name = #name_, \
631 CODEC_LONG_NAME(long_name_), \
632 .p.type = AVMEDIA_TYPE_AUDIO, \
633 .p.id = id_, \
634 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | \
635 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, \
636 .init = pcm_encode_init, \
637 FF_CODEC_ENCODE_CB(pcm_encode_frame), \
638 CODEC_SAMPLEFMTS(sample_fmt_), \
639 }
640
641 #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name) \
642 PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)
643 #define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name) \
644 PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)
645 #define PCM_ENCODER(id, sample_fmt, name, long_name) \
646 PCM_ENCODER_3(CONFIG_PCM_ ## id ## _ENCODER, AV_CODEC_ID_PCM_ ## id, \
647 AV_SAMPLE_FMT_ ## sample_fmt, pcm_ ## name, long_name)
648
649 #define PCM_DECODER_0(id, sample_fmt, name, long_name, Context, init_func)
650 #define PCM_DECODER_1(id_, sample_fmt, name_, long_name, Context, init_func)\
651 const FFCodec ff_ ## name_ ## _decoder = { \
652 .p.name = #name_, \
653 CODEC_LONG_NAME(long_name), \
654 .p.type = AVMEDIA_TYPE_AUDIO, \
655 .p.id = id_, \
656 .priv_data_size = sizeof(Context), \
657 .init = init_func, \
658 FF_CODEC_DECODE_CB(pcm_decode_frame), \
659 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_PARAM_CHANGE, \
660 }
661
662 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name, Context, init_func) \
663 PCM_DECODER_ ## cf(id, sample_fmt, name, long_name, Context, init_func)
664 #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name, Context, init_func) \
665 PCM_DECODER_2(cf, id, sample_fmt, name, long_name, Context, init_func)
666 #define PCM_DEC_EXT(id, sample_fmt, name, long_name, Context, init_func) \
667 PCM_DECODER_3(CONFIG_PCM_ ## id ## _DECODER, AV_CODEC_ID_PCM_ ## id, \
668 AV_SAMPLE_FMT_ ## sample_fmt, pcm_ ## name, long_name, \
669 Context, init_func)
670
671 #define PCM_DECODER(id, sample_fmt, name, long_name) \
672 PCM_DEC_EXT(id, sample_fmt, name, long_name, PCMDecode, pcm_decode_init)
673
674 #define PCM_CODEC(id, sample_fmt_, name, long_name_) \
675 PCM_ENCODER(id, sample_fmt_, name, long_name_); \
676 PCM_DECODER(id, sample_fmt_, name, long_name_)
677
678 #define PCM_CODEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func) \
679 PCM_DEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func); \
680 PCM_ENCODER(id, sample_fmt, name, long_name)
681
682 /* Note: Do not forget to add new entries to the Makefile and
683 * to the table in pcm_decode_init() as well. */
684 // AV_CODEC_ID_* pcm_* name
685 // AV_SAMPLE_FMT_* long name DecodeContext decode init func
686 PCM_CODEC_EXT(ALAW, S16, alaw, "PCM A-law / G.711 A-law", PCMLUTDecode, pcm_lut_decode_init);
687 PCM_DEC_EXT (F16LE, FLT, f16le, "PCM 16.8 floating point little-endian", PCMScaleDecode, pcm_scale_decode_init);
688 PCM_DEC_EXT (F24LE, FLT, f24le, "PCM 24.0 floating point little-endian", PCMScaleDecode, pcm_scale_decode_init);
689 PCM_CODEC (F32BE, FLT, f32be, "PCM 32-bit floating point big-endian");
690 PCM_CODEC (F32LE, FLT, f32le, "PCM 32-bit floating point little-endian");
691 PCM_CODEC (F64BE, DBL, f64be, "PCM 64-bit floating point big-endian");
692 PCM_CODEC (F64LE, DBL, f64le, "PCM 64-bit floating point little-endian");
693 PCM_DECODER (LXF, S32P,lxf, "PCM signed 20-bit little-endian planar");
694 PCM_CODEC_EXT(MULAW, S16, mulaw, "PCM mu-law / G.711 mu-law", PCMLUTDecode, pcm_lut_decode_init);
695 PCM_CODEC (S8, U8, s8, "PCM signed 8-bit");
696 PCM_CODEC (S8_PLANAR, U8P, s8_planar, "PCM signed 8-bit planar");
697 PCM_CODEC (S16BE, S16, s16be, "PCM signed 16-bit big-endian");
698 PCM_CODEC (S16BE_PLANAR, S16P,s16be_planar, "PCM signed 16-bit big-endian planar");
699 PCM_CODEC (S16LE, S16, s16le, "PCM signed 16-bit little-endian");
700 PCM_CODEC (S16LE_PLANAR, S16P,s16le_planar, "PCM signed 16-bit little-endian planar");
701 PCM_CODEC (S24BE, S32, s24be, "PCM signed 24-bit big-endian");
702 PCM_CODEC (S24DAUD, S16, s24daud, "PCM D-Cinema audio signed 24-bit");
703 PCM_CODEC (S24LE, S32, s24le, "PCM signed 24-bit little-endian");
704 PCM_CODEC (S24LE_PLANAR, S32P,s24le_planar, "PCM signed 24-bit little-endian planar");
705 PCM_CODEC (S32BE, S32, s32be, "PCM signed 32-bit big-endian");
706 PCM_CODEC (S32LE, S32, s32le, "PCM signed 32-bit little-endian");
707 PCM_CODEC (S32LE_PLANAR, S32P,s32le_planar, "PCM signed 32-bit little-endian planar");
708 PCM_CODEC (U8, U8, u8, "PCM unsigned 8-bit");
709 PCM_CODEC (U16BE, S16, u16be, "PCM unsigned 16-bit big-endian");
710 PCM_CODEC (U16LE, S16, u16le, "PCM unsigned 16-bit little-endian");
711 PCM_CODEC (U24BE, S32, u24be, "PCM unsigned 24-bit big-endian");
712 PCM_CODEC (U24LE, S32, u24le, "PCM unsigned 24-bit little-endian");
713 PCM_CODEC (U32BE, S32, u32be, "PCM unsigned 32-bit big-endian");
714 PCM_CODEC (U32LE, S32, u32le, "PCM unsigned 32-bit little-endian");
715 PCM_CODEC (S64BE, S64, s64be, "PCM signed 64-bit big-endian");
716 PCM_CODEC (S64LE, S64, s64le, "PCM signed 64-bit little-endian");
717 PCM_CODEC_EXT(VIDC, S16, vidc, "PCM Archimedes VIDC", PCMLUTDecode, pcm_lut_decode_init);
718 PCM_DECODER (SGA, U8, sga, "PCM SGA");
719