Statistics
| Branch: | Revision:

ffmpeg / libavcodec / pcm.c @ 72415b2a

History | View | Annotate | Download (18.6 KB)

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 libavcodec/pcm.c
24
 * PCM codecs
25
 */
26

    
27
#include "avcodec.h"
28
#include "libavutil/common.h" /* for av_reverse */
29
#include "bytestream.h"
30

    
31
#define MAX_CHANNELS 64
32

    
33
/* from g711.c by SUN microsystems (unrestricted use) */
34

    
35
#define         SIGN_BIT        (0x80)      /* Sign bit for a A-law byte. */
36
#define         QUANT_MASK      (0xf)       /* Quantization field mask. */
37
#define         NSEGS           (8)         /* Number of A-law segments. */
38
#define         SEG_SHIFT       (4)         /* Left shift for segment number. */
39
#define         SEG_MASK        (0x70)      /* Segment field mask. */
40

    
41
#define         BIAS            (0x84)      /* Bias for linear code. */
42

    
43
/*
44
 * alaw2linear() - Convert an A-law value to 16-bit linear PCM
45
 *
46
 */
47
static av_cold int alaw2linear(unsigned char a_val)
48
{
49
        int t;
50
        int seg;
51

    
52
        a_val ^= 0x55;
53

    
54
        t = a_val & QUANT_MASK;
55
        seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
56
        if(seg) t= (t + t + 1 + 32) << (seg + 2);
57
        else    t= (t + t + 1     ) << 3;
58

    
59
        return (a_val & SIGN_BIT) ? t : -t;
60
}
61

    
62
static av_cold int ulaw2linear(unsigned char u_val)
63
{
64
        int t;
65

    
66
        /* Complement to obtain normal u-law value. */
67
        u_val = ~u_val;
68

    
69
        /*
70
         * Extract and bias the quantization bits. Then
71
         * shift up by the segment number and subtract out the bias.
72
         */
73
        t = ((u_val & QUANT_MASK) << 3) + BIAS;
74
        t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
75

    
76
        return (u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS);
77
}
78

    
79
/* 16384 entries per table */
80
static uint8_t linear_to_alaw[16384];
81
static uint8_t linear_to_ulaw[16384];
82

    
83
static av_cold void build_xlaw_table(uint8_t *linear_to_xlaw,
84
                             int (*xlaw2linear)(unsigned char),
85
                             int mask)
86
{
87
    int i, j, v, v1, v2;
88

    
89
    j = 0;
90
    for(i=0;i<128;i++) {
91
        if (i != 127) {
92
            v1 = xlaw2linear(i ^ mask);
93
            v2 = xlaw2linear((i + 1) ^ mask);
94
            v = (v1 + v2 + 4) >> 3;
95
        } else {
96
            v = 8192;
97
        }
98
        for(;j<v;j++) {
99
            linear_to_xlaw[8192 + j] = (i ^ mask);
100
            if (j > 0)
101
                linear_to_xlaw[8192 - j] = (i ^ (mask ^ 0x80));
102
        }
103
    }
104
    linear_to_xlaw[0] = linear_to_xlaw[1];
105
}
106

    
107
static av_cold int pcm_encode_init(AVCodecContext *avctx)
108
{
109
    avctx->frame_size = 1;
110
    switch(avctx->codec->id) {
111
    case CODEC_ID_PCM_ALAW:
112
        build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);
113
        break;
114
    case CODEC_ID_PCM_MULAW:
115
        build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);
116
        break;
117
    default:
118
        break;
119
    }
120

    
121
    avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
122
    avctx->block_align = avctx->channels * avctx->bits_per_coded_sample/8;
123
    avctx->coded_frame= avcodec_alloc_frame();
124
    avctx->coded_frame->key_frame= 1;
125

    
126
    return 0;
127
}
128

    
129
static av_cold int pcm_encode_close(AVCodecContext *avctx)
130
{
131
    av_freep(&avctx->coded_frame);
132

    
133
    return 0;
134
}
135

    
136
/**
137
 * Write PCM samples macro
138
 * @param type Datatype of native machine format
139
 * @param endian bytestream_put_xxx() suffix
140
 * @param src Source pointer (variable name)
141
 * @param dst Destination pointer (variable name)
142
 * @param n Total number of samples (variable name)
143
 * @param shift Bitshift (bits)
144
 * @param offset Sample value offset
145
 */
146
#define ENCODE(type, endian, src, dst, n, shift, offset) \
147
    samples_##type = (type*)src; \
