← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/pcm.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/pcm.c
26
26
 
27
27
#include "avcodec.h"
28
28
#include "bitstream.h" // for ff_reverse
 
29
#include "bytestream.h"
 
30
 
 
31
#define MAX_CHANNELS 64
29
32
 
30
33
/* from g711.c by SUN microsystems (unrestricted use) */
31
34
 
41
44
 * alaw2linear() - Convert an A-law value to 16-bit linear PCM
42
45
 *
43
46
 */
44
 
static int alaw2linear(unsigned char a_val)
 
47
static av_cold int alaw2linear(unsigned char a_val)
45
48
{
46
49
        int t;
47
50
        int seg;
56
59
        return ((a_val & SIGN_BIT) ? t : -t);
57
60
}
58
61
 
59
 
static int ulaw2linear(unsigned char u_val)
 
62
static av_cold int ulaw2linear(unsigned char u_val)
60
63
{
61
64
        int t;
62
65
 
74
77
}
75
78
 
76
79
/* 16384 entries per table */
77
 
static uint8_t *linear_to_alaw = NULL;
78
 
static int linear_to_alaw_ref = 0;
79
 
 
80
 
static uint8_t *linear_to_ulaw = NULL;
81
 
static int linear_to_ulaw_ref = 0;
82
 
 
83
 
static void build_xlaw_table(uint8_t *linear_to_xlaw,
 
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
84
                             int (*xlaw2linear)(unsigned char),
85
85
                             int mask)
86
86
{
104
104
    linear_to_xlaw[0] = linear_to_xlaw[1];
105
105
}
106
106
 
107
 
static int pcm_encode_init(AVCodecContext *avctx)
 
107
static av_cold int pcm_encode_init(AVCodecContext *avctx)
108
108
{
109
109
    avctx->frame_size = 1;
110
110
    switch(avctx->codec->id) {
111
111
    case CODEC_ID_PCM_ALAW:
112
 
        if (linear_to_alaw_ref == 0) {
113
 
            linear_to_alaw = av_malloc(16384);
114
 
            if (!linear_to_alaw)
115
 
                return -1;
116
 
            build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);
117
 
        }
118
 
        linear_to_alaw_ref++;
 
112
        build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);
119
113
        break;
120
114
    case CODEC_ID_PCM_MULAW:
121
 
        if (linear_to_ulaw_ref == 0) {
122
 
            linear_to_ulaw = av_malloc(16384);
123
 
            if (!linear_to_ulaw)
124
 
                return -1;
125
 
            build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);
126
 
        }
127
 
        linear_to_ulaw_ref++;
 
115
        build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);
128
116
        break;
129
117
    default:
130
118
        break;
166
154
    return 0;
167
155
}
168
156
 
169
 
static int pcm_encode_close(AVCodecContext *avctx)
 
157
static av_cold int pcm_encode_close(AVCodecContext *avctx)
170
158
{
171
159
    av_freep(&avctx->coded_frame);
172
160
 
173
 
    switch(avctx->codec->id) {
174
 
    case CODEC_ID_PCM_ALAW:
175
 
        if (--linear_to_alaw_ref == 0)
176
 
            av_free(linear_to_alaw);
177
 
        break;
178
 
    case CODEC_ID_PCM_MULAW:
179
 
        if (--linear_to_ulaw_ref == 0)
180
 
            av_free(linear_to_ulaw);
181
 
        break;
182
 
    default:
183
 
        /* nothing to free */
184
 
        break;
185
 
    }
186
161
    return 0;
187
162
}
188
163
 
197
172
 */
198
173
static inline void encode_from16(int bps, int le, int us,
199
174
                               short **samples, uint8_t **dst, int n) {
 
175
    int usum = us ? 0x8000 : 0;
200
176
    if (bps > 2)
201
177
        memset(*dst, 0, n * bps);
202
178
    if (le) *dst += bps - 2;
203
179
    for(;n>0;n--) {
204
180
        register int v = *(*samples)++;
205
 
        if (us) v += 0x8000;
206
 
        (*dst)[le] = v >> 8;
207
 
        (*dst)[1 - le] = v;
 
181
        v += usum;
 
182
        if (le) AV_WL16(*dst, v);
 
183
        else    AV_WB16(*dst, v);
208
184
        *dst += bps;
209
185
    }
210
186
    if (le) *dst -= bps - 2;
275
251
            uint32_t tmp = ff_reverse[*samples >> 8] +
276
252
                           (ff_reverse[*samples & 0xff] << 8);
277
253
            tmp <<= 4; // sync flags would go here
278
 
            dst[2] = tmp & 0xff;
279
 
            tmp >>= 8;
280
 
            dst[1] = tmp & 0xff;
281
 
            dst[0] = tmp >> 8;
 
254
            bytestream_put_be24(&dst, tmp);
282
255
            samples++;
283
 
            dst += 3;
284
256
        }
