GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/pcm.c Lines: 211 279 75.6 %
Date: 2019-11-20 04:07:19 Branches: 148 187 79.1 %

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 "libavutil/attributes.h"
28
#include "libavutil/float_dsp.h"
29
#include "avcodec.h"
30
#include "bytestream.h"
31
#include "internal.h"
32
#include "mathops.h"
33
#include "pcm_tablegen.h"
34
35
998
static av_cold int pcm_encode_init(AVCodecContext *avctx)
36
{
37
998
    avctx->frame_size = 0;
38

998
    switch (avctx->codec->id) {
39
6
    case AV_CODEC_ID_PCM_ALAW:
40
6
        pcm_alaw_tableinit();
41
6
        break;
42
2
    case AV_CODEC_ID_PCM_MULAW:
43
2
        pcm_ulaw_tableinit();
44
2
        break;
45
    case AV_CODEC_ID_PCM_VIDC:
46
        pcm_vidc_tableinit();
47
        break;
48
990
    default:
49
990
        break;
50
    }
51
52
998
    avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);
53
998
    avctx->block_align           = avctx->channels * avctx->bits_per_coded_sample / 8;
54
998
    avctx->bit_rate              = avctx->block_align * 8LL * avctx->sample_rate;
55
56
998
    return 0;
57
}
58
59
/**
60
 * Write PCM samples macro
61
 * @param type   Datatype of native machine format
62
 * @param endian bytestream_put_xxx() suffix
63
 * @param src    Source pointer (variable name)
64
 * @param dst    Destination pointer (variable name)
65
 * @param n      Total number of samples (variable name)
66
 * @param shift  Bitshift (bits)
67
 * @param offset Sample value offset
68
 */
69
#define ENCODE(type, endian, src, dst, n, shift, offset)                \
70
    samples_ ## type = (const type *) src;                              \
71
    for (; n > 0; n--) {                                                \
72
        register type v = (*samples_ ## type++ >> shift) + offset;      \
73
        bytestream_put_ ## endian(&dst, v);                             \
74
    }
75
76
#define ENCODE_PLANAR(type, endian, dst, n, shift, offset)              \
77
    n /= avctx->channels;                                               \
78
    for (c = 0; c < avctx->channels; c++) {                             \
79
        int i;                                                          \
80
        samples_ ## type = (const type *) frame->extended_data[c];      \
81
        for (i = n; i > 0; i--) {                                       \
82
            register type v = (*samples_ ## type++ >> shift) + offset;  \
83
            bytestream_put_ ## endian(&dst, v);                         \
84
        }                                                               \
85
    }
86
87
253761
static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
88
                            const AVFrame *frame, int *got_packet_ptr)
89
{
90
    int n, c, sample_size, v, ret;
91
    const short *samples;
92
    unsigned char *dst;
93
    const uint8_t *samples_uint8_t;
94
    const int16_t *samples_int16_t;
95
    const int32_t *samples_int32_t;
96
    const int64_t *samples_int64_t;
97
    const uint16_t *samples_uint16_t;
98
    const uint32_t *samples_uint32_t;
99
100
253761
    sample_size = av_get_bits_per_sample(avctx->codec->id) / 8;
101
253761
    n           = frame->nb_samples * avctx->channels;
102
253761
    samples     = (const short *)frame->data[0];
103
104
253761
    if ((ret = ff_alloc_packet2(avctx, avpkt, n * sample_size, n * sample_size)) < 0)
105
        return ret;
106
253761
    dst = avpkt->data;
107
108





253761
    switch (avctx->codec->id) {
109
259
    case AV_CODEC_ID_PCM_U32LE:
110
529459
        ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)
111
259
        break;
112
259
    case AV_CODEC_ID_PCM_U32BE:
113
529459
        ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)
114
259
        break;
115
5847
    case AV_CODEC_ID_PCM_S24LE:
116
39354433
        ENCODE(int32_t, le24, samples, dst, n, 8, 0)
117
5847
        break;
118
259
    case AV_CODEC_ID_PCM_S24LE_PLANAR:
119

529977
        ENCODE_PLANAR(int32_t, le24, dst, n, 8, 0)
120
259
        break;
121
259
    case AV_CODEC_ID_PCM_S24BE:
122
529459
        ENCODE(int32_t, be24, samples, dst, n, 8, 0)
123
259
        break;
124
259
    case AV_CODEC_ID_PCM_U24LE:
125
529459
        ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)
