Statistics
| Branch: | Revision:

ffmpeg / libavcodec / adx.c @ ad1ea1f1

History | View | Annotate | Download (9.52 KB)

1
/*
2
 * ADX ADPCM codecs
3
 * Copyright (c) 2001,2003 BERO
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
#include "avcodec.h"
22

    
23
/**
24
 * @file adx.c
25
 * SEGA CRI adx codecs.
26
 *
27
 * Reference documents:
28
 * http://ku-www.ss.titech.ac.jp/~yatsushi/adx.html
29
 * adx2wav & wav2adx http://www.geocities.co.jp/Playtown/2004/
30
 */
31

    
32
typedef struct {
33
    int s1,s2;
34
} PREV;
35

    
36
typedef struct {
37
    PREV prev[2];
38
    int header_parsed;
39
    unsigned char dec_temp[18*2];
40
    unsigned short enc_temp[32*2];
41
    int in_temp;
42
} ADXContext;
43

    
44
//#define    BASEVOL    0x11e0
45
#define    BASEVOL   0x4000
46
#define    SCALE1    0x7298
47
#define    SCALE2    0x3350
48

    
49
#define    CLIP(s)    if (s>32767) s=32767; else if (s<-32768) s=-32768
50

    
51
/* 18 bytes <-> 32 samples */
52

    
53
#ifdef CONFIG_ENCODERS
54
static void adx_encode(unsigned char *adx,const short *wav,PREV *prev)
55
{
56
    int scale;
57
    int i;
58
    int s0,s1,s2,d;
59
    int max=0;
60
    int min=0;
61
    int data[32];
62

    
63
    s1 = prev->s1;
64
    s2 = prev->s2;
65
    for(i=0;i<32;i++) {
66
        s0 = wav[i];
67
        d = ((s0<<14) - SCALE1*s1 + SCALE2*s2)/BASEVOL;
68
        data[i]=d;
69
        if (max<d) max=d;
70
        if (min>d) min=d;
71
        s2 = s1;
72
        s1 = s0;
73
    }
74
    prev->s1 = s1;
75
    prev->s2 = s2;
76

    
77
    /* -8..+7 */
78

    
79
    if (max==0 && min==0) {
80
        memset(adx,0,18);
81
        return;
82
    }
83

    
84
    if (max/7>-min/8) scale = max/7;
85
    else scale = -min/8;
86

    
87
    if (scale==0) scale=1;
88

    
89
    adx[0] = scale>>8;
90
    adx[1] = scale;
91

    
92
    for(i=0;i<16;i++) {
93
        adx[i+2] = ((data[i*2]/scale)<<4) | ((data[i*2+1]/scale)&0xf);
94
    }
95
}
96
#endif //CONFIG_ENCODERS
97

    
98
static void adx_decode(short *out,const unsigned char *in,PREV *prev)
99
{
100
    int scale = ((in[0]<<8)|(in[1]));
101
    int i;
102
    int s0,s1,s2,d;
103

    
104
//    printf("%x ",scale);
105

    
106
    in+=2;
107
    s1 = prev->s1;
108
    s2 = prev->s2;
109
    for(i=0;i<16;i++) {
110
        d = in[i];
111
        // d>>=4; if (d&8) d-=16;
112
        d = ((signed char)d >> 4);
113
        s0 = (BASEVOL*d*scale + SCALE1*s1 - SCALE2*s2)>>14;
114
        CLIP(s0);
115
        *out++=s0;
116
        s2 = s1;
117
        s1 = s0;
118

    
119
        d = in[i];
120
        //d&=15; if (d&8) d-=16;
121
        d = ((signed char)(d<<4) >> 4);
122
        s0 = (BASEVOL*d*scale + SCALE1*s1 - SCALE2*s2)>>14;
123
        CLIP(s0);
124
        *out++=s0;
125
        s2 = s1;
126
        s1 = s0;
127
    }
128
    prev->s1 = s1;
129
    prev->s2 = s2;
130

    
131
}
132

    
133
static void adx_decode_stereo(short *out,const unsigned char *in,PREV *prev)
134
{
135
    short tmp[32*2];
136
    int i;
137

    
138
    adx_decode(tmp   ,in   ,prev);
139
    adx_decode(tmp+32,in+18,prev+1);
140
    for(i=0;i<32;i++) {
141
        out[i*2]   = tmp[i];
142
        out[i*2+1] = tmp[i+32];
143
    }
144
}
145

    
146
#ifdef CONFIG_ENCODERS
147

    
148
static void write_long(unsigned char *p,uint32_t v)
149
{
150
    p[0] = v>>24;
151
    p[1] = v>>16;
152
    p[2] = v>>8;
153
    p[3] = v;
154
}
155

    
156
static int adx_encode_header(AVCodecContext *avctx,unsigned char *buf,size_t bufsize)
157
{
158
#if 0
159
    struct {
160
        uint32_t offset; /* 0x80000000 + sample start - 4 */
161
        unsigned char unknown1[3]; /* 03 12 04 */
162
        unsigned char channel; /* 1 or 2 */
163
        uint32_t freq;
164
        uint32_t size;
165
        uint32_t unknown2; /* 01 f4 03 00 */
166
        uint32_t unknown3; /* 00 00 00 00 */
167
        uint32_t unknown4; /* 00 00 00 00 */
168

169
    /* if loop
170
        unknown3 00 15 00 01
171
        unknown4 00 00 00 01
172
        long loop_start_sample;
173
        long loop_start_byte;
174
        long loop_end_sample;
175
        long loop_end_byte;
176
        long
177
    */
178
    } adxhdr; /* big endian */
179
    /* offset-6 "(c)CRI" */
180
#endif
181
    write_long(buf+0x00,0x80000000|0x20);
182
    write_long(buf+0x04,0x03120400|avctx->channels);
183
    write_long(buf+0x08,avctx->sample_rate);
184
    write_long(buf+0x0c,0); /* FIXME: set after */
185
    write_long(buf+0x10,0x01040300);
186
    write_long(buf+0x14,0x00000000);
187
    write_long(buf+0x18,0x00000000);
188
    memcpy(buf+0x1c,"\0\0(c)CRI",8);
189
    return 0x20+4;
190
}
191

    
192
static int adx_decode_init(AVCodecContext *avctx);
193
static int adx_encode_init(AVCodecContext *avctx)
194
{
195
    if (avctx->channels > 2)
196
        return -1; /* only stereo or mono =) */
197
    avctx->frame_size = 32;
198

    
199
    avctx->coded_frame= avcodec_alloc_frame();
200
    avctx->coded_frame->key_frame= 1;
201

    
202
//    avctx->bit_rate = avctx->sample_rate*avctx->channels*18*8/32;
203

    
204
    av_log(avctx, AV_LOG_DEBUG, "adx encode init\n");
205
    adx_decode_init(avctx);
206

    
207
    return 0;
208
}
209

    
210
static int adx_encode_close(AVCodecContext *avctx)
211
{
212
    av_freep(&avctx->coded_frame);
213

    
214
    return 0;
215
}
216

    
217
static int adx_encode_frame(AVCodecContext *avctx,
218
                uint8_t *frame, int buf_size, void *data)
