Statistics
| Branch: | Revision:

ffmpeg / libavcodec / pcm.c @ 5d6e4c16

History | View | Annotate | Download (17.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
24
 * PCM codecs
25
 */
26

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

    
32
#define MAX_CHANNELS 64
33

    
34
static av_cold int pcm_encode_init(AVCodecContext *avctx)
35
{
36
    avctx->frame_size = 1;
37
    switch(avctx->codec->id) {
38
    case CODEC_ID_PCM_ALAW:
39
        pcm_alaw_tableinit();
40
        break;
41
    case CODEC_ID_PCM_MULAW:
42
        pcm_ulaw_tableinit();
43
        break;
44
    default:
45
        break;
46
    }
47

    
48
    avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
49
    avctx->block_align = avctx->channels * avctx->bits_per_coded_sample/8;
50
    avctx->coded_frame= avcodec_alloc_frame();
51
    avctx->coded_frame->key_frame= 1;
52

    
53
    return 0;
54
}
55

    
56
static av_cold int pcm_encode_close(AVCodecContext *avctx)
57
{
58
    av_freep(&avctx->coded_frame);
59

    
60
    return 0;
61
}
62

    
63
/**
64
 * Write PCM samples macro
65
 * @param type Datatype of native machine format
66
 * @param endian bytestream_put_xxx() suffix
67
 * @param src Source pointer (variable name)
68
 * @param dst Destination pointer (variable name)
69
 * @param n Total number of samples (variable name)
70
 * @param shift Bitshift (bits)
71
 * @param offset Sample value offset
72
 */
73
#define ENCODE(type, endian, src, dst, n, shift, offset) \
74
    samples_##type = (type*)src; \
75
    for(;n>0;n--) { \
76
        register type v = (*samples_##type++ >> shift) + offset; \
77
        bytestream_put_##endian(&dst, v); \
78
    }
79

    
80
static int pcm_encode_frame(AVCodecContext *avctx,
81
                            unsigned char *frame, int buf_size, void *data)
82
{
83
    int n, sample_size, v;
84
    const short *samples;
85
    unsigned char *dst;
86
    const uint8_t *srcu8;
87
    const int16_t *samples_int16_t;
88
    const int32_t *samples_int32_t;
89
    const int64_t *samples_int64_t;
90
    const uint16_t *samples_uint16_t;
91
    const uint32_t *samples_uint32_t;
92

    
93
    sample_size = av_get_bits_per_sample(avctx->codec->id)/8;
94
    n = buf_size / sample_size;
95
    samples = data;
96
    dst = frame;
97

    
98
    if (avctx->sample_fmt!=avctx->codec->sample_fmts[0]) {
99
        av_log(avctx, AV_LOG_ERROR, "invalid sample_fmt\n");
100
        return -1;
101
    }
102

    
103
    switch(avctx->codec->id) {
104
    case CODEC_ID_PCM_U32LE:
105
        ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
106
        break;
107
    case CODEC_ID_PCM_U32BE:
108
        ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
109
        break;
110
    case CODEC_ID_PCM_S24LE:
111
        ENCODE(int32_t, le24, samples, dst, n, 8, 0)
112
        break;
113
    case CODEC_ID_PCM_S24BE:
114
        ENCODE(int32_t, be24, samples, dst, n, 8, 0)
115
        break;
116
    case CODEC_ID_PCM_U24LE:
117
        ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
118
        break;
119
    case CODEC_ID_PCM_U24BE:
120
        ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
121
        break;
122
    case CODEC_ID_PCM_S24DAUD:
123
        for(;n>0;n--) {
124
            uint32_t tmp = av_reverse[(*samples >> 8) & 0xff] +
125
                           (av_reverse[*samples & 0xff] << 8);
126
            tmp <<= 4; // sync flags would go here
127
            bytestream_put_be24(&dst, tmp);
128
            samples++;
129
        }
130
        break;
131
    case CODEC_ID_PCM_U16LE:
132
        ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
133
        break;
134
    case CODEC_ID_PCM_U16BE:
135
        ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
136
        break;
137
    case CODEC_ID_PCM_S8:
138
        srcu8= data;
139
        for(;n>0;n--) {
140
            v = *srcu8++;
141
            *dst++ = v - 128;
142
        }
143
        break;
144
#if HAVE_BIGENDIAN
145
    case CODEC_ID_PCM_F64LE:
146
        ENCODE(int64_t, le64, samples, dst, n, 0, 0)
147
        break;
148
    case CODEC_ID_PCM_S32LE:
149
    case CODEC_ID_PCM_F32LE:
150
        ENCODE(int32_t, le32, samples, dst, n, 0, 0)
151
        break;
152
    case CODEC_ID_PCM_S16LE:
153
        ENCODE(int16_t, le16, samples, dst, n, 0, 0)
154
        break;
155
    case CODEC_ID_PCM_F64BE:
156
    case CODEC_ID_PCM_F32BE:
157
    case CODEC_ID_PCM_S32BE:
158
    case CODEC_ID_PCM_S16BE:
159
#else
160
    case CODEC_ID_PCM_F64BE:
161
        ENCODE(int64_t, be64, samples, dst, n, 0, 0)
162
        break;
163
    case CODEC_ID_PCM_F32BE:
164
    case CODEC_ID_PCM_S32BE:
165
        ENCODE(int32_t, be32, samples, dst, n, 0, 0)
166
        break;
167
    case CODEC_ID_PCM_S16BE:
168
        ENCODE(int16_t, be16, samples, dst, n, 0, 0)
169
        break;
170
    case CODEC_ID_PCM_F64LE:
171
    case CODEC_ID_PCM_F32LE:
172
    case CODEC_ID_PCM_S32LE:
173
    case CODEC_ID_PCM_S16LE:
174
#endif /* HAVE_BIGENDIAN */
175
    case CODEC_ID_PCM_U8:
176
        memcpy(dst, samples, n*sample_size);
177
        dst += n*sample_size;
178
        break;
179
    case CODEC_ID_PCM_ZORK:
180
        for(;n>0;n--) {
181
            v= *samples++ >> 8;
182
            if(v<0)   v = -v;
183
            else      v+= 128;
184
            *dst++ = v;
185
        }
186
        break;
187
    case CODEC_ID_PCM_ALAW:
188
        for(;n>0;n--) {
189
            v = *samples++;
190
            *dst++ = linear_to_alaw[(v + 32768) >> 2];
191
        }
192
        break;
193
    case CODEC_ID_PCM_MULAW:
194
        for(;n>0;n--) {
195
            v = *samples++;
196
            *dst++ = linear_to_ulaw[(v + 32768) >> 2];
197
        }
198
        break;
199
    default:
200
        return -1;
201
    }
202
    //avctx->frame_size = (dst - frame) / (sample_size * avctx->channels);
203

    
204
    return dst - frame;
205
}
206

    
207
typedef struct PCMDecode {
208
    short table[256];
209
} PCMDecode;
210

    
211
static av_cold int pcm_decode_init(AVCodecContext * avctx)
212
{
213
    PCMDecode *s = avctx->priv_data;
214
    int i;
215

    
216
    switch(avctx->codec->id) {
217
    case CODEC_ID_PCM_ALAW:
218
        for(i=0;i<256;i++)
219
            s->table[i] = alaw2linear(i);
220
        break;
221
    case CODEC_ID_PCM_MULAW:
222
        for(i=0;i<256;i++)
223
            s->table[i] = ulaw2linear(i);
224
        break;
225
    default:
226
        break;
227
    }
228

    
229
    avctx->sample_fmt = avctx->codec->sample_fmts[0];
230

    
231
    if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
232
        avctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec->id);
233

    
234
    return 0;
235
}
236

    
237
/**
238
 * Read PCM samples macro
239
 * @param type Datatype of native machine format
240
 * @param endian bytestream_get_xxx() endian suffix
241
 * @param src Source pointer (variable name)
242
 * @param dst Destination pointer (variable name)
243
 * @param n Total number of samples (variable name)
244
 * @param shift Bitshift (bits)
245
 * @param offset Sample value offset
246
 */
247
#define DECODE(type, endian, src, dst, n, shift, offset) \
248
    dst_##type = (type*)dst; \
249
    for(;n>0;n--) { \
250
        register type v = bytestream_get_##endian(&src); \
251
        *dst_##type++ = (v - offset) << shift; \
252
    } \
253
    dst = (short*)dst_##type;
254

    
255
static int pcm_decode_frame(AVCodecContext *avctx,
256
                            void *data, int *data_size,
257
                            AVPacket *avpkt)
258
{
259
    const uint8_t *buf = avpkt->data;
260
    int buf_size = avpkt->size;
261
    PCMDecode *s = avctx->priv_data;
262
    int sample_size, c, n, i;
263
    short *samples;
264
    const uint8_t *src, *src8, *src2[MAX_CHANNELS];
265
    uint8_t *dstu8;
266
    int16_t *dst_int16_t;
267
    int32_t *dst_int32_t;
268
    int64_t *dst_int64_t;
269
    uint16_t *dst_uint16_t;
270
    uint32_t *dst_uint32_t;
271

    
272
    samples = data;
273
    src = buf;
274

    
275
    if (avctx->sample_fmt!=avctx->codec->sample_fmts[0]) {
276
        av_log(avctx, AV_LOG_ERROR, "invalid sample_fmt\n");
277
        return -1;
278
    }
279

    
280
    if(avctx->channels <= 0 || avctx->channels > MAX_CHANNELS){
281
        av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
282
        return -1;
283
    }
284

    
285
    sample_size = av_get_bits_per_sample(avctx->codec_id)/8;
286

    
287
    /* av_get_bits_per_sample returns 0 for CODEC_ID_PCM_DVD */
288
    if (CODEC_ID_PCM_DVD == avctx->codec_id)
289
        /* 2 samples are interleaved per block in PCM_DVD */
290
        sample_size = avctx->bits_per_coded_sample * 2 / 8;
291
    else if (avctx->codec_id == CODEC_ID_PCM_LXF)
292
        /* we process 40-bit blocks per channel for LXF */
293
        sample_size = 5;
294

    
295
    n = avctx->channels * sample_size;
296

    
297
    if(n && buf_size % n){
298
        if (buf_size < n) {
299
            av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");
300
            return -1;
301
        }else
302
            buf_size -= buf_size % n;
303
    }
304

    
305
    buf_size= FFMIN(buf_size, *data_size/2);
306
    *data_size=0;
307

    
308
    n = buf_size/sample_size;
309

    
310
    switch(avctx->codec->id) {
311
    case CODEC_ID_PCM_U32LE:
312
        DECODE(uint32_t, le32, src, samples, n, 0, 0x80000000)
313
        break;
314
    case CODEC_ID_PCM_U32BE:
315
        DECODE(uint32_t, be32, src, samples, n, 0, 0x80000000)
316
        break;
317
    case CODEC_ID_PCM_S24LE:
318
        DECODE(int32_t, le24, src, samples, n, 8, 0)
319
        break;
320
    case CODEC_ID_PCM_S24BE:
321
        DECODE(int32_t, be24, src, samples, n, 8, 0)
322
        break;
323
    case CODEC_ID_PCM_U24LE:
324
        DECODE(uint32_t, le24, src, samples, n, 8, 0x800000)
325
        break;
326
    case CODEC_ID_PCM_U24BE:
327
        DECODE(uint32_t, be24, src, samples, n, 8, 0x800000)
328
        break;
329
    case CODEC_ID_PCM_S24DAUD:
330
        for(;n>0;n--) {
331
          uint32_t v = bytestream_get_be24(&src);
332
          v >>= 4; // sync flags are here
333
          *samples++ = av_reverse[(v >> 8) & 0xff] +
334
                       (av_reverse[v & 0xff] << 8);
335
        }
336
        break;
337
    case CODEC_ID_PCM_S16LE_PLANAR:
338
        n /= avctx->channels;
339
        for(c=0;c<avctx->channels;c++)
340
            src2[c] = &src[c*n*2];
341
        for(;n>0;n--)
342
            for(c=0;c<avctx->channels;c++)
343
                *samples++ = bytestream_get_le16(&src2[c]);
344
        src = src2[avctx->channels-1];
345
        break;
346
    case CODEC_ID_PCM_U16LE:
347
        DECODE(uint16_t, le16, src, samples, n, 0, 0x8000)
348
        break;
349
    case CODEC_ID_PCM_U16BE:
350
        DECODE(uint16_t, be16, src, samples, n, 0, 0x8000)
351
        break;
352
    case CODEC_ID_PCM_S8:
353
        dstu8= (uint8_t*)samples;
354
        for(;n>0;n--) {
355
            *dstu8++ = *src++ + 128;
356
        }
357
        samples= (short*)dstu8;
358
        break;
359
#if HAVE_BIGENDIAN
360
    case CODEC_ID_PCM_F64LE:
361
        DECODE(int64_t, le64, src, samples, n, 0, 0)
362
        break;
363
    case CODEC_ID_PCM_S32LE:
364
    case CODEC_ID_PCM_F32LE:
365
        DECODE(int32_t, le32, src, samples, n, 0, 0)
366
        break;
367
    case CODEC_ID_PCM_S16LE:
368
        DECODE(int16_t, le16, src, samples, n, 0, 0)
369
        break;
370
    case CODEC_ID_PCM_F64BE:
371
    case CODEC_ID_PCM_F32BE:
372
    case CODEC_ID_PCM_S32BE:
373
    case CODEC_ID_PCM_S16BE:
374
#else
375
    case CODEC_ID_PCM_F64BE:
376
        DECODE(int64_t, be64, src, samples, n, 0, 0)
377
        break;
378
    case CODEC_ID_PCM_F32BE:
379
    case CODEC_ID_PCM_S32BE:
380
        DECODE(int32_t, be32, src, samples, n, 0, 0)
381
        break;
382
    case CODEC_ID_PCM_S16BE:
383
        DECODE(int16_t, be16, src, samples, n, 0, 0)
384
        break;
385
    case CODEC_ID_PCM_F64LE:
386
    case CODEC_ID_PCM_F32LE:
387
    case CODEC_ID_PCM_S32LE:
388
    case CODEC_ID_PCM_S16LE:
389
#endif /* HAVE_BIGENDIAN */
390
    case CODEC_ID_PCM_U8:
391
        memcpy(samples, src, n*sample_size);
392
        src += n*sample_size;
393
        samples = (short*)((uint8_t*)data + n*sample_size);
394
        break;
395
    case CODEC_ID_PCM_ZORK:
396
        for(;n>0;n--) {
397
            int x= *src++;
398
            if(x&128) x-= 128;
399
            else      x = -x;
400
            *samples++ = x << 8;
401
        }
402
        break;
403
    case CODEC_ID_PCM_ALAW:
404
    case CODEC_ID_PCM_MULAW:
405
        for(;n>0;n--) {
406
            *samples++ = s->table[*src++];
407
        }
408
        break;
409
    case CODEC_ID_PCM_DVD:
410
        dst_int32_t = data;
411
        n /= avctx->channels;
412
        switch (avctx->bits_per_coded_sample) {
413
        case 20:
414
            while (n--) {
415
                c = avctx->channels;
416
                src8 = src + 4*c;
417
                while (c--) {
418
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8   &0xf0) << 8);
419
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++ &0x0f) << 12);
420
                }
421
                src = src8;
422
            }