285
257
        break;
286
258
    case CODEC_ID_PCM_S16LE:
287
259
        for(;n>0;n--) {
288
260
            v = *samples++;
289
 
            dst[0] = v & 0xff;
290
 
            dst[1] = v >> 8;
291
 
            dst += 2;
 
261
            bytestream_put_le16(&dst, v);
292
262
        }
293
263
        break;
294
264
    case CODEC_ID_PCM_S16BE:
295
265
        for(;n>0;n--) {
296
266
            v = *samples++;
297
 
            dst[0] = v >> 8;
298
 
            dst[1] = v;
299
 
            dst += 2;
 
267
            bytestream_put_be16(&dst, v);
300
268
        }
301
269
        break;
302
270
    case CODEC_ID_PCM_U16LE:
303
271
        for(;n>0;n--) {
304
272
            v = *samples++;
305
273
            v += 0x8000;
306
 
            dst[0] = v & 0xff;
307
 
            dst[1] = v >> 8;
308
 
            dst += 2;
 
274
            bytestream_put_le16(&dst, v);
309
275
        }
310
276
        break;
311
277
    case CODEC_ID_PCM_U16BE:
312
278
        for(;n>0;n--) {
313
279
            v = *samples++;
314
280
            v += 0x8000;
315
 
            dst[0] = v >> 8;
316
 
            dst[1] = v;
317
 
            dst += 2;
 
281
            bytestream_put_be16(&dst, v);
318
282
        }
319
283
        break;
320
284
    case CODEC_ID_PCM_S8:
321
285
        for(;n>0;n--) {
322
286
            v = *samples++;
323
 
            dst[0] = v >> 8;
324
 
            dst++;
 
287
            *dst++ = v >> 8;
325
288
        }
326
289
        break;
327
290
    case CODEC_ID_PCM_U8:
328
291
        for(;n>0;n--) {
329
292
            v = *samples++;
330
 
            dst[0] = (v >> 8) + 128;
331
 
            dst++;
 
293
            *dst++ = (v >> 8) + 128;
 
294
        }
 
295
        break;
 
296
    case CODEC_ID_PCM_ZORK:
 
297
        for(;n>0;n--) {
 
298
            v= *samples++ >> 8;
 
299
            if(v<0)   v = -v;
 
300
            else      v+= 128;
 
301
            *dst++ = v;
332
302
        }
333
303
        break;
334
304
    case CODEC_ID_PCM_ALAW:
335
305
        for(;n>0;n--) {
336
306
            v = *samples++;
337
 
            dst[0] = linear_to_alaw[(v + 32768) >> 2];
338
 
            dst++;
 
307
            *dst++ = linear_to_alaw[(v + 32768) >> 2];
339
308
        }
340
309
        break;
341
310
    case CODEC_ID_PCM_MULAW:
342
311
        for(;n>0;n--) {
343
312
            v = *samples++;
344
 
            dst[0] = linear_to_ulaw[(v + 32768) >> 2];
345
 
            dst++;
 
313
            *dst++ = linear_to_ulaw[(v + 32768) >> 2];
346
314
        }
347
315
        break;
348
316
    default:
357
325
    short table[256];
358
326
} PCMDecode;
359
327
 
360
 
static int pcm_decode_init(AVCodecContext * avctx)
 
328
static av_cold int pcm_decode_init(AVCodecContext * avctx)
361
329
{
362
330
    PCMDecode *s = avctx->priv_data;
363
331
    int i;
387
355
 * \param src_len number of bytes in src
388
356
 */
389
357
static inline void decode_to16(int bps, int le, int us,
390
 
                               uint8_t **src, short **samples, int src_len)
 
358
                               const uint8_t **src, short **samples, int src_len)
391
359
{
 
360
    int usum = us ? -0x8000 : 0;
392
361
    register int n = src_len / bps;
393
362
    if (le) *src += bps - 2;
394
363
    for(;n>0;n--) {
395
 
        *(*samples)++ = ((*src)[le] << 8 | (*src)[1 - le]) - (us?0x8000:0);
 
364
        register int v;
 
365
        if (le) v = AV_RL16(*src);
 
366
        else    v = AV_RB16(*src);
 
367
        v += usum;
 
368
        *(*samples)++ = v;
396
369
        *src += bps;
397
370
    }
398
371
    if (le) *src -= bps - 2;
400
373
 
401
374
static int pcm_decode_frame(AVCodecContext *avctx,
402
375
                            void *data, int *data_size,
403
 
                            uint8_t *buf, int buf_size)
 
376
                            const uint8_t *buf, int buf_size)