126
259
        break;
127
259
    case AV_CODEC_ID_PCM_U24BE:
128
529459
        ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)
129
259
        break;
130
20
    case AV_CODEC_ID_PCM_S24DAUD:
131
40940
        for (; n > 0; n--) {
132
40920
            uint32_t tmp = ff_reverse[(*samples >> 8) & 0xff] +
133
40920
                           (ff_reverse[*samples & 0xff] << 8);
134
40920
            tmp <<= 4; // sync flags would go here
135
40920
            bytestream_put_be24(&dst, tmp);
136
40920
            samples++;
137
        }
138
20
        break;
139
259
    case AV_CODEC_ID_PCM_U16LE:
140
529459
        ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)
141
259
        break;
142
259
    case AV_CODEC_ID_PCM_U16BE:
143
529459
        ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)
144
259
        break;
145
366
    case AV_CODEC_ID_PCM_S8:
146
7726634
        ENCODE(uint8_t, byte, samples, dst, n, 0, -128)
147
366
        break;
148
259
    case AV_CODEC_ID_PCM_S8_PLANAR:
149

529977
        ENCODE_PLANAR(uint8_t, byte, dst, n, 0, -128)
150
259
        break;
151
#if HAVE_BIGENDIAN
152
    case AV_CODEC_ID_PCM_S64LE:
153
    case AV_CODEC_ID_PCM_F64LE:
154
        ENCODE(int64_t, le64, samples, dst, n, 0, 0)
155
        break;
156
    case AV_CODEC_ID_PCM_S32LE:
157
    case AV_CODEC_ID_PCM_F32LE:
158
        ENCODE(int32_t, le32, samples, dst, n, 0, 0)
159
        break;
160
    case AV_CODEC_ID_PCM_S32LE_PLANAR:
161
        ENCODE_PLANAR(int32_t, le32, dst, n, 0, 0)
162
        break;
163
    case AV_CODEC_ID_PCM_S16LE:
164
        ENCODE(int16_t, le16, samples, dst, n, 0, 0)
165
        break;
166
    case AV_CODEC_ID_PCM_S16LE_PLANAR:
167
        ENCODE_PLANAR(int16_t, le16, dst, n, 0, 0)
168
        break;
169
    case AV_CODEC_ID_PCM_F64BE:
170
    case AV_CODEC_ID_PCM_F32BE:
171
    case AV_CODEC_ID_PCM_S64BE:
172
    case AV_CODEC_ID_PCM_S32BE:
173
    case AV_CODEC_ID_PCM_S16BE:
174
#else
175
259
    case AV_CODEC_ID_PCM_S64BE:
176
    case AV_CODEC_ID_PCM_F64BE:
177
529459
        ENCODE(int64_t, be64, samples, dst, n, 0, 0)
178
259
        break;
179
518
    case AV_CODEC_ID_PCM_F32BE:
180
    case AV_CODEC_ID_PCM_S32BE:
181
1058918
        ENCODE(int32_t, be32, samples, dst, n, 0, 0)
182
518
        break;
183
391
    case AV_CODEC_ID_PCM_S16BE:
184
661891
        ENCODE(int16_t, be16, samples, dst, n, 0, 0)
185
391
        break;
186
303
    case AV_CODEC_ID_PCM_S16BE_PLANAR:
187

618309
        ENCODE_PLANAR(int16_t, be16, dst, n, 0, 0)
188
303
        break;
189
242426
    case AV_CODEC_ID_PCM_F64LE:
190
    case AV_CODEC_ID_PCM_F32LE:
