Add support for VDPAU video out, including hardware decoding.
[mplayer/glamo.git] / libmpcodecs / ad_imaadpcm.c
bloba85cc680998e88be4dc9b831b29c76eba7343ab9
1 /*
2 IMA ADPCM Decoder for MPlayer
3 by Mike Melanson
5 This file is in charge of decoding all of the various IMA ADPCM data
6 formats that various entities have created. Details about the data
7 formats can be found here:
8 http://www.pcisys.net/~melanson/codecs/
10 So far, this file handles these formats:
11 'ima4': IMA ADPCM found in QT files
12 0x11: IMA ADPCM found in MS AVI/ASF/WAV files
13 0x61: DK4 ADPCM found in certain AVI files on Sega Saturn CD-ROMs;
14 note that this is a 'rogue' format number in that it was
15 never officially registered with Microsoft
16 0x1100736d: IMA ADPCM coded like in MS AVI/ASF/WAV found in QT files
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <inttypes.h>
24 #include "config.h"
25 #include "libavutil/common.h"
26 #include "mpbswap.h"
27 #include "ad_internal.h"
29 #define MS_IMA_ADPCM_PREAMBLE_SIZE 4
31 #define QT_IMA_ADPCM_PREAMBLE_SIZE 2
32 #define QT_IMA_ADPCM_BLOCK_SIZE 0x22
33 #define QT_IMA_ADPCM_SAMPLES_PER_BLOCK 64
35 #define BE_16(x) (be2me_16(*(unsigned short *)(x)))
36 #define LE_16(x) (le2me_16(*(unsigned short *)(x)))
38 // pertinent tables for IMA ADPCM
39 static const int16_t adpcm_step[89] =
41 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
42 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
43 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
44 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
45 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
46 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
47 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
48 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
49 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
52 static const int8_t adpcm_index[8] =
54 -1, -1, -1, -1, 2, 4, 6, 8,
57 // useful macros
58 // clamp a number between 0 and 88
59 #define CLAMP_0_TO_88(x) x = av_clip(x, 0, 88);
60 // clamp a number within a signed 16-bit range
61 #define CLAMP_S16(x) x = av_clip_int16(x);
62 // clamp a number above 16
63 #define CLAMP_ABOVE_16(x) if (x < 16) x = 16;
65 static ad_info_t info =
67 "IMA ADPCM audio decoder",
68 "imaadpcm",
69 "Nick Kurshev",
70 "Mike Melanson",
74 LIBAD_EXTERN(imaadpcm)
76 static int preinit(sh_audio_t *sh_audio)
78 // not exactly sure what this field is for
79 sh_audio->audio_out_minsize = 8192;
81 // if format is "ima4", assume the audio is coming from a QT file which
82 // indicates constant block size, whereas an AVI/ASF/WAV file will fill
83 // in this field with 0x11
84 if ((sh_audio->format == 0x11) || (sh_audio->format == 0x61) ||
85 (sh_audio->format == 0x1100736d))
87 sh_audio->ds->ss_div = (sh_audio->wf->nBlockAlign -
88 (MS_IMA_ADPCM_PREAMBLE_SIZE * sh_audio->wf->nChannels)) * 2;
89 sh_audio->ds->ss_mul = sh_audio->wf->nBlockAlign;
91 else
93 sh_audio->ds->ss_div = QT_IMA_ADPCM_SAMPLES_PER_BLOCK;
94 sh_audio->ds->ss_mul = QT_IMA_ADPCM_BLOCK_SIZE * sh_audio->wf->nChannels;
96 sh_audio->audio_in_minsize=sh_audio->ds->ss_mul;
97 return 1;
100 static int init(sh_audio_t *sh_audio)
102 /* IMA-ADPCM 4:1 audio codec:*/
103 sh_audio->channels=sh_audio->wf->nChannels;
104 sh_audio->samplerate=sh_audio->wf->nSamplesPerSec;
105 /* decodes 34 byte -> 64 short*/
106 sh_audio->i_bps =
107 (sh_audio->ds->ss_mul * sh_audio->samplerate) / sh_audio->ds->ss_div;
108 sh_audio->samplesize=2;
110 return 1;
113 static void uninit(sh_audio_t *sh_audio)
117 static int control(sh_audio_t *sh_audio,int cmd,void* arg, ...)
119 if(cmd==ADCTRL_SKIP_FRAME){
120 demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,sh_audio->ds->ss_mul);
121 return CONTROL_TRUE;
123 return CONTROL_UNKNOWN;
126 static void decode_nibbles(unsigned short *output,
127 int output_size, int channels,
128 int predictor[2], int index[2])
130 int step[2];
131 int i;
132 int sign;
133 int delta;
134 int channel_number = 0;
136 step[0] = adpcm_step[index[0]];
137 step[1] = adpcm_step[index[1]];
139 for (i = 0; i < output_size; i++)
141 delta = output[i];
142 sign = delta & 8;
143 delta = delta & 7;
145 index[channel_number] += adpcm_index[delta];
146 CLAMP_0_TO_88(index[channel_number]);
148 delta = 2 * delta + 1;
149 if (sign) delta = -delta;
151 predictor[channel_number] += (delta * step[channel_number]) >> 3;
153 CLAMP_S16(predictor[channel_number]);
154 output[i] = predictor[channel_number];
155 step[channel_number] = adpcm_step[index[channel_number]];
157 // toggle channel
158 channel_number ^= channels - 1;
163 static int qt_ima_adpcm_decode_block(unsigned short *output,
164 unsigned char *input, int channels, int block_size)
166 int initial_predictor[2];
167 int initial_index[2];
168 int i;
170 if (channels != 1) channels = 2;
171 if (block_size < channels * QT_IMA_ADPCM_BLOCK_SIZE)
172 return -1;
174 for (i = 0; i < channels; i++) {
175 initial_index[i] = initial_predictor[i] = (int16_t)BE_16(&input[i * QT_IMA_ADPCM_BLOCK_SIZE]);
177 // mask, sign-extend, and clamp the predictor portion
178 initial_predictor[i] &= ~0x7F;
179 CLAMP_S16(initial_predictor[i]);
181 // mask and clamp the index portion
182 initial_index[i] &= 0x7F;
183 CLAMP_0_TO_88(initial_index[i]);
186 // break apart all of the nibbles in the block
187 if (channels == 1)
188 for (i = 0; i < QT_IMA_ADPCM_SAMPLES_PER_BLOCK / 2; i++)
190 output[i * 2 + 0] = input[2 + i] & 0x0F;
191 output[i * 2 + 1] = input[2 + i] >> 4;
193 else
194 for (i = 0; i < QT_IMA_ADPCM_SAMPLES_PER_BLOCK / 2; i++)
196 output[i * 4 + 0] = input[2 + i] & 0x0F;
197 output[i * 4 + 1] = input[2 + QT_IMA_ADPCM_BLOCK_SIZE + i] & 0x0F;
198 output[i * 4 + 2] = input[2 + i] >> 4;
199 output[i * 4 + 3] = input[2 + QT_IMA_ADPCM_BLOCK_SIZE + i] >> 4;
202 decode_nibbles(output,
203 QT_IMA_ADPCM_SAMPLES_PER_BLOCK * channels, channels,
204 initial_predictor, initial_index);
206 return QT_IMA_ADPCM_SAMPLES_PER_BLOCK * channels;
209 static int ms_ima_adpcm_decode_block(unsigned short *output,
210 unsigned char *input, int channels, int block_size)
212 int predictor[2];
213 int index[2];
214 int i;
215 int channel_counter;
216 int channel_index;
217 int channel_index_l;
218 int channel_index_r;
220 if (channels != 1) channels = 2;
221 if (block_size < MS_IMA_ADPCM_PREAMBLE_SIZE * channels)
222 return -1;
224 for (i = 0; i < channels; i++) {
225 predictor[i] = (int16_t)LE_16(&input[i * 4]);
226 index[i] = input[i * 4 + 2];
229 if (channels == 1)
230 for (i = 0;
231 i < (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels); i++)
233 output[i * 2 + 0] = input[MS_IMA_ADPCM_PREAMBLE_SIZE + i] & 0x0F;
234 output[i * 2 + 1] = input[MS_IMA_ADPCM_PREAMBLE_SIZE + i] >> 4;
236 else
238 // encoded as 8 nibbles (4 bytes) per channel; switch channel every
239 // 4th byte
240 channel_counter = 0;
241 channel_index_l = 0;
242 channel_index_r = 1;
243 channel_index = channel_index_l;
244 for (i = 0;
245 i < (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels); i++)
247 output[channel_index + 0] =
248 input[MS_IMA_ADPCM_PREAMBLE_SIZE * 2 + i] & 0x0F;
249 output[channel_index + 2] =
250 input[MS_IMA_ADPCM_PREAMBLE_SIZE * 2 + i] >> 4;
251 channel_index += 4;
252 channel_counter++;
253 if (channel_counter == 4)
255 channel_index_l = channel_index;
256 channel_index = channel_index_r;
258 else if (channel_counter == 8)
260 channel_index_r = channel_index;
261 channel_index = channel_index_l;
262 channel_counter = 0;
267 decode_nibbles(output,
268 (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2,
269 channels,
270 predictor, index);
272 return (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2;
275 static int dk4_ima_adpcm_decode_block(unsigned short *output,
276 unsigned char *input, int channels, int block_size)
278 int i;
279 int output_ptr;
280 int predictor[2];
281 int index[2];
283 if (channels != 1) channels = 2;
284 if (block_size < MS_IMA_ADPCM_PREAMBLE_SIZE * channels)
285 return -1;
287 for (i = 0; i < channels; i++) {
288 // the first predictor value goes straight to the output
289 predictor[i] = output[i] = (int16_t)LE_16(&input[i * 4]);
290 index[i] = input[i * 4 + 2];
293 output_ptr = channels;
294 for (i = MS_IMA_ADPCM_PREAMBLE_SIZE * channels; i < block_size; i++)
296 output[output_ptr++] = input[i] >> 4;
297 output[output_ptr++] = input[i] & 0x0F;
300 decode_nibbles(&output[channels],
301 (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2 - channels,
302 channels,
303 predictor, index);
305 return (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2 - channels;
308 static int decode_audio(sh_audio_t *sh_audio,unsigned char *buf,int minlen,int maxlen)
310 int res = -1;
311 int (*decode_func)(unsigned short *output, unsigned char *input, int channels, int block_size) = qt_ima_adpcm_decode_block;
312 if (demux_read_data(sh_audio->ds, sh_audio->a_in_buffer,
313 sh_audio->ds->ss_mul) !=
314 sh_audio->ds->ss_mul)
315 return -1;
317 if ((sh_audio->format == 0x11) || (sh_audio->format == 0x1100736d))
318 decode_func = ms_ima_adpcm_decode_block;
319 else if (sh_audio->format == 0x61)
320 decode_func = dk4_ima_adpcm_decode_block;
322 res = decode_func((unsigned short*)buf, sh_audio->a_in_buffer,
323 sh_audio->wf->nChannels, sh_audio->ds->ss_mul);
324 return res < 0 ? res : 2 * res;