148
    for(;n>0;n--) { \
149
        register type v = (*samples_##type++ >> shift) + offset; \
150
        bytestream_put_##endian(&dst, v); \
151
    }
152

    
153
static int pcm_encode_frame(AVCodecContext *avctx,
154
                            unsigned char *frame, int buf_size, void *data)
155
{
156
    int n, sample_size, v;
157
    short *samples;
158
    unsigned char *dst;
159
    uint8_t *srcu8;
160
    int16_t *samples_int16_t;
161
    int32_t *samples_int32_t;
162
    int64_t *samples_int64_t;
163
    uint16_t *samples_uint16_t;
164
    uint32_t *samples_uint32_t;
165

    
166
    sample_size = av_get_bits_per_sample(avctx->codec->id)/8;
167
    n = buf_size / sample_size;
168
    samples = data;
169
    dst = frame;
170

    
171
    if (avctx->sample_fmt!=avctx->codec->sample_fmts[0]) {
172
        av_log(avctx, AV_LOG_ERROR, "invalid sample_fmt\n");
173
        return -1;
174
    }
175

    
176
    switch(avctx->codec->id) {
177
    case CODEC_ID_PCM_U32LE:
178
        ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
179
        break;
180
    case CODEC_ID_PCM_U32BE:
181
        ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
182
        break;
183
    case CODEC_ID_PCM_S24LE:
184
        ENCODE(int32_t, le24, samples, dst, n, 8, 0)
185
        break;
186
    case CODEC_ID_PCM_S24BE:
187
        ENCODE(int32_t, be24, samples, dst, n, 8, 0)
188
        break;
189
    case CODEC_ID_PCM_U24LE:
190
        ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
191
        break;
192
    case CODEC_ID_PCM_U24BE:
193
        ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
194
        break;
195
    case CODEC_ID_PCM_S24DAUD:
196
        for(;n>0;n--) {
197
            uint32_t tmp = av_reverse[(*samples >> 8) & 0xff] +
198
                           (av_reverse[*samples & 0xff] << 8);
199
            tmp <<= 4; // sync flags would go here
200
            bytestream_put_be24(&dst, tmp);
201
            samples++;
202
        }
203
        break;
204
    case CODEC_ID_PCM_U16LE:
205
        ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
206
        break;
207
    case CODEC_ID_PCM_U16BE:
208
        ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
209
        break;
210
    case CODEC_ID_PCM_S8:
211
        srcu8= data;
212
        for(;n>0;n--) {
213
            v = *srcu8++;
214
            *dst++ = v - 128;
215
        }
216
        break;
217
#if HAVE_BIGENDIAN
218
    case CODEC_ID_PCM_F64LE:
219
        ENCODE(int64_t, le64, samples, dst, n, 0, 0)
220
        break;
221
    case CODEC_ID_PCM_S32LE:
222
    case CODEC_ID_PCM_F32LE:
223
        ENCODE(int32_t, le32, samples, dst, n, 0, 0)
224
        break;
225
    case CODEC_ID_PCM_S16LE:
226
        ENCODE(int16_t, le16, samples, dst, n, 0, 0)
227
        break;
228
    case CODEC_ID_PCM_F64BE:
229
    case CODEC_ID_PCM_F32BE:
230
    case CODEC_ID_PCM_S32BE:
231
    case CODEC_ID_PCM_S16BE:
232
#else
233
    case CODEC_ID_PCM_F64BE:
234
        ENCODE(int64_t, be64, samples, dst, n, 0, 0)
235
        break;
236
    case CODEC_ID_PCM_F32BE:
237
    case CODEC_ID_PCM_S32BE:
238
        ENCODE(int32_t, be32, samples, dst, n, 0, 0)
239
        break;
240
    case CODEC_ID_PCM_S16BE:
241
        ENCODE(int16_t, be16, samples, dst, n, 0, 0)
242
        break;
243
    case CODEC_ID_PCM_F64LE:
244
    case CODEC_ID_PCM_F32LE:
245
    case CODEC_ID_PCM_S32LE:
246
    case CODEC_ID_PCM_S16LE:
247
#endif /* HAVE_BIGENDIAN */
248
    case CODEC_ID_PCM_U8:
249
        memcpy(dst, samples, n*sample_size);
250
        dst += n*sample_size;
251
        break;
252
    case CODEC_ID_PCM_ZORK:
253
        for(;n>0;n--) {
254
            v= *samples++ >> 8;
255
            if(v<0)   v = -v;
256
            else      v+= 128;
257
            *dst++ = v;
258
        }
259
        break;
260
    case CODEC_ID_PCM_ALAW:
261
        for(;n>0;n--) {
262
            v = *samples++;
263
            *dst++ = linear_to_alaw[(v + 32768) >> 2];
264
        }
265
        break;
266
    case CODEC_ID_PCM_MULAW:
267
        for(;n>0;n--) {
268
            v = *samples++;
269
            *dst++ = linear_to_ulaw[(v + 32768) >> 2];
270
        }
271
        break;
272
    default:
273
        return -1;
274
    }
275
    //avctx->frame_size = (dst - frame) / (sample_size * avctx->channels);
276

    
277
    return dst - frame;
278
}
279

    
280
typedef struct PCMDecode {
281
    short table[256];
282
} PCMDecode;
283

    
284
static av_cold int pcm_decode_init(AVCodecContext * avctx)
285
{
286
    PCMDecode *s = avctx->priv_data;
287
    int i;
288

    
289
    switch(avctx->codec->id) {
290
    case CODEC_ID_PCM_ALAW:
291
        for(i=0;i<256;i++)
292
            s->table[i] = alaw2linear(i);
293
        break;
294
    case CODEC_ID_PCM_MULAW:
295
        for(i=0;i<256;i++)
296
            s->table[i] = ulaw2linear(i);
297
        break;
298
    default:
299
        break;
300
    }
301

    
302
    avctx->sample_fmt = avctx->codec->sample_fmts[0];
303
    return 0;
304
}
305

    
306
/**
307
 * Read PCM samples macro
308
 * @param type Datatype of native machine format
309
 * @param endian bytestream_get_xxx() endian suffix
310
 * @param src Source pointer (variable name)
311
 * @param dst Destination pointer (variable name)
312
 * @param n Total number of samples (variable name)
313
 * @param shift Bitshift (bits)
314
 * @param offset Sample value offset
315
 */
316
#define DECODE(type, endian, src, dst, n, shift, offset) \
317
    dst_##type = (type*)dst; \
318
    for(;n>0;n--) { \
319
        register type v = bytestream_get_##endian(&src); \
320
        *dst_##type++ = (v - offset) << shift; \
321
    } \
322
    dst = (short*)dst_##type;
323

    
324
static int pcm_decode_frame(AVCodecContext *avctx,
325
                            void *data, int *data_size,
326
                            AVPacket *avpkt)
327
{
328
    const uint8_t *buf = avpkt->data;
329
    int buf_size = avpkt->size;
330
    PCMDecode *s = avctx->priv_data;
331
    int sample_size, c, n;
332
    short *samples;
333
    const uint8_t *src, *src8, *src2[MAX_CHANNELS];
334
    uint8_t *dstu8;
335
    int16_t *dst_int16_t;
336
    int32_t *dst_int32_t;
337
    int64_t *dst_int64_t;
338
    uint16_t *dst_uint16_t;
339
    uint32_t *dst_uint32_t;
340

    
341
    samples = data;
342
    src = buf;
343

    
344
    if (avctx->sample_fmt!=avctx->codec->sample_fmts[0]) {
345
        av_log(avctx, AV_LOG_ERROR, "invalid sample_fmt\n");
346
        return -1;
347
    }
348

    
349
    if(avctx->channels <= 0 || avctx->channels > MAX_CHANNELS){
350
        av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
351
        return -1;
352
    }
353

    
354
    sample_size = av_get_bits_per_sample(avctx->codec_id)/8;
355

    
356
    /* av_get_bits_per_sample returns 0 for CODEC_ID_PCM_DVD */
357
    if (CODEC_ID_PCM_DVD == avctx->codec_id)
358
        /* 2 samples are interleaved per block in PCM_DVD */
359
        sample_size = avctx->bits_per_coded_sample * 2 / 8;
360

    
361
    n = avctx->channels * sample_size;
362

    
363
    if(n && buf_size % n){
364
        if (buf_size < n) {
365
            av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");
366
            return -1;
367
        }else
368
            buf_size -= buf_size % n;
369
    }
370

    
371
    buf_size= FFMIN(buf_size, *data_size/2);
372
    *data_size=0;
373

    
374
    n = buf_size/sample_size;
375

    
376
    switch(avctx->codec->id) {
377
    case CODEC_ID_PCM_U32LE:
378
        DECODE(uint32_t, le32, src, samples, n, 0, 0x80000000)
379
        break;
380
    case CODEC_ID_PCM_U32BE:
381
        DECODE(uint32_t, be32, src, samples, n, 0, 0x80000000)
382
        break;
383
    case CODEC_ID_PCM_S24LE:
384
        DECODE(int32_t, le24, src, samples, n, 8, 0)
385
        break;
386
    case CODEC_ID_PCM_S24BE:
387
        DECODE(int32_t, be24, src, samples, n, 8, 0)
388
        break;
389
    case CODEC_ID_PCM_U24LE:
390
        DECODE(uint32_t, le24, src, samples, n, 8, 0x800000)
391
        break;
392
    case CODEC_ID_PCM_U24BE:
393
        DECODE(uint32_t, be24, src, samples, n, 8, 0x800000)
394
        break;
395
    case CODEC_ID_PCM_S24DAUD:
396
        for(;n>0;n--) {
397
          uint32_t v = bytestream_get_be24(&src);
398
          v >>= 4; // sync flags are here
399
          *samples++ = av_reverse[(v >> 8) & 0xff] +
400
                       (av_reverse[v & 0xff] << 8);
401
        }
402
        break;
403
    case CODEC_ID_PCM_S16LE_PLANAR:
404
        n /= avctx->channels;
405
        for(c=0;c<avctx->channels;c++)
406
            src2[c] = &src[c*n*2];
407
        for(;n>0;n--)
408
            for(c=0;c<avctx->channels;c++)
409
                *samples++ = bytestream_get_le16(&src2[c]);
410
        src = src2[avctx->channels-1];
411
        break;
412
    case CODEC_ID_PCM_U16LE:
413
        DECODE(uint16_t, le16, src, samples, n, 0, 0x8000)
414
        break;
415
    case CODEC_ID_PCM_U16BE:
416
        DECODE(uint16_t, be16, src, samples, n, 0, 0x8000)
417
        break;
418
    case CODEC_ID_PCM_S8:
419
        dstu8= (uint8_t*)samples;
420
        for(;n>0;n--) {
421
            *dstu8++ = *src++ + 128;
422
        }
423
        samples= (short*)dstu8;
424
        break;
425
#if HAVE_BIGENDIAN
426
    case CODEC_ID_PCM_F64LE:
427
        DECODE(int64_t, le64, src, samples, n, 0, 0)
428
        break;
429
    case CODEC_ID_PCM_S32LE:
430
    case CODEC_ID_PCM_F32LE:
431
        DECODE(int32_t, le32, src, samples, n, 0, 0)
432
        break;
433
    case CODEC_ID_PCM_S16LE:
434
        DECODE(int16_t, le16, src, samples, n, 0, 0)
435
        break;
436
    case CODEC_ID_PCM_F64BE:
437
    case CODEC_ID_PCM_F32BE:
438
    case CODEC_ID_PCM_S32BE:
439
    case CODEC_ID_PCM_S16BE:
440
#else
441
    case CODEC_ID_PCM_F64BE:
442
        DECODE(int64_t, be64, src, samples, n, 0, 0)
443
        break;
444
    case CODEC_ID_PCM_F32BE:
445
    case CODEC_ID_PCM_S32BE:
446
        DECODE(int32_t, be32, src, samples, n, 0, 0)
447
        break;
448
    case CODEC_ID_PCM_S16BE:
449
        DECODE(int16_t, be16, src, samples, n, 0, 0)
450
        break;
451
    case CODEC_ID_PCM_F64LE:
452
    case CODEC_ID_PCM_F32LE:
453
    case CODEC_ID_PCM_S32LE:
454
    case CODEC_ID_PCM_S16LE:
455
#endif /* HAVE_BIGENDIAN */
456
    case CODEC_ID_PCM_U8:
457
        memcpy(samples, src, n*sample_size);
458
        src += n*sample_size;
459
        samples = (short*)((uint8_t*)data + n*sample_size);
460
        break;
461
    case CODEC_ID_PCM_ZORK:
462
        for(;n>0;n--) {
463
            int x= *src++;
464
            if(x&128) x-= 128;
465
            else      x = -x;
466
            *samples++ = x << 8;
467
        }
468
        break;
469
    case CODEC_ID_PCM_ALAW:
470
    case CODEC_ID_PCM_MULAW:
471
        for(;n>0;n--) {
472
            *samples++ = s->table[*src++];
473
        }
474
        break;
475
    case CODEC_ID_PCM_DVD:
476
        dst_int32_t = data;
477
        n /= avctx->channels;
478
        switch (avctx->bits_per_coded_sample) {
479
        case 20:
480
            while (n--) {
481
                c = avctx->channels;
482
                src8 = src + 4*c;
483
                while (c--) {
484
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8   &0xf0) << 8);
485
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++ &0x0f) << 12);
486
                }
487
                src = src8;
488
            }