191
    case AV_CODEC_ID_PCM_S64LE:
192
    case AV_CODEC_ID_PCM_S32LE:
193
    case AV_CODEC_ID_PCM_S16LE:
194
#endif /* HAVE_BIGENDIAN */
195
    case AV_CODEC_ID_PCM_U8:
196
242426
        memcpy(dst, samples, n * sample_size);
197
242426
        break;
198
#if HAVE_BIGENDIAN
199
    case AV_CODEC_ID_PCM_S16BE_PLANAR:
200
#else
201
518
    case AV_CODEC_ID_PCM_S16LE_PLANAR:
202
    case AV_CODEC_ID_PCM_S32LE_PLANAR:
203
#endif /* HAVE_BIGENDIAN */
204
518
        n /= avctx->channels;
205
1554
        for (c = 0; c < avctx->channels; c++) {
206
1036
            const uint8_t *src = frame->extended_data[c];
207
1036
            bytestream_put_buffer(&dst, src, n * sample_size);
208
        }
209
518
        break;
210
479
    case AV_CODEC_ID_PCM_ALAW:
211
750179
        for (; n > 0; n--) {
212
749700
            v      = *samples++;
213
749700
            *dst++ = linear_to_alaw[(v + 32768) >> 2];
214
        }
215
479
        break;
216
303
    case AV_CODEC_ID_PCM_MULAW:
217
573603
        for (; n > 0; n--) {
218
573300
            v      = *samples++;
219
573300
            *dst++ = linear_to_ulaw[(v + 32768) >> 2];
220
        }
221
303
        break;
222
    case AV_CODEC_ID_PCM_VIDC:
223
        for (; n > 0; n--) {
224
            v      = *samples++;
225
            *dst++ = linear_to_vidc[(v + 32768) >> 2];
226
        }
227
        break;
228
    default:
229
        return -1;
230
    }
231
232
253761
    *got_packet_ptr = 1;
233
253761
    return 0;
234
}
235
236
typedef struct PCMDecode {
237
    short   table[256];
238
    AVFloatDSPContext *fdsp;
239
    float   scale;
240
} PCMDecode;
241
242
1443
static av_cold int pcm_decode_init(AVCodecContext *avctx)
243
{
244
1443
    PCMDecode *s = avctx->priv_data;
245
    int i;
246
247
1443
    if (avctx->channels <= 0) {
248
        av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
249
        return AVERROR(EINVAL);
250
    }
251
252

1443
    switch (avctx->codec_id) {
253
24
    case AV_CODEC_ID_PCM_ALAW:
254
6168
        for (i = 0; i < 256; i++)
255
6144
            s->table[i] = alaw2linear(i);
256
24
        break;
257
14
    case AV_CODEC_ID_PCM_MULAW:
258
3598
        for (i = 0; i < 256; i++)
259
3584
            s->table[i] = ulaw2linear(i);
260
14
        break;
261
    case AV_CODEC_ID_PCM_VIDC:
262
        for (i = 0; i < 256; i++)
263
            s->table[i] = vidc2linear(i);
264
        break;
265
    case AV_CODEC_ID_PCM_F16LE:
266
    case AV_CODEC_ID_PCM_F24LE:
267
        if (avctx->bits_per_coded_sample < 1 || avctx->bits_per_coded_sample > 24)
268
            return AVERROR_INVALIDDATA;
269
270
        s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));
271
        s->fdsp = avpriv_float_dsp_alloc(0);
272
        if (!s->fdsp)
273
            return AVERROR(ENOMEM);
274
        break;
275
1405
    default:
276
1405
        break;
277
    }
278
279
1443
    avctx->sample_fmt = avctx->codec->sample_fmts[0];
280
281
1443
    if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)
282
43
        avctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec_id);
283
284
1443
    return 0;