423
            break;
424
        case 24:
425
            while (n--) {
426
                c = avctx->channels;
427
                src8 = src + 4*c;
428
                while (c--) {
429
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++) << 8);
430
                    *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++) << 8);
431
                }
432
                src = src8;
433
            }
434
            break;
435
        default:
436
            av_log(avctx, AV_LOG_ERROR, "PCM DVD unsupported sample depth\n");
437
            return -1;
438
            break;
439
        }
440
        samples = (short *) dst_int32_t;
441
        break;
442
    case CODEC_ID_PCM_LXF:
443
        dst_int32_t = data;
444
        n /= avctx->channels;
445
        //unpack and de-planerize
446
        for (i = 0; i < n; i++) {
447
            for (c = 0, src8 = src + i*5; c < avctx->channels; c++, src8 += n*5) {
448
                //extract low 20 bits and expand to 32 bits
449
                *dst_int32_t++ = (src8[2] << 28) | (src8[1] << 20) | (src8[0] << 12) |
450
                                 ((src8[2] & 0xF) << 8) | src8[1];
451
            }
452

    
453
            for (c = 0, src8 = src + i*5; c < avctx->channels; c++, src8 += n*5) {
454
                //extract high 20 bits and expand to 32 bits
455
                *dst_int32_t++ = (src8[4] << 24) | (src8[3] << 16) |
456
                                 ((src8[2] & 0xF0) << 8) | (src8[4] << 4) | (src8[3] >> 4);
457
            }
458
        }