219
{
220
    ADXContext *c = avctx->priv_data;
221
    const short *samples = data;
222
    unsigned char *dst = frame;
223
    int rest = avctx->frame_size;
224

    
225
/*
226
    input data size =
227
    ffmpeg.c: do_audio_out()
228
    frame_bytes = enc->frame_size * 2 * enc->channels;
229
*/
230

    
231
//    printf("sz=%d ",buf_size); fflush(stdout);
232
    if (!c->header_parsed) {
233
        int hdrsize = adx_encode_header(avctx,dst,buf_size);
234
        dst+=hdrsize;
235
        c->header_parsed = 1;
236
    }
237

    
238
    if (avctx->channels==1) {
239
        while(rest>=32) {
240
            adx_encode(dst,samples,c->prev);
241
            dst+=18;
242
            samples+=32;
243
            rest-=32;
244
        }
245
    } else {
246
        while(rest>=32*2) {
247
            short tmpbuf[32*2];
248
            int i;
249

    
250
            for(i=0;i<32;i++) {
251
                tmpbuf[i] = samples[i*2];
252
                tmpbuf[i+32] = samples[i*2+1];
253
            }
254

    
255
            adx_encode(dst,tmpbuf,c->prev);
256
            adx_encode(dst+18,tmpbuf+32,c->prev+1);
257
            dst+=18*2;
258
            samples+=32*2;
259
            rest-=32*2;
260
        }
261
    }
262
    return dst-frame;
263
}
264

    
265
#endif //CONFIG_ENCODERS
266

    
267
static uint32_t read_long(const unsigned char *p)
268
{
269
    return (p[0]<<24)|(p[1]<<16)|(p[2]<<8)|p[3];
270
}
271

    
272
static int is_adx(const unsigned char *buf,size_t bufsize)
273
{
274
    int    offset;
275

    
276
    if (buf[0]!=0x80) return 0;
277
    offset = (read_long(buf)^0x80000000)+4;
278
    if (bufsize<offset || memcmp(buf+offset-6,"(c)CRI",6)) return 0;
279
    return offset;
280
}
281

    
282
/* return data offset or 6 */
283
static int adx_decode_header(AVCodecContext *avctx,const unsigned char *buf,size_t bufsize)
284
{
285
    int offset;
286
    int channels,freq,size;
287

    
288
    offset = is_adx(buf,bufsize);
289
    if (offset==0) return 0;
290

    
291
    channels = buf[7];
292
    freq = read_long(buf+8);
293
    size = read_long(buf+12);
294

    
295
//    printf("freq=%d ch=%d\n",freq,channels);
296

    
297
    avctx->sample_rate = freq;
298
    avctx->channels = channels;
299
    avctx->bit_rate = freq*channels*18*8/32;
300
//    avctx->frame_size = 18*channels;
301

    
302
    return offset;
303
}
304

    
305
static int adx_decode_init(AVCodecContext * avctx)
306
{
307
    ADXContext *c = avctx->priv_data;
308

    
309
//    printf("adx_decode_init\n"); fflush(stdout);
310
    c->prev[0].s1 = 0;
311
    c->prev[0].s2 = 0;
312
    c->prev[1].s1 = 0;
313
    c->prev[1].s2 = 0;
314
    c->header_parsed = 0;
315
    c->in_temp = 0;
316
    return 0;
317
}
318

    
319
#if 0
320
static void dump(unsigned char *buf,size_t len)
321
{
322
    int i;
323
    for(i=0;i<len;i++) {
324
        if ((i&15)==0) av_log(NULL, AV_LOG_DEBUG, "%04x  ",i);
325
        av_log(NULL, AV_LOG_DEBUG, "%02x ",buf[i]);
326
        if ((i&15)==15) av_log(NULL, AV_LOG_DEBUG, "\n");
327
    }
328
    av_log(NULL, AV_LOG_ERROR, "\n");
329
}
330
#endif
331

    
332
static int adx_decode_frame(AVCodecContext *avctx,
333
                void *data, int *data_size,
334
                uint8_t *buf0, int buf_size)