285
}
286
287
1443
static av_cold int pcm_decode_close(AVCodecContext *avctx)
288
{
289
1443
    PCMDecode *s = avctx->priv_data;
290
291
1443
    av_freep(&s->fdsp);
292
293
1443
    return 0;
294
}
295
296
/**
297
 * Read PCM samples macro
298
 * @param size   Data size of native machine format
299
 * @param endian bytestream_get_xxx() endian suffix
300
 * @param src    Source pointer (variable name)
301
 * @param dst    Destination pointer (variable name)
302
 * @param n      Total number of samples (variable name)
303
 * @param shift  Bitshift (bits)
304
 * @param offset Sample value offset
305
 */
306
#define DECODE(size, endian, src, dst, n, shift, offset)                       \
307
    for (; n > 0; n--) {                                                       \
308
        uint ## size ## _t v = bytestream_get_ ## endian(&src);                \
309
        AV_WN ## size ## A(dst, (uint ## size ## _t)(v - offset) << shift);    \
310
        dst += size / 8;                                                       \
311
    }
312
313
#define DECODE_PLANAR(size, endian, src, dst, n, shift, offset)                \
314
    n /= avctx->channels;                                                      \
315
    for (c = 0; c < avctx->channels; c++) {                                    \
316
        int i;                                                                 \
317
        dst = frame->extended_data[c];                                         \
318
        for (i = n; i > 0; i--) {                                              \
319
            uint ## size ## _t v = bytestream_get_ ## endian(&src);            \
320
            AV_WN ## size ## A(dst, (uint ## size ##_t)(v - offset) << shift); \
321
            dst += size / 8;                                                   \
322
        }                                                                      \
323
    }
324
325
76141
static int pcm_decode_frame(AVCodecContext *avctx, void *data,
326
                            int *got_frame_ptr, AVPacket *avpkt)
