FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/pcm.c
Date: 2025-06-23 20:06:14
Exec Total Coverage
Lines: 213 277 76.9%
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 1157 static av_cold int pcm_encode_init(AVCodecContext *avctx)
42 {
43 1157 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 1148 times.
 1157 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 7 INIT_ONCE(ALAW, alaw);
54 2 INIT_ONCE(MULAW, ulaw);
55 ✗ INIT_ONCE(VIDC, vidc);
56 1148 default:
57 1148 break;
58 }
59 #endif
60
61 1157 avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
62 1157 avctx->block_align = avctx->ch_layout.nb_channels * avctx->bits_per_coded_sample / 8;
63 1157 avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate;
64
65 1157 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 232789 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 232789 sample_size = av_get_bits_per_sample(avctx->codec->id) / 8;
110 232789 n = frame->nb_samples * avctx->ch_layout.nb_channels;
111 232789 samples = (const short *)frame->data[0];
112
113
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 232789 times.
 232789 if ((ret = ff_get_encode_buffer(avctx, avpkt, n * sample_size, 0)) < 0)
114 ✗ return ret;
115 232789 dst = avpkt->data;
116
117
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 225140 times.
✓ Branch 17 taken 130 times.
✓ Branch 18 taken 131 times.
✓ Branch 19 taken 76 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 232789 switch (avctx->codec->id) {
118 65 case AV_CODEC_ID_PCM_U32LE:
119
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
120 65 break;
121 65 case AV_CODEC_ID_PCM_U32BE:
122
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
123 65 break;
124 5861 case AV_CODEC_ID_PCM_S24LE:
125
2/2
✓ Branch 1 taken 39500794 times.
✓ Branch 2 taken 5861 times.
 39506655 ENCODE(int32_t, le24, samples, dst, n, 8, 0)
126 5861 break;
127 65 case AV_CODEC_ID_PCM_S24LE_PLANAR:
128
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)
129 65 break;
130 313 case AV_CODEC_ID_PCM_S24BE:
131
2/2
✓ Branch 1 taken 8497686 times.
✓ Branch 2 taken 313 times.
 8497999 ENCODE(int32_t, be24, samples, dst, n, 8, 0)
132 313 break;
133 65 case AV_CODEC_ID_PCM_U24LE:
134
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
135 65 break;
136 65 case AV_CODEC_ID_PCM_U24BE:
137
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
138 65 break;
139 20 case AV_CODEC_ID_PCM_S24DAUD:
140
2/2
✓ Branch 0 taken 983040 times.
✓ Branch 1 taken 20 times.
 983060 for (; n > 0; n--) {
141 983040 uint32_t tmp = ff_reverse[(*samples >> 8) & 0xff] +
142 983040 (ff_reverse[*samples & 0xff] << 8);
143 983040 tmp <<= 4; // sync flags would go here
144 983040 bytestream_put_be24(&dst, tmp);
145 983040 samples++;
146 }
147 20 break;
148 65 case AV_CODEC_ID_PCM_U16LE:
149
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
150 65 break;
151 65 case AV_CODEC_ID_PCM_U16BE:
152
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
153 65 break;
154 172 case AV_CODEC_ID_PCM_S8:
155
2/2
✓ Branch 1 taken 7726268 times.
✓ Branch 2 taken 172 times.
 7726440 ENCODE(uint8_t, byte, samples, dst, n, 0, -128)
156 172 break;
157 65 case AV_CODEC_ID_PCM_S8_PLANAR:
158
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)
159 65 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 65 case AV_CODEC_ID_PCM_S64BE:
185 case AV_CODEC_ID_PCM_F64BE:
186
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 ENCODE(int64_t, be64, samples, dst, n, 0, 0)
187 65 break;
188 174 case AV_CODEC_ID_PCM_F32BE:
189 case AV_CODEC_ID_PCM_S32BE:
190
2/2
✓ Branch 1 taken 1159776 times.
✓ Branch 2 taken 174 times.
 1159950 ENCODE(int32_t, be32, samples, dst, n, 0, 0)
191 174 break;
192 104 case AV_CODEC_ID_PCM_S16BE:
193
2/2
✓ Branch 1 taken 673696 times.
✓ Branch 2 taken 104 times.
 673800 ENCODE(int16_t, be16, samples, dst, n, 0, 0)
194 104 break;
195 83 case AV_CODEC_ID_PCM_S16BE_PLANAR:
196
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)
197 83 break;
198 225140 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 225140 memcpy(dst, samples, n * sample_size);
206 225140 break;
207 #if HAVE_BIGENDIAN
208 case AV_CODEC_ID_PCM_S16BE_PLANAR:
209 #else
210 130 case AV_CODEC_ID_PCM_S16LE_PLANAR:
211 case AV_CODEC_ID_PCM_S32LE_PLANAR:
212 #endif /* HAVE_BIGENDIAN */
213 130 n /= avctx->ch_layout.nb_channels;
214
2/2
✓ Branch 0 taken 260 times.
✓ Branch 1 taken 130 times.
 390 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