459
        src += n * avctx->channels * 5;
460
        samples = (short *) dst_int32_t;
461
        break;
462
    default:
463
        return -1;
464
    }
465
    *data_size = (uint8_t *)samples - (uint8_t *)data;
466
    return src - buf;
467
}
468

    
469
#if CONFIG_ENCODERS
470
#define PCM_ENCODER(id_,sample_fmt_,name_,long_name_) \
471
AVCodec name_ ## _encoder = {                   \
472
    .name        = #name_,                      \
473
    .type        = AVMEDIA_TYPE_AUDIO,          \
474
    .id          = id_,                         \
475
    .init        = pcm_encode_init,             \
476
    .encode      = pcm_encode_frame,            \
477
    .close       = pcm_encode_close,            \
478
    .sample_fmts = (const enum AVSampleFormat[]){sample_fmt_,AV_SAMPLE_FMT_NONE}, \
479
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
480
};
481
#else
482
#define PCM_ENCODER(id,sample_fmt_,name,long_name_)
483
#endif
484

    
485
#if CONFIG_DECODERS
486
#define PCM_DECODER(id_,sample_fmt_,name_,long_name_)         \
487
AVCodec name_ ## _decoder = {                   \
488
    .name           = #name_,                   \
489
    .type           = AVMEDIA_TYPE_AUDIO,       \