327
{
328
76141
    const uint8_t *src = avpkt->data;
329
76141
    int buf_size       = avpkt->size;
330
76141
    PCMDecode *s       = avctx->priv_data;
331
76141
    AVFrame *frame     = data;
332
    int sample_size, c, n, ret, samples_per_block;
333
    uint8_t *samples;
334
    int32_t *dst_int32_t;
335
336
76141
    sample_size = av_get_bits_per_sample(avctx->codec_id) / 8;
337
338
    /* av_get_bits_per_sample returns 0 for AV_CODEC_ID_PCM_DVD */
339
76141
    samples_per_block = 1;
340
76141
    if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {
341
        /* we process 40-bit blocks per channel for LXF */
342
        samples_per_block = 2;
343
        sample_size       = 5;
344
    }
345
346
76141
    if (sample_size == 0) {
347
        av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");
348
        return AVERROR(EINVAL);
349
    }
350
351
76141
    if (avctx->channels == 0) {
352
        av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
353
        return AVERROR(EINVAL);
354
    }
355
356
76141
    if (avctx->codec_id != avctx->codec->id) {
357
        av_log(avctx, AV_LOG_ERROR, "codec ids mismatch\n");
358
        return AVERROR(EINVAL);
359
    }
360
361
76141
    n = avctx->channels * sample_size;
362
363

76141
    if (n && buf_size % n) {
364
        if (buf_size < n) {
365
            av_log(avctx, AV_LOG_ERROR,
366
                   "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",
367
                   buf_size, n);
368
            return AVERROR_INVALIDDATA;
369
        } else
370
            buf_size -= buf_size % n;
371
    }
372
373
76141
    n = buf_size / sample_size;
374
375
    /* get output buffer */
376
76141
    frame->nb_samples = n * samples_per_block / avctx->channels;
377
76141
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
378
        return ret;
379
76141
    samples = frame->data[0];
380
381





76141
    switch (avctx->codec_id) {
382
259
    case AV_CODEC_ID_PCM_U32LE:
383
529459
        DECODE(32, le32, src, samples, n, 0, 0x80000000)
384
259
        break;
385
259
    case AV_CODEC_ID_PCM_U32BE:
386
529459
        DECODE(32, be32, src, samples, n, 0, 0x80000000)
387
259
        break;
388
14475
    case AV_CODEC_ID_PCM_S24LE:
389
19756559
        DECODE(32, le24, src, samples, n, 8, 0)
390
14475
        break;
391
259
    case AV_CODEC_ID_PCM_S24LE_PLANAR:
392

529977
        DECODE_PLANAR(32, le24, src, samples, n, 8, 0);
393
259
        break;
394
259
    case AV_CODEC_ID_PCM_S24BE:
395
529459
        DECODE(32, be24, src, samples, n, 8, 0)
396
259
        break;
397
259
    case AV_CODEC_ID_PCM_U24LE:
398
529459
        DECODE(32, le24, src, samples, n, 8, 0x800000)
399
259
        break;
400
259
    case AV_CODEC_ID_PCM_U24BE:
401
529459
        DECODE(32, be24, src, samples, n, 8, 0x800000)
402
259
        break;
403
20
    case AV_CODEC_ID_PCM_S24DAUD:
404
40940
        for (; n > 0; n--) {
405
40920
            uint32_t v = bytestream_get_be24(&src);
406
40920
            v >>= 4; // sync flags are here
407
40920
            AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +
408
                             (ff_reverse[v        & 0xff] << 8));
409
40920
            samples += 2;
410
        }
411
20
        break;
412
259
    case AV_CODEC_ID_PCM_U16LE:
413
529459
        DECODE(16, le16, src, samples, n, 0, 0x8000)
414
259
        break;
415
259
    case AV_CODEC_ID_PCM_U16BE:
416
529459
        DECODE(16, be16, src, samples, n, 0, 0x8000)
417
259
        break;
418
259
    case AV_CODEC_ID_PCM_S8:
419
529459
        for (; n > 0; n--)
420
529200
            *samples++ = *src++ + 128;
421
259
        break;
422
259
    case AV_CODEC_ID_PCM_S8_PLANAR:
423
259
        n /= avctx->channels;
424
777
        for (c = 0; c < avctx->channels; c++) {
425
            int i;
426
518
            samples = frame->extended_data[c];
427
529718
            for (i = n; i > 0; i--)
428
529200
                *samples++ = *src++ + 128;
429
        }
430
259
        break;
431
#if HAVE_BIGENDIAN
432
    case AV_CODEC_ID_PCM_S64LE:
433
    case AV_CODEC_ID_PCM_F64LE:
434
        DECODE(64, le64, src, samples, n, 0, 0)
435
        break;
436
    case AV_CODEC_ID_PCM_S32LE:
437
    case AV_CODEC_ID_PCM_F32LE:
438
    case AV_CODEC_ID_PCM_F24LE:
439
    case AV_CODEC_ID_PCM_F16LE:
440
        DECODE(32, le32, src, samples, n, 0, 0)
441
        break;
442
    case AV_CODEC_ID_PCM_S32LE_PLANAR:
443
        DECODE_PLANAR(32, le32, src, samples, n, 0, 0);
444
        break;
445
    case AV_CODEC_ID_PCM_S16LE:
446
        DECODE(16, le16, src, samples, n, 0, 0)
447
        break;
448
    case AV_CODEC_ID_PCM_S16LE_PLANAR:
449
        DECODE_PLANAR(16, le16, src, samples, n, 0, 0);
450
        break;
451
    case AV_CODEC_ID_PCM_F64BE:
452
    case AV_CODEC_ID_PCM_F32BE:
453
    case AV_CODEC_ID_PCM_S64BE:
454
    case AV_CODEC_ID_PCM_S32BE:
455
    case AV_CODEC_ID_PCM_S16BE:
456
#else
457
259
    case AV_CODEC_ID_PCM_S64BE:
458
    case AV_CODEC_ID_PCM_F64BE:
459
529459
        DECODE(64, be64, src, samples, n, 0, 0)
460
259
        break;
461
518
    case AV_CODEC_ID_PCM_F32BE:
462
    case AV_CODEC_ID_PCM_S32BE:
463
1058918
        DECODE(32, be32, src, samples, n, 0, 0)
464
518
        break;
465
1028
    case AV_CODEC_ID_PCM_S16BE:
466
1888842
        DECODE(16, be16, src, samples, n, 0, 0)
467
1028
        break;
468
303
    case AV_CODEC_ID_PCM_S16BE_PLANAR:
469

618309
        DECODE_PLANAR(16, be16, src, samples, n, 0, 0);
470
303
        break;
471
53440
    case AV_CODEC_ID_PCM_F64LE:
472
    case AV_CODEC_ID_PCM_F32LE:
473
    case AV_CODEC_ID_PCM_F24LE:
474
    case AV_CODEC_ID_PCM_F16LE:
475
    case AV_CODEC_ID_PCM_S64LE:
476
    case AV_CODEC_ID_PCM_S32LE:
477
    case AV_CODEC_ID_PCM_S16LE:
478
#endif /* HAVE_BIGENDIAN */
479
    case AV_CODEC_ID_PCM_U8:
480
53440
        memcpy(samples, src, n * sample_size);
481
53440
        break;
482
#if HAVE_BIGENDIAN
483
    case AV_CODEC_ID_PCM_S16BE_PLANAR:
484
#else
485
660
    case AV_CODEC_ID_PCM_S16LE_PLANAR:
486
    case AV_CODEC_ID_PCM_S32LE_PLANAR:
487
#endif /* HAVE_BIGENDIAN */
488
660
        n /= avctx->channels;
489
1980
        for (c = 0; c < avctx->channels; c++) {
490
1320
            samples = frame->extended_data[c];
491
1320
            bytestream_get_buffer(&src, samples, n * sample_size);
492
        }
493
660
        break;
494
    case AV_CODEC_ID_PCM_ZORK:
495
        for (; n > 0; n--) {
496
            int v = *src++;
497
            if (v < 128)
498
                v = 128 - v;
499
            *samples++ = v;
500
        }
501
        break;
502
2848
    case AV_CODEC_ID_PCM_ALAW:
503
    case AV_CODEC_ID_PCM_MULAW:
504
    case AV_CODEC_ID_PCM_VIDC:
505
4972036
        for (; n > 0; n--) {
506
4969188
            AV_WN16A(samples, s->table[*src++]);
507
4969188
            samples += 2;
508
        }
509
2848
        break;
510
    case AV_CODEC_ID_PCM_LXF:
511
    {
512
        int i;
513
        n /= avctx->channels;
514
        for (c = 0; c < avctx->channels; c++) {
515
            dst_int32_t = (int32_t *)frame->extended_data[c];
516
            for (i = 0; i < n; i++) {
517
                // extract low 20 bits and expand to 32 bits
518
                *dst_int32_t++ =  (src[2]         << 28) |
519
                                  (src[1]         << 20) |
520
                                  (src[0]         << 12) |
521
                                 ((src[2] & 0x0F) <<  8) |
522
                                   src[1];
523
                // extract high 20 bits and expand to 32 bits
524
                *dst_int32_t++ =  (src[4]         << 24) |
525
                                  (src[3]         << 16) |
526
                                 ((src[2] & 0xF0) <<  8) |
527
                                  (src[4]         <<  4) |
528
                                  (src[3]         >>  4);
529
                src += 5;
530
            }
531
        }
532
        break;
533
    }
534
    default:
535
        return -1;
536
    }