489
            break;
490
        case 24:
491
            while (n--) {
492
                c = avctx->channels;
493
                src8 = src + 4*c;
494
                while (c--) {
495
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++) << 8);
496
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++) << 8);
497
                }
498
                src = src8;
499
            }
500
            break;
501
        default:
502
            av_log(avctx, AV_LOG_ERROR, "PCM DVD unsupported sample depth\n");
503
            return -1;
504
            break;
505
        }
506
        samples = (short *) dst_int32_t;
507
        break;
508
    default:
509
        return -1;
510
    }
511
    *data_size = (uint8_t *)samples - (uint8_t *)data;
512
    return src - buf;
513
}
514

    
515
#if CONFIG_ENCODERS
516
#define PCM_ENCODER(id,sample_fmt_,name,long_name_) \
517
AVCodec name ## _encoder = {                    \
518
    #name,                                      \
519
    AVMEDIA_TYPE_AUDIO,                         \
520
    id,                                         \
521
    0,                                          \
522
    pcm_encode_init,                            \
523
    pcm_encode_frame,                           \
524
    pcm_encode_close,                           \
525
    NULL,                                       \
526
    .sample_fmts = (const enum SampleFormat[]){sample_fmt_,SAMPLE_FMT_NONE}, \
527
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
528
};
529
#else
530
#define PCM_ENCODER(id,sample_fmt_,name,long_name_)
531
#endif
532

    
533
#if CONFIG_DECODERS
534
#define PCM_DECODER(id,sample_fmt_,name,long_name_)         \
535
AVCodec name ## _decoder = {                    \
536
    #name,                                      \
