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
22#include "libavutil/intreadwrite.h"
23#include "avcodec.h"
24#include "adx.h"
25
26/**
27 * @file libavcodec/adxenc.c
28 * SEGA CRI adx codecs.
29 *
30 * Reference documents:
31 * http://ku-www.ss.titech.ac.jp/~yatsushi/adx.html
32 * adx2wav & wav2adx http://www.geocities.co.jp/Playtown/2004/
33 */
34
35/* 18 bytes <-> 32 samples */
36
37static void adx_encode(unsigned char *adx,const short *wav,PREV *prev)
38{
39    int scale;
40    int i;
41    int s0,s1,s2,d;
42    int max=0;
43    int min=0;
44    int data[32];
45
46    s1 = prev->s1;
47    s2 = prev->s2;
48    for(i=0;i<32;i++) {
49        s0 = wav[i];
50        d = ((s0<<14) - SCALE1*s1 + SCALE2*s2)/BASEVOL;
51        data[i]=d;
52        if (max<d) max=d;
53        if (min>d) min=d;
54        s2 = s1;
55        s1 = s0;
56    }
57    prev->s1 = s1;
58    prev->s2 = s2;
59
60    /* -8..+7 */
61
62    if (max==0 && min==0) {
63        memset(adx,0,18);
64        return;
65    }
66
67    if (max/7>-min/8) scale = max/7;
68    else scale = -min/8;
69
70    if (scale==0) scale=1;
71
72    AV_WB16(adx, scale);
73
74    for(i=0;i<16;i++) {
75        adx[i+2] = ((data[i*2]/scale)<<4) | ((data[i*2+1]/scale)&0xf);
76    }
77}
78
79static int adx_encode_header(AVCodecContext *avctx,unsigned char *buf,size_t bufsize)
80{
81#if 0
82    struct {
83        uint32_t offset; /* 0x80000000 + sample start - 4 */
84        unsigned char unknown1[3]; /* 03 12 04 */
85        unsigned char channel; /* 1 or 2 */
86        uint32_t freq;
87        uint32_t size;
88        uint32_t unknown2; /* 01 f4 03 00 */
89        uint32_t unknown3; /* 00 00 00 00 */
90        uint32_t unknown4; /* 00 00 00 00 */
91
92    /* if loop
93        unknown3 00 15 00 01
94        unknown4 00 00 00 01
95        long loop_start_sample;
96        long loop_start_byte;
97        long loop_end_sample;
98        long loop_end_byte;
99        long
100    */
101    } adxhdr; /* big endian */
102    /* offset-6 "(c)CRI" */
103#endif
104    AV_WB32(buf+0x00,0x80000000|0x20);
105    AV_WB32(buf+0x04,0x03120400|avctx->channels);
106    AV_WB32(buf+0x08,avctx->sample_rate);
107    AV_WB32(buf+0x0c,0); /* FIXME: set after */
108    AV_WB32(buf+0x10,0x01040300);
109    AV_WB32(buf+0x14,0x00000000);
110    AV_WB32(buf+0x18,0x00000000);
111    memcpy(buf+0x1c,"\0\0(c)CRI",8);
112    return 0x20+4;
113}
114
115static av_cold int adx_encode_init(AVCodecContext *avctx)
116{
117    if (avctx->channels > 2)
118        return -1; /* only stereo or mono =) */
119    avctx->frame_size = 32;
120
121    avctx->coded_frame= avcodec_alloc_frame();
122    avctx->coded_frame->key_frame= 1;
123
124//    avctx->bit_rate = avctx->sample_rate*avctx->channels*18*8/32;
125
126    av_log(avctx, AV_LOG_DEBUG, "adx encode init\n");
127
128    return 0;
129}
130
131static av_cold int adx_encode_close(AVCodecContext *avctx)
132{
133    av_freep(&avctx->coded_frame);
134
135    return 0;
136}
137
138static int adx_encode_frame(AVCodecContext *avctx,
139                uint8_t *frame, int buf_size, void *data)
140{
141    ADXContext *c = avctx->priv_data;
142    const short *samples = data;
143    unsigned char *dst = frame;
144    int rest = avctx->frame_size;
145
146/*
147    input data size =
148    ffmpeg.c: do_audio_out()
149    frame_bytes = enc->frame_size * 2 * enc->channels;
150*/
151
152//    printf("sz=%d ",buf_size); fflush(stdout);
153    if (!c->header_parsed) {
154        int hdrsize = adx_encode_header(avctx,dst,buf_size);
155        dst+=hdrsize;
156        c->header_parsed = 1;
157    }
158
159    if (avctx->channels==1) {
160        while(rest>=32) {
161            adx_encode(dst,samples,c->prev);
162            dst+=18;
163            samples+=32;
164            rest-=32;
165        }
166    } else {
167        while(rest>=32*2) {
168            short tmpbuf[32*2];
169            int i;
170
171            for(i=0;i<32;i++) {
172                tmpbuf[i] = samples[i*2];
173                tmpbuf[i+32] = samples[i*2+1];
174            }
175
176            adx_encode(dst,tmpbuf,c->prev);
177            adx_encode(dst+18,tmpbuf+32,c->prev+1);
178            dst+=18*2;
179            samples+=32*2;
180            rest-=32*2;
181        }
182    }
183    return dst-frame;
184}
185
186AVCodec adpcm_adx_encoder = {
187    "adpcm_adx",
188    CODEC_TYPE_AUDIO,
189    CODEC_ID_ADPCM_ADX,
190    sizeof(ADXContext),
191    adx_encode_init,
192    adx_encode_frame,
193    adx_encode_close,
194    NULL,
195    .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
196    .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
197};
198