490
    .id             = id_,                      \
491
    .priv_data_size = sizeof(PCMDecode),        \
492
    .init           = pcm_decode_init,          \
493
    .decode         = pcm_decode_frame,         \
494
    .sample_fmts = (const enum AVSampleFormat[]){sample_fmt_,AV_SAMPLE_FMT_NONE}, \
495
    .long_name = NULL_IF_CONFIG_SMALL(long_name_), \
496
};
497
#else
498
#define PCM_DECODER(id,sample_fmt_,name,long_name_)
499
#endif
500

    
501
#define PCM_CODEC(id, sample_fmt_, name, long_name_)         \
502
    PCM_ENCODER(id,sample_fmt_,name,long_name_) PCM_DECODER(id,sample_fmt_,name,long_name_)
503

    
504
/* Note: Do not forget to add new entries to the Makefile as well. */
505
PCM_CODEC  (CODEC_ID_PCM_ALAW,  AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law");
506
PCM_CODEC  (CODEC_ID_PCM_DVD,   AV_SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20|24-bit big-endian");
507
PCM_CODEC  (CODEC_ID_PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");
508
PCM_CODEC  (CODEC_ID_PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");
509
PCM_CODEC  (CODEC_ID_PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");
510
PCM_CODEC  (CODEC_ID_PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");
511
PCM_DECODER(CODEC_ID_PCM_LXF,   AV_SAMPLE_FMT_S32, pcm_lxf, "PCM signed 20-bit little-endian planar");
512
PCM_CODEC  (CODEC_ID_PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law");
513
PCM_CODEC  (CODEC_ID_PCM_S8,    AV_SAMPLE_FMT_U8,  pcm_s8, "PCM signed 8-bit");
514
PCM_CODEC  (CODEC_ID_PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");
515
PCM_CODEC  (CODEC_ID_PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");
516
PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16, pcm_s16le_planar, "PCM 16-bit little-endian planar");
517
PCM_CODEC  (CODEC_ID_PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");
518
PCM_CODEC  (CODEC_ID_PCM_S24DAUD, AV_SAMPLE_FMT_S16,  pcm_s24daud, "PCM D-Cinema audio signed 24-bit");
519
PCM_CODEC  (CODEC_ID_PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");
520
PCM_CODEC  (CODEC_ID_PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");
521
PCM_CODEC  (CODEC_ID_PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");
522
PCM_CODEC  (CODEC_ID_PCM_U8,    AV_SAMPLE_FMT_U8,  pcm_u8, "PCM unsigned 8-bit");
523
PCM_CODEC  (CODEC_ID_PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");
524
PCM_CODEC  (CODEC_ID_PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");
525
PCM_CODEC  (CODEC_ID_PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");
526
PCM_CODEC  (CODEC_ID_PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");
527
PCM_CODEC  (CODEC_ID_PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");
528
PCM_CODEC  (CODEC_ID_PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");
529
PCM_CODEC  (CODEC_ID_PCM_ZORK,  AV_SAMPLE_FMT_S16, pcm_zork, "PCM Zork");