537
538
76141
    if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||
539
76141
        avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {
540
        s->fdsp->vector_fmul_scalar((float *)frame->extended_data[0],
541
                                    (const float *)frame->extended_data[0],
542
                                    s->scale, FFALIGN(frame->nb_samples * avctx->channels, 4));
543
        emms_c();
544
    }
545
546
76141
    *got_frame_ptr = 1;
547
548
76141
    return buf_size;
549
}
550
551
#define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)
552
#define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_)                  \
553
AVCodec ff_ ## name_ ## _encoder = {                                        \
554
    .name         = #name_,                                                 \
555
    .long_name    = NULL_IF_CONFIG_SMALL(long_name_),                       \
556
    .type         = AVMEDIA_TYPE_AUDIO,                                     \
557
    .id           = AV_CODEC_ID_ ## id_,                                    \
558
    .init         = pcm_encode_init,                                        \
559
    .encode2      = pcm_encode_frame,                                       \
560
    .capabilities = AV_CODEC_CAP_VARIABLE_FRAME_SIZE,                       \
561
    .sample_fmts  = (const enum AVSampleFormat[]){ sample_fmt_,             \
562
                                                   AV_SAMPLE_FMT_NONE },    \
563
}
564
565
#define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)                  \
566
    PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)
567
#define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name)                  \
568
    PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)