537
    AVMEDIA_TYPE_AUDIO,                         \
538
    id,                                         \
539
    sizeof(PCMDecode),                          \
540
    pcm_decode_init,                            \
541
    NULL,                                       \
542
    NULL,                                       \
543
    pcm_decode_frame,                           \
544
    .sample_fmts = (const enum SampleFormat[]){sample_fmt_,SAMPLE_FMT_NONE}, \
545
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
546
};
547
#else
548
#define PCM_DECODER(id,sample_fmt_,name,long_name_)
549
#endif
550

    
551
#define PCM_CODEC(id, sample_fmt_, name, long_name_)         \
552
    PCM_ENCODER(id,sample_fmt_,name,long_name_) PCM_DECODER(id,sample_fmt_,name,long_name_)
553

    
554
/* Note: Do not forget to add new entries to the Makefile as well. */
555
PCM_CODEC  (CODEC_ID_PCM_ALAW,  SAMPLE_FMT_S16, pcm_alaw, "PCM A-law");
556
PCM_CODEC  (CODEC_ID_PCM_DVD,   SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20|24-bit big-endian");
557
PCM_CODEC  (CODEC_ID_PCM_F32BE, SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
558
PCM_CODEC  (CODEC_ID_PCM_F32LE, SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
559
PCM_CODEC  (CODEC_ID_PCM_F64BE, SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
560
PCM_CODEC  (CODEC_ID_PCM_F64LE, SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
561
PCM_CODEC  (CODEC_ID_PCM_MULAW, SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law");
562
PCM_CODEC  (CODEC_ID_PCM_S8,    SAMPLE_FMT_U8,  pcm_s8, "PCM signed 8-bit");
563
PCM_CODEC  (CODEC_ID_PCM_S16BE, SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
564
PCM_CODEC  (CODEC_ID_PCM_S16LE, SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
565
PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, SAMPLE_FMT_S16, pcm_s16le_planar, "PCM 16-bit little-endian planar");
566
PCM_CODEC  (CODEC_ID_PCM_S24BE, SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
567
PCM_CODEC  (CODEC_ID_PCM_S24DAUD, SAMPLE_FMT_S16,  pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
568
PCM_CODEC  (CODEC_ID_PCM_S24LE, SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
569
PCM_CODEC  (CODEC_ID_PCM_S32BE, SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
570
PCM_CODEC  (CODEC_ID_PCM_S32LE, SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
571
PCM_CODEC  (CODEC_ID_PCM_U8,    SAMPLE_FMT_U8,  pcm_u8, "PCM unsigned 8-bit");
572
PCM_CODEC  (CODEC_ID_PCM_U16BE, SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
573
PCM_CODEC  (CODEC_ID_PCM_U16LE, SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
574
PCM_CODEC  (CODEC_ID_PCM_U24BE, SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
575
PCM_CODEC  (CODEC_ID_PCM_U24LE, SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
576
PCM_CODEC  (CODEC_ID_PCM_U32BE, SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
577
PCM_CODEC  (CODEC_ID_PCM_U32LE, SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
578
PCM_CODEC  (CODEC_ID_PCM_ZORK,  SAMPLE_FMT_S16, pcm_zork, "PCM Zork");