335
{
336
    ADXContext *c = avctx->priv_data;
337
    short *samples = data;
338
    const uint8_t *buf = buf0;
339
    int rest = buf_size;
340

    
341
    if (!c->header_parsed) {
342
        int hdrsize = adx_decode_header(avctx,buf,rest);
343
        if (hdrsize==0) return -1;
344
        c->header_parsed = 1;
345
        buf  += hdrsize;
346
        rest -= hdrsize;
347
    }
348

    
349
    if (c->in_temp) {
350
        int copysize = 18*avctx->channels - c->in_temp;
351
        memcpy(c->dec_temp+c->in_temp,buf,copysize);
352
        rest -= copysize;
353
        buf  += copysize;
354
        if (avctx->channels==1) {
355
            adx_decode(samples,c->dec_temp,c->prev);
356
            samples += 32;
357
        } else {
358
            adx_decode_stereo(samples,c->dec_temp,c->prev);
359
            samples += 32*2;
360
        }
361
    }
362
    //
363
    if (avctx->channels==1) {
364
        while(rest>=18) {
365
            adx_decode(samples,buf,c->prev);
366
            rest-=18;
367
            buf+=18;
368
            samples+=32;
369
        }
370
    } else {
371
        while(rest>=18*2) {
372
            adx_decode_stereo(samples,buf,c->prev);
373
            rest-=18*2;
374
            buf+=18*2;
375
            samples+=32*2;
376
        }
377
    }
378
    //
379
    c->in_temp = rest;
380
    if (rest) {
381
        memcpy(c->dec_temp,buf,rest);
382
        buf+=rest;
383
    }
384
    *data_size = (uint8_t*)samples - (uint8_t*)data;
385
//    printf("%d:%d ",buf-buf0,*data_size); fflush(stdout);
386
    return buf-buf0;
387
}
388

    
389
#ifdef CONFIG_ENCODERS
390
AVCodec adpcm_adx_encoder = {
391
    "adpcm_adx",
392
    CODEC_TYPE_AUDIO,
393
    CODEC_ID_ADPCM_ADX,
394
    sizeof(ADXContext),
395
    adx_encode_init,
396
    adx_encode_frame,
397
    adx_encode_close,
398
    NULL,
399
};
400
#endif //CONFIG_ENCODERS
401

    
402
AVCodec adpcm_adx_decoder = {
403
    "adpcm_adx",
404
    CODEC_TYPE_AUDIO,
405
    CODEC_ID_ADPCM_ADX,
406
    sizeof(ADXContext),
407
    adx_decode_init,
408
    NULL,
409
    NULL,
410
    adx_decode_frame,
411
};
412