Statistics
| Branch: | Revision:

ffmpeg / libavcodec / pcm.c @ 98ec8287

History | View | Annotate | Download (17.7 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
    if (sample_size == 0) {
296
        av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");
297
        return AVERROR(EINVAL);
298
    }
299

    
300
    n = avctx->channels * sample_size;
301

    
302
    if(n && buf_size % n){
303
        if (buf_size < n) {
304
            av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");
305
            return -1;
306
        }else
307
            buf_size -= buf_size % n;
308
    }
309

    
310
    buf_size= FFMIN(buf_size, *data_size/2);
311
    *data_size=0;
312

    
313
    n = buf_size/sample_size;
314

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

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

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

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

    
506
#define PCM_CODEC(id, sample_fmt_, name, long_name_)         \
507
    PCM_ENCODER(id,sample_fmt_,name,long_name_); PCM_DECODER(id,sample_fmt_,name,long_name_)
508

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