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 | 38944 | static int pcm_decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
382 | int *got_frame_ptr, AVPacket *avpkt) | ||
383 | { | ||
384 | 38944 | const uint8_t *src = avpkt->data; | |
385 | 38944 | int buf_size = avpkt->size; | |
386 | 38944 | PCMDecode *s = avctx->priv_data; | |
387 | 38944 | int channels = avctx->ch_layout.nb_channels; | |
388 | 38944 | 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 | 38944 | samples_per_block = 1; | |
394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38944 times.
|
38944 | 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 38944 times.
|
38944 | 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 38944 times.
|
38944 | 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 | 38944 | n = channels * sample_size; | |
410 | |||
411 |
3/4✓ Branch 0 taken 38944 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 38942 times.
|
38944 | 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 | 38943 | n = buf_size / sample_size; | |
422 | |||
423 | /* get output buffer */ | ||
424 | 38943 | frame->nb_samples = n * samples_per_block / channels; | |
425 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 38943 times.
|
38943 | if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) |
426 | ✗ | return ret; | |
427 | 38943 | 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 32469 times.
✓ Branch 18 taken 272 times.
✓ Branch 19 taken 2698 times.
✗ Branch 20 not taken.
✗ Branch 21 not taken.
|
38943 | 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 | 32469 | 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 | 32469 | memcpy(samples, src, n * sample_size); | |
537 | 32469 | 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 | 2698 | case AV_CODEC_ID_PCM_ALAW: | |
551 | case AV_CODEC_ID_PCM_MULAW: | ||
552 | case AV_CODEC_ID_PCM_VIDC: { | ||
553 | 2698 | const int16_t *const lut = ((PCMLUTDecode*)avctx->priv_data)->table; | |
554 | 2698 | int16_t *restrict samples_16 = (int16_t*)samples; | |
555 | |||
556 |
2/2✓ Branch 0 taken 5035338 times.
✓ Branch 1 taken 2698 times.
|
5038036 | for (; n > 0; n--) |
557 | 5035338 | *samples_16++ = lut[*src++]; | |
558 | 2698 | 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 38943 times.
✗ Branch 1 not taken.
|
38943 | if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE || |
589 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 38943 times.
|
38943 | 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 | 38943 | *got_frame_ptr = 1; | |
597 | |||
598 | 38943 | 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 |