569
#define PCM_ENCODER(id, sample_fmt, name, long_name)                        \
570
    PCM_ENCODER_3(CONFIG_ ## id ## _ENCODER, id, sample_fmt, name, long_name)
571
572
#define PCM_DECODER_0(id, sample_fmt, name, long_name)
573
#define PCM_DECODER_1(id_, sample_fmt_, name_, long_name_)                  \
574
AVCodec ff_ ## name_ ## _decoder = {                                        \
575
    .name           = #name_,                                               \
576
    .long_name      = NULL_IF_CONFIG_SMALL(long_name_),                     \
577
    .type           = AVMEDIA_TYPE_AUDIO,                                   \
578
    .id             = AV_CODEC_ID_ ## id_,                                  \
579
    .priv_data_size = sizeof(PCMDecode),                                    \
580
    .init           = pcm_decode_init,                                      \
581
    .close          = pcm_decode_close,                                     \
582
    .decode         = pcm_decode_frame,                                     \
583
    .capabilities   = AV_CODEC_CAP_DR1,                                     \
584
    .sample_fmts    = (const enum AVSampleFormat[]){ sample_fmt_,           \
585
                                                     AV_SAMPLE_FMT_NONE },  \
586
}
587
588
#define PCM_DECODER_2(cf, id, sample_fmt, name, long_name)                  \
589
    PCM_DECODER_ ## cf(id, sample_fmt, name, long_name)
590
#define PCM_DECODER_3(cf, id, sample_fmt, name, long_name)                  \
591
    PCM_DECODER_2(cf, id, sample_fmt, name, long_name)
