adxdec.c 4.46 KB
Newer Older
1 2 3 4
/*
 * ADX ADPCM codecs
 * Copyright (c) 2001,2003 BERO
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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
#include "adx.h"
23 24 25 26 27 28 29 30 31 32

/**
 * @file adx.c
 * SEGA CRI adx codecs.
 *
 * Reference documents:
 * http://ku-www.ss.titech.ac.jp/~yatsushi/adx.html
 * adx2wav & wav2adx http://www.geocities.co.jp/Playtown/2004/
 */

33
static av_cold int adx_decode_init(AVCodecContext *avctx)
34 35 36 37 38
{
    avctx->sample_fmt = SAMPLE_FMT_S16;
    return 0;
}

39
/* 18 bytes <-> 32 samples */
40 41 42

static void adx_decode(short *out,const unsigned char *in,PREV *prev)
{
43
    int scale = AV_RB16(in);
44 45 46 47 48 49 50 51 52 53 54 55 56 57
    int i;
    int s0,s1,s2,d;

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

    in+=2;
    s1 = prev->s1;
    s2 = prev->s2;
    for(i=0;i<16;i++) {
        d = in[i];
        // d>>=4; if (d&8) d-=16;
        d = ((signed char)d >> 4);
        s0 = (BASEVOL*d*scale + SCALE1*s1 - SCALE2*s2)>>14;
        s2 = s1;
58 59
        s1 = av_clip_int16(s0);
        *out++=s1;
60 61 62 63 64 65

        d = in[i];
        //d&=15; if (d&8) d-=16;
        d = ((signed char)(d<<4) >> 4);
        s0 = (BASEVOL*d*scale + SCALE1*s1 - SCALE2*s2)>>14;
        s2 = s1;
66 67
        s1 = av_clip_int16(s0);
        *out++=s1;
68 69 70
    }
    prev->s1 = s1;
    prev->s2 = s2;
71 72 73 74 75

}

static void adx_decode_stereo(short *out,const unsigned char *in,PREV *prev)
{
76 77 78 79 80 81 82 83 84
    short tmp[32*2];
    int i;

    adx_decode(tmp   ,in   ,prev);
    adx_decode(tmp+32,in+18,prev+1);
    for(i=0;i<32;i++) {
        out[i*2]   = tmp[i];
        out[i*2+1] = tmp[i+32];
    }
85 86
}

87 88
/* return data offset or 0 */
static int adx_decode_header(AVCodecContext *avctx,const unsigned char *buf,size_t bufsize)
89
{
90
    int offset;
91

92
    if (buf[0]!=0x80) return 0;
93
    offset = (AV_RB32(buf)^0x80000000)+4;
94
    if (bufsize<offset || memcmp(buf+offset-6,"(c)CRI",6)) return 0;
95

96 97 98
    avctx->channels    = buf[7];
    avctx->sample_rate = AV_RB32(buf+8);
    avctx->bit_rate    = avctx->sample_rate*avctx->channels*18*8/32;
99

100
    return offset;
101 102 103
}

static int adx_decode_frame(AVCodecContext *avctx,
104
                void *data, int *data_size,
Michael Niedermayer's avatar
Michael Niedermayer committed
105
                const uint8_t *buf0, int buf_size)
106
{
107 108 109 110 111 112 113 114 115 116 117 118 119
    ADXContext *c = avctx->priv_data;
    short *samples = data;
    const uint8_t *buf = buf0;
    int rest = buf_size;

    if (!c->header_parsed) {
        int hdrsize = adx_decode_header(avctx,buf,rest);
        if (hdrsize==0) return -1;
        c->header_parsed = 1;
        buf  += hdrsize;
        rest -= hdrsize;
    }

120 121 122 123 124
    /* 18 bytes of data are expanded into 32*2 bytes of audio,
       so guard against buffer overflows */
    if(rest/18 > *data_size/64)
        rest = (*data_size/64) * 18;

125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
    if (c->in_temp) {
        int copysize = 18*avctx->channels - c->in_temp;
        memcpy(c->dec_temp+c->in_temp,buf,copysize);
        rest -= copysize;
        buf  += copysize;
        if (avctx->channels==1) {
            adx_decode(samples,c->dec_temp,c->prev);
            samples += 32;
        } else {
            adx_decode_stereo(samples,c->dec_temp,c->prev);
            samples += 32*2;
        }
    }
    //
    if (avctx->channels==1) {
        while(rest>=18) {
            adx_decode(samples,buf,c->prev);
            rest-=18;
            buf+=18;
            samples+=32;
        }
    } else {
        while(rest>=18*2) {
            adx_decode_stereo(samples,buf,c->prev);
            rest-=18*2;
            buf+=18*2;
            samples+=32*2;
        }
    }
    //
    c->in_temp = rest;
    if (rest) {
        memcpy(c->dec_temp,buf,rest);
        buf+=rest;
    }
    *data_size = (uint8_t*)samples - (uint8_t*)data;
//    printf("%d:%d ",buf-buf0,*data_size); fflush(stdout);
    return buf-buf0;
163 164
}

165 166
AVCodec adpcm_adx_decoder = {
    "adpcm_adx",
167 168 169
    CODEC_TYPE_AUDIO,
    CODEC_ID_ADPCM_ADX,
    sizeof(ADXContext),
170
    adx_decode_init,
171 172 173
    NULL,
    NULL,
    adx_decode_frame,
174
    .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX"),
175 176
};