codecs.conf: remove yuv422 format from VDPAU section
[mplayer/glamo.git] / libmpcodecs / ad_dk3adpcm.c
blob9ee168dc458cc6a19e9a6e44a698c28fcc76c808
1 /*
2 * DK3 ADPCM decoder
4 * "This format number was used by Duck Corp. but not officially
5 * registered with Microsoft"
7 * This file is responsible for decoding audio data encoded with
8 * Duck Corp's DK3 ADPCM algorithm. Details about the data format
9 * can be found here:
10 * http://www.pcisys.net/~melanson/codecs/
12 * Copyright (c) 2002 Mike Melanson
14 * This file is part of MPlayer.
16 * MPlayer is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
21 * MPlayer is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License along
27 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
28 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <unistd.h>
35 #include "config.h"
36 #include "mpbswap.h"
37 #include "ad_internal.h"
39 static const ad_info_t info =
41 "Duck Corp. DK3 ADPCM decoder",
42 "dk3adpcm",
43 "Nick Kurshev",
44 "Mike Melanson",
48 LIBAD_EXTERN(dk3adpcm)
50 #define DK3_ADPCM_PREAMBLE_SIZE 16
52 #define LE_16(x) (le2me_16(*(unsigned short *)(x)))
53 #define LE_32(x) (le2me_32(*(unsigned int *)(x)))
55 // useful macros
56 // clamp a number between 0 and 88
57 #define CLAMP_0_TO_88(x) if (x < 0) x = 0; else if (x > 88) x = 88;
58 // clamp a number within a signed 16-bit range
59 #define CLAMP_S16(x) if (x < -32768) x = -32768; \
60 else if (x > 32767) x = 32767;
61 // clamp a number above 16
62 #define CLAMP_ABOVE_16(x) if (x < 16) x = 16;
63 // sign extend a 16-bit value
64 #define SE_16BIT(x) if (x & 0x8000) x -= 0x10000;
65 // sign extend a 4-bit value
66 #define SE_4BIT(x) if (x & 0x8) x -= 0x10;
68 // pertinent tables
69 static int adpcm_step[89] =
71 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
72 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
73 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
74 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
75 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
76 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
77 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
78 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
79 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
82 static int adpcm_index[16] =
84 -1, -1, -1, -1, 2, 4, 6, 8,
85 -1, -1, -1, -1, 2, 4, 6, 8
88 static int preinit(sh_audio_t *sh_audio)
90 sh_audio->audio_out_minsize = sh_audio->wf->nBlockAlign * 6;
91 sh_audio->ds->ss_div =
92 (sh_audio->wf->nBlockAlign - DK3_ADPCM_PREAMBLE_SIZE) * 8 / 3;
93 sh_audio->audio_in_minsize=
94 sh_audio->ds->ss_mul = sh_audio->wf->nBlockAlign;
95 return 1;
98 static int init(sh_audio_t *sh_audio)
100 sh_audio->channels = sh_audio->wf->nChannels;
101 sh_audio->samplerate = sh_audio->wf->nSamplesPerSec;
102 sh_audio->i_bps =
103 (sh_audio->ds->ss_mul * sh_audio->samplerate) / sh_audio->ds->ss_div;
104 sh_audio->samplesize=2;
105 return 1;
108 static void uninit(sh_audio_t *sh_audio)
112 static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
114 if(cmd==ADCTRL_SKIP_FRAME){
115 demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
116 return CONTROL_TRUE;
118 return CONTROL_UNKNOWN;
121 #define DK3_GET_NEXT_NIBBLE() \
122 if (decode_top_nibble_next) \
124 nibble = (last_byte >> 4) & 0x0F; \
125 decode_top_nibble_next = 0; \
127 else \
129 last_byte = input[in_ptr++]; \
130 nibble = last_byte & 0x0F; \
131 decode_top_nibble_next = 1; \
134 // note: This decoder assumes the format 0x62 data always comes in
135 // stereo flavor
136 static int dk3_adpcm_decode_block(unsigned short *output, unsigned char *input,
137 int block_size)
139 int sum_pred;
140 int diff_pred;
141 int sum_index;
142 int diff_index;
143 int diff_channel;
144 int in_ptr = 0x10;
145 int out_ptr = 0;
147 unsigned char last_byte = 0;
148 unsigned char nibble;
149 int decode_top_nibble_next = 0;
151 // ADPCM work variables
152 int sign;
153 int delta;
154 int step;
155 int diff;
157 sum_pred = LE_16(&input[10]);
158 diff_pred = LE_16(&input[12]);
159 SE_16BIT(sum_pred);
160 SE_16BIT(diff_pred);
161 diff_channel = diff_pred;
162 sum_index = input[14];
163 diff_index = input[15];
165 while (in_ptr < block_size - !decode_top_nibble_next)
166 // while (in_ptr < 2048)
168 // process the first predictor of the sum channel
169 DK3_GET_NEXT_NIBBLE();
171 step = adpcm_step[sum_index];
173 sign = nibble & 8;
174 delta = nibble & 7;
176 diff = step >> 3;
177 if (delta & 4) diff += step;
178 if (delta & 2) diff += step >> 1;
179 if (delta & 1) diff += step >> 2;
181 if (sign)
182 sum_pred -= diff;
183 else
184 sum_pred += diff;
186 CLAMP_S16(sum_pred);
188 sum_index += adpcm_index[nibble];
189 CLAMP_0_TO_88(sum_index);
191 // process the diff channel predictor
192 DK3_GET_NEXT_NIBBLE();
194 step = adpcm_step[diff_index];
196 sign = nibble & 8;
197 delta = nibble & 7;
199 diff = step >> 3;
200 if (delta & 4) diff += step;
201 if (delta & 2) diff += step >> 1;
202 if (delta & 1) diff += step >> 2;
204 if (sign)
205 diff_pred -= diff;
206 else
207 diff_pred += diff;
209 CLAMP_S16(diff_pred);
211 diff_index += adpcm_index[nibble];
212 CLAMP_0_TO_88(diff_index);
214 // output the first pair of stereo PCM samples
215 diff_channel = (diff_channel + diff_pred) / 2;
216 output[out_ptr++] = sum_pred + diff_channel;
217 output[out_ptr++] = sum_pred - diff_channel;
219 // process the second predictor of the sum channel
220 DK3_GET_NEXT_NIBBLE();
222 step = adpcm_step[sum_index];
224 sign = nibble & 8;
225 delta = nibble & 7;
227 diff = step >> 3;
228 if (delta & 4) diff += step;
229 if (delta & 2) diff += step >> 1;
230 if (delta & 1) diff += step >> 2;
232 if (sign)
233 sum_pred -= diff;
234 else
235 sum_pred += diff;
237 CLAMP_S16(sum_pred);
239 sum_index += adpcm_index[nibble];
240 CLAMP_0_TO_88(sum_index);
242 // output the second pair of stereo PCM samples
243 output[out_ptr++] = sum_pred + diff_channel;
244 output[out_ptr++] = sum_pred - diff_channel;
247 return out_ptr;
250 static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
252 if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
253 sh_audio->ds->ss_mul) !=
254 sh_audio->ds->ss_mul)
255 return -1; /* EOF */
257 if (maxlen < 2 * 4 * sh_audio->wf->nBlockAlign * 2 / 3) {
258 mp_msg(MSGT_DECAUDIO, MSGL_V, "dk3adpcm: maxlen too small in decode_audio\n");
259 return -1;
261 return 2 * dk3_adpcm_decode_block(
262 (unsigned short*)buf, sh_audio->a_in_buffer,
263 sh_audio->ds->ss_mul);