592
#define PCM_DECODER(id, sample_fmt, name, long_name)                        \
593
    PCM_DECODER_3(CONFIG_ ## id ## _DECODER, id, sample_fmt, name, long_name)
594
595
#define PCM_CODEC(id, sample_fmt_, name, long_name_)                    \
596
    PCM_ENCODER(id, sample_fmt_, name, long_name_);                     \
597
    PCM_DECODER(id, sample_fmt_, name, long_name_)
598
599
/* Note: Do not forget to add new entries to the Makefile as well. */
600
PCM_CODEC  (PCM_ALAW,         AV_SAMPLE_FMT_S16, pcm_alaw,         "PCM A-law / G.711 A-law");
601
PCM_DECODER(PCM_F16LE,        AV_SAMPLE_FMT_FLT, pcm_f16le,        "PCM 16.8 floating point little-endian");
602
PCM_DECODER(PCM_F24LE,        AV_SAMPLE_FMT_FLT, pcm_f24le,        "PCM 24.0 floating point little-endian");
603
PCM_CODEC  (PCM_F32BE,        AV_SAMPLE_FMT_FLT, pcm_f32be,        "PCM 32-bit floating point big-endian");
604
PCM_CODEC  (PCM_F32LE,        AV_SAMPLE_FMT_FLT, pcm_f32le,        "PCM 32-bit floating point little-endian");
605
PCM_CODEC  (PCM_F64BE,        AV_SAMPLE_FMT_DBL, pcm_f64be,        "PCM 64-bit floating point big-endian");
606
PCM_CODEC  (PCM_F64LE,        AV_SAMPLE_FMT_DBL, pcm_f64le,        "PCM 64-bit floating point little-endian");
607
PCM_DECODER(PCM_LXF,          AV_SAMPLE_FMT_S32P,pcm_lxf,          "PCM signed 20-bit little-endian planar");
608
PCM_CODEC  (PCM_MULAW,        AV_SAMPLE_FMT_S16, pcm_mulaw,        "PCM mu-law / G.711 mu-law");
609
PCM_CODEC  (PCM_S8,           AV_SAMPLE_FMT_U8,  pcm_s8,           "PCM signed 8-bit");
610
PCM_CODEC  (PCM_S8_PLANAR,    AV_SAMPLE_FMT_U8P, pcm_s8_planar,    "PCM signed 8-bit planar");
611
PCM_CODEC  (PCM_S16BE,        AV_SAMPLE_FMT_S16, pcm_s16be,        "PCM signed 16-bit big-endian");
612
PCM_CODEC  (PCM_S16BE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16be_planar, "PCM signed 16-bit big-endian planar");
613
PCM_CODEC  (PCM_S16LE,        AV_SAMPLE_FMT_S16, pcm_s16le,        "PCM signed 16-bit little-endian");
614
PCM_CODEC  (PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16le_planar, "PCM signed 16-bit little-endian planar");
615
PCM_CODEC  (PCM_S24BE,        AV_SAMPLE_FMT_S32, pcm_s24be,        "PCM signed 24-bit big-endian");
616
PCM_CODEC  (PCM_S24DAUD,      AV_SAMPLE_FMT_S16, pcm_s24daud,      "PCM D-Cinema audio signed 24-bit");
617
PCM_CODEC  (PCM_S24LE,        AV_SAMPLE_FMT_S32, pcm_s24le,        "PCM signed 24-bit little-endian");
618
PCM_CODEC  (PCM_S24LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s24le_planar, "PCM signed 24-bit little-endian planar");
619
PCM_CODEC  (PCM_S32BE,        AV_SAMPLE_FMT_S32, pcm_s32be,        "PCM signed 32-bit big-endian");
620
PCM_CODEC  (PCM_S32LE,        AV_SAMPLE_FMT_S32, pcm_s32le,        "PCM signed 32-bit little-endian");
621
PCM_CODEC  (PCM_S32LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s32le_planar, "PCM signed 32-bit little-endian planar");
622
PCM_CODEC  (PCM_U8,           AV_SAMPLE_FMT_U8,  pcm_u8,           "PCM unsigned 8-bit");
623
PCM_CODEC  (PCM_U16BE,        AV_SAMPLE_FMT_S16, pcm_u16be,        "PCM unsigned 16-bit big-endian");
624
PCM_CODEC  (PCM_U16LE,        AV_SAMPLE_FMT_S16, pcm_u16le,        "PCM unsigned 16-bit little-endian");
625
PCM_CODEC  (PCM_U24BE,        AV_SAMPLE_FMT_S32, pcm_u24be,        "PCM unsigned 24-bit big-endian");
626
PCM_CODEC  (PCM_U24LE,        AV_SAMPLE_FMT_S32, pcm_u24le,        "PCM unsigned 24-bit little-endian");
627
PCM_CODEC  (PCM_U32BE,        AV_SAMPLE_FMT_S32, pcm_u32be,        "PCM unsigned 32-bit big-endian");
628
PCM_CODEC  (PCM_U32LE,        AV_SAMPLE_FMT_S32, pcm_u32le,        "PCM unsigned 32-bit little-endian");
629
PCM_DECODER(PCM_ZORK,         AV_SAMPLE_FMT_U8,  pcm_zork,         "PCM Zork");
630
PCM_CODEC  (PCM_S64BE,        AV_SAMPLE_FMT_S64, pcm_s64be,        "PCM signed 64-bit big-endian");
631
PCM_CODEC  (PCM_S64LE,        AV_SAMPLE_FMT_S64, pcm_s64le,        "PCM signed 64-bit little-endian");
632
PCM_CODEC  (PCM_VIDC,         AV_SAMPLE_FMT_S16, pcm_vidc,         "PCM Archimedes VIDC");