215 260 const uint8_t *src = frame->extended_data[c];
216 260 bytestream_put_buffer(&dst, src, n * sample_size);
217 }
218 130 break;
219 131 case AV_CODEC_ID_PCM_ALAW:
220
2/2
✓ Branch 0 taken 793800 times.
✓ Branch 1 taken 131 times.
 793931 for (; n > 0; n--) {
221 793800 v = *samples++;
222 793800 *dst++ = linear_to_alaw[(v + 32768) >> 2];
223 }
224 131 break;
225 76 case AV_CODEC_ID_PCM_MULAW:
226
2/2
✓ Branch 0 taken 573300 times.
✓ Branch 1 taken 76 times.
 573376 for (; n > 0; n--) {
227 573300 v = *samples++;
228 573300 *dst++ = linear_to_ulaw[(v + 32768) >> 2];
229 }
230 76 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 232789 *got_packet_ptr = 1;
242 232789 return 0;
243 }
244
245 typedef struct PCMDecode {
246 int sample_size;
247 } PCMDecode;
248
249 1579 static av_cold av_unused int pcm_decode_init(AVCodecContext *avctx)
250 {
251 1579 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
1/2
✓ Branch 0 taken 10067 times.
✗ Branch 1 not taken.
 10067 for (unsigned i = 0; i < FF_ARRAY_ELEMS(codec_id_to_samplefmt); ++i) {
279
2/2
✓ Branch 0 taken 1579 times.
✓ Branch 1 taken 8488 times.
 10067 if (codec_id_to_samplefmt[i].codec_id == avctx->codec_id) {
280 1579 s->sample_size = codec_id_to_samplefmt[i].sample_size;
281 1579 avctx->sample_fmt = codec_id_to_samplefmt[i].sample_fmt;
282
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 1489 times.
 1579 if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
283 90 avctx->bits_per_raw_sample = codec_id_to_samplefmt[i].bits_per_sample;
284 1579 break;
285 }
286 av_assert1(i + 1 < FF_ARRAY_ELEMS(codec_id_to_samplefmt));
287 }
288
289 1579 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 40 static av_cold av_unused int pcm_lut_decode_init(AVCodecContext *avctx)
326 {
327 40 PCMLUTDecode *s = avctx->priv_data;
328
329
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
 40 switch (avctx->codec_id) {
330 ✗ default:
331 ✗ av_unreachable("pcm_lut_decode_init() only used with alaw, mulaw and vidc");
332 26 case AV_CODEC_ID_PCM_ALAW:
333
2/2
✓ Branch 0 taken 6656 times.
✓ Branch 1 taken 26 times.
 6682 for (int i = 0; i < 256; i++)
334 6656 s->table[i] = alaw2linear(i);
335 26 break;
336 14 case AV_CODEC_ID_PCM_MULAW:
337
2/2
✓ Branch 0 taken 3584 times.
✓ Branch 1 taken 14 times.
 3598 for (int i = 0; i < 256; i++)
338 3584 s->table[i] = ulaw2linear(i);
339 14 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 40 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
347 40 s->base.sample_size = 1;
348
349 40 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 38961 static int pcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
382 int *got_frame_ptr, AVPacket *avpkt)
383 {
384 38961 const uint8_t *src = avpkt->data;
385 38961 int buf_size = avpkt->size;
386 38961 PCMDecode *s = avctx->priv_data;
387 38961 int channels = avctx->ch_layout.nb_channels;
388 38961 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 38961 samples_per_block = 1;
394
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38961 times.
 38961 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
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38961 times.
 38961 if (channels == 0) {
400 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
401 ✗ return AVERROR(EINVAL);
402 }
403
404
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38961 times.
 38961 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 38961 n = channels * sample_size;
410
411
3/4
✓ Branch 0 taken 38961 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 38959 times.
 38961 if (n && buf_size % n) {
412
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (buf_size < n) {
413 1 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 1 return AVERROR_INVALIDDATA;
417 } else
418 1 buf_size -= buf_size % n;
419 }
420
421 38960 n = buf_size / sample_size;
422
423 /* get output buffer */
424 38960 frame->nb_samples = n * samples_per_block / channels;
425
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 38960 times.
 38960 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
426 ✗ return ret;
427 38960 samples = frame->data[0];
428
429
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 32487 times.
✓ Branch 18 taken 272 times.
✓ Branch 19 taken 2697 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
 38960 switch (avctx->codec_id) {
430 65 case AV_CODEC_ID_PCM_U32LE:
431
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, le32, src, samples, n, 0, 0x80000000)
432 65 break;
433 65 case AV_CODEC_ID_PCM_U32BE:
434
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, be32, src, samples, n, 0, 0x80000000)
435 65 break;
436 920 case AV_CODEC_ID_PCM_S24LE:
437
2/2
✓ Branch 1 taken 27459284 times.
✓ Branch 2 taken 920 times.
 27460204 DECODE(32, le24, src, samples, n, 8, 0)
438 920 break;
439 65 case AV_CODEC_ID_PCM_S24LE_PLANAR:
440
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);
441 65 break;
442 259 case AV_CODEC_ID_PCM_S24BE:
443
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 259 times.
 529459 DECODE(32, be24, src, samples, n, 8, 0)
444 259 break;
445 65 case AV_CODEC_ID_PCM_U24LE:
446
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, le24, src, samples, n, 8, 0x800000)
447 65 break;
448 65 case AV_CODEC_ID_PCM_U24BE:
449
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(32, be24, src, samples, n, 8, 0x800000)
450 65 break;
451 86 case AV_CODEC_ID_PCM_S24DAUD:
452
2/2
✓ Branch 0 taken 1026720 times.
✓ Branch 1 taken 86 times.
 1026806 for (; n > 0; n--) {
453 1026720 uint32_t v = bytestream_get_be24(&src);
454 1026720 v >>= 4; // sync flags are here
455 1026720 AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
456 (ff_reverse[v & 0xff] << 8));
457 1026720 samples += 2;
458 }
459 86 break;
460 65 case AV_CODEC_ID_PCM_U16LE:
461
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(16, le16, src, samples, n, 0, 0x8000)
462 65 break;
463 65 case AV_CODEC_ID_PCM_U16BE:
464
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(16, be16, src, samples, n, 0, 0x8000)
465 65 break;
466 259 case AV_CODEC_ID_PCM_S8:
467
2/2
✓ Branch 0 taken 529200 times.
✓ Branch 1 taken 259 times.
 529459 for (; n > 0; n--)