404
377
{
405
378
    PCMDecode *s = avctx->priv_data;
406
 
    int n;
 
379
    int c, n;
407
380
    short *samples;
408
 
    uint8_t *src;
 
381
    const uint8_t *src, *src2[MAX_CHANNELS];
409
382
 
410
383
    samples = data;
411
384
    src = buf;
415
388
        av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");
416
389
        return -1;
417
390
    }
 
391
    if(avctx->channels <= 0 || avctx->channels > MAX_CHANNELS){
 
392
        av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");
 
393
        return -1;
 
394
    }
418
395
 
419
396
    buf_size= FFMIN(buf_size, *data_size/2);
420
397
    *data_size=0;
421
398
 
 
399
    n = buf_size/avctx->channels;
 
400
    for(c=0;c<avctx->channels;c++)
 
401
        src2[c] = &src[c*n];
 
402
 
422
403
    switch(avctx->codec->id) {
423
404
    case CODEC_ID_PCM_S32LE:
424
405
        decode_to16(4, 1, 0, &src, &samples, buf_size);
447
428
    case CODEC_ID_PCM_S24DAUD:
448
429
        n = buf_size / 3;
449
430
        for(;n>0;n--) {
450
 
          uint32_t v = src[0] << 16 | src[1] << 8 | src[2];
 
431
          uint32_t v = bytestream_get_be24(&src);
451
432
          v >>= 4; // sync flags are here
452
433
          *samples++ = ff_reverse[(v >> 8) & 0xff] +
453
434
                       (ff_reverse[v & 0xff] << 8);
454
 
          src += 3;
455
435
        }
456
436
        break;
457
437
    case CODEC_ID_PCM_S16LE:
458
438
        n = buf_size >> 1;
459
439
        for(;n>0;n--) {
460
 
            *samples++ = src[0] | (src[1] << 8);
461
 
            src += 2;
 
440
            *samples++ = bytestream_get_le16(&src);
462
441
        }
463
442
        break;
 
443
    case CODEC_ID_PCM_S16LE_PLANAR:
 
444
        for(n>>=1;n>0;n--)
 
445
            for(c=0;c<avctx->channels;c++)
 
446
                *samples++ = bytestream_get_le16(&src2[c]);
 
447
        src = src2[avctx->channels-1];
 
448
        break;
464
449
    case CODEC_ID_PCM_S16BE:
465
450
        n = buf_size >> 1;
466
451
        for(;n>0;n--) {
467
 
            *samples++ = (src[0] << 8) | src[1];
468
 
            src += 2;
 
452
            *samples++ = bytestream_get_be16(&src);
469
453
        }
470
454
        break;
471
455
    case CODEC_ID_PCM_U16LE:
472
456
        n = buf_size >> 1;
473
457
        for(;n>0;n--) {
474
 
            *samples++ = (src[0] | (src[1] << 8)) - 0x8000;
475
 
            src += 2;
 
458
            *samples++ = bytestream_get_le16(&src) - 0x8000;
476
459
        }
477
460
        break;
478
461
    case CODEC_ID_PCM_U16BE:
479
462
        n = buf_size >> 1;
480
463
        for(;n>0;n--) {
481
 
            *samples++ = ((src[0] << 8) | src[1]) - 0x8000;
482
 
            src += 2;
 
464
            *samples++ = bytestream_get_be16(&src) - 0x8000;
483
465
        }
484
466
        break;
485
467
    case CODEC_ID_PCM_S8:
486
468
        n = buf_size;
487
469
        for(;n>0;n--) {
488
 
            *samples++ = src[0] << 8;
489
 
            src++;
 
470
            *samples++ = *src++ << 8;
490
471
        }
491
472
        break;
492
473
    case CODEC_ID_PCM_U8:
493
474
        n = buf_size;
494
475
        for(;n>0;n--) {
495
 
            *samples++ = ((int)src[0] - 128) << 8;
496
 
            src++;
 
476
            *samples++ = ((int)*src++ - 128) << 8;
 
477
        }
 
478
        break;
 
479
    case CODEC_ID_PCM_ZORK:
 
480
        n = buf_size;
 
481
        for(;n>0;n--) {
 
482
            int x= *src++;
 
483
            if(x&128) x-= 128;
 
484
            else      x = -x;
 
485
            *samples++ = x << 8;
497
486
        }
498
487
        break;
499
488
    case CODEC_ID_PCM_ALAW:
500
489
    case CODEC_ID_PCM_MULAW:
501
490
        n = buf_size;
502
491
        for(;n>0;n--) {
503
 
            *samples++ = s->table[src[0]];
504
 
            src++;
 
492
            *samples++ = s->table[*src++];
505
493
        }
506
494
        break;
507
495
    default:
511
499
    return src - buf;
512
500
}
513
501
 
514
 
#define PCM_CODEC(id, name)                     \
 
502
#ifdef CONFIG_ENCODERS
 
503
#define PCM_ENCODER(id,name)                    \
515
504
AVCodec name ## _encoder = {                    \
516
505
    #name,                                      \
517
506
    CODEC_TYPE_AUDIO,                           \
521
510
    pcm_encode_frame,                           \
522
511
    pcm_encode_close,                           \
523
512
    NULL,                                       \
524
 
};                                              \
 
513
};
 
514
#else
 
515
#define PCM_ENCODER(id,name)
 
516
#endif
 
517
 
 
518
#ifdef CONFIG_DECODERS
 
519
#define PCM_DECODER(id,name)                    \
525
520
AVCodec name ## _decoder = {                    \
526
521
    #name,                                      \
527
522
    CODEC_TYPE_AUDIO,                           \
531
526
    NULL,                                       \
532
527
    NULL,                                       \
533
528
    pcm_decode_frame,                           \
534
 
}
535
 
 
536
 
PCM_CODEC(CODEC_ID_PCM_S32LE, pcm_s32le);
537
 
PCM_CODEC(CODEC_ID_PCM_S32BE, pcm_s32be);
538
 
PCM_CODEC(CODEC_ID_PCM_U32LE, pcm_u32le);
539
 
PCM_CODEC(CODEC_ID_PCM_U32BE, pcm_u32be);
540
 
PCM_CODEC(CODEC_ID_PCM_S24LE, pcm_s24le);
541
 
PCM_CODEC(CODEC_ID_PCM_S24BE, pcm_s24be);
542
 
PCM_CODEC(CODEC_ID_PCM_U24LE, pcm_u24le);
543
 
PCM_CODEC(CODEC_ID_PCM_U24BE, pcm_u24be);
544
 
PCM_CODEC(CODEC_ID_PCM_S24DAUD, pcm_s24daud);
545
 
PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
546
 
PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
547
 
PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
548
 
PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
549
 
PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
550
 
PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
551
 
PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
552
 
PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
553
 
 
554
 
#undef PCM_CODEC
 
529
};
 
530
#else
 
531
#define PCM_DECODER(id,name)
 
532
#endif
 
533
 
 
534
#define PCM_CODEC(id, name)                     \
 
535
PCM_ENCODER(id,name) PCM_DECODER(id,name)
 
536
 
 
537
PCM_CODEC  (CODEC_ID_PCM_ALAW, pcm_alaw);
 
538
PCM_CODEC  (CODEC_ID_PCM_MULAW, pcm_mulaw);
 
539
PCM_CODEC  (CODEC_ID_PCM_S8, pcm_s8);
 
540
PCM_CODEC  (CODEC_ID_PCM_S16BE, pcm_s16be);
 
541
PCM_CODEC  (CODEC_ID_PCM_S16LE, pcm_s16le);
 
542
PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, pcm_s16le_planar);
 
543
PCM_CODEC  (CODEC_ID_PCM_S24BE, pcm_s24be);
 
544
PCM_CODEC  (CODEC_ID_PCM_S24DAUD, pcm_s24daud);
 
545
PCM_CODEC  (CODEC_ID_PCM_S24LE, pcm_s24le);
 
546
PCM_CODEC  (CODEC_ID_PCM_S32BE, pcm_s32be);
 
547
PCM_CODEC  (CODEC_ID_PCM_S32LE, pcm_s32le);
 
548
PCM_CODEC  (CODEC_ID_PCM_U8, pcm_u8);
 
549
PCM_CODEC  (CODEC_ID_PCM_U16BE, pcm_u16be);
 
550
PCM_CODEC  (CODEC_ID_PCM_U16LE, pcm_u16le);
 
551
PCM_CODEC  (CODEC_ID_PCM_U24BE, pcm_u24be);
 
552
PCM_CODEC  (CODEC_ID_PCM_U24LE, pcm_u24le);
 
553
PCM_CODEC  (CODEC_ID_PCM_U32BE, pcm_u32be);
 
554
PCM_CODEC  (CODEC_ID_PCM_U32LE, pcm_u32le);
 
555
PCM_CODEC  (CODEC_ID_PCM_ZORK, pcm_zork);