468 529200 *samples++ = *src++ + 128;
469 259 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 65 case AV_CODEC_ID_PCM_S8_PLANAR:
479 65 n /= avctx->ch_layout.nb_channels;
480
2/2
✓ Branch 0 taken 130 times.
✓ Branch 1 taken 65 times.
 195 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
481 int i;
482 130 samples = frame->extended_data[c];
483
2/2
✓ Branch 0 taken 529200 times.
✓ Branch 1 taken 130 times.
 529330 for (i = n; i > 0; i--)
484 529200 *samples++ = *src++ + 128;
485 }
486 65 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 65 case AV_CODEC_ID_PCM_S64BE:
514 case AV_CODEC_ID_PCM_F64BE:
515
2/2
✓ Branch 1 taken 529200 times.
✓ Branch 2 taken 65 times.
 529265 DECODE(64, be64, src, samples, n, 0, 0)
516 65 break;
517 324 case AV_CODEC_ID_PCM_F32BE:
518 case AV_CODEC_ID_PCM_S32BE:
519
2/2
✓ Branch 1 taken 1058400 times.
✓ Branch 2 taken 324 times.
 1058724 DECODE(32, be32, src, samples, n, 0, 0)
520 324 break;
521 995 case AV_CODEC_ID_PCM_S16BE:
522
2/2
✓ Branch 1 taken 1887814 times.
✓ Branch 2 taken 995 times.
 1888809 DECODE(16, be16, src, samples, n, 0, 0)
523 995 break;
524 76 case AV_CODEC_ID_PCM_S16BE_PLANAR:
525
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);
526 76 break;
527 32487 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 32487 memcpy(samples, src, n * sample_size);
537 32487 break;
538 #if HAVE_BIGENDIAN
539 case AV_CODEC_ID_PCM_S16BE_PLANAR:
540 #else
541 272 case AV_CODEC_ID_PCM_S16LE_PLANAR:
542 case AV_CODEC_ID_PCM_S32LE_PLANAR:
543 #endif /* HAVE_BIGENDIAN */
544 272 n /= avctx->ch_layout.nb_channels;
545
2/2
✓ Branch 0 taken 544 times.
✓ Branch 1 taken 272 times.
 816 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {
546 544 samples = frame->extended_data[c];
547 544 bytestream_get_buffer(&src, samples, n * sample_size);
548 }
549 272 break;
550 2697 case AV_CODEC_ID_PCM_ALAW:
551 case AV_CODEC_ID_PCM_MULAW:
552 case AV_CODEC_ID_PCM_VIDC: {
553 2697 const int16_t *const lut = ((PCMLUTDecode*)avctx->priv_data)->table;
554 2697 int16_t *restrict samples_16 = (int16_t*)samples;
555
556
2/2
✓ Branch 0 taken 5024313 times.
✓ Branch 1 taken 2697 times.
 5027010 for (; n > 0; n--)
557 5024313 *samples_16++ = lut[*src++];
558 2697 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
1/2
✓ Branch 0 taken 38960 times.
✗ Branch 1 not taken.
 38960 if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
589
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 38960 times.
 38960 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 38960 *got_frame_ptr = 1;
597
598 38960 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");
693