1 /*****************************************************************************
2 * adpcm.c : adpcm variant audio decoder
3 *****************************************************************************
4 * Copyright (C) 2001, 2002 VideoLAN
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
22 *****************************************************************************/
24 /*****************************************************************************
27 * Documentation: http://www.pcisys.net/~melanson/codecs/adpcm.txt
28 *****************************************************************************/
30 #include <vlc/decoder.h>
32 /*****************************************************************************
34 *****************************************************************************/
35 static int OpenDecoder( vlc_object_t * );
36 static void CloseDecoder( vlc_object_t * );
38 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
41 set_description( _("ADPCM audio decoder") );
42 set_capability( "decoder", 50 );
43 set_category( CAT_INPUT );
44 set_subcategory( SUBCAT_INPUT_ACODEC );
45 set_callbacks( OpenDecoder, CloseDecoder );
48 /*****************************************************************************
50 *****************************************************************************/
62 enum adpcm_codec_e codec;
65 int i_samplesperblock;
67 audio_date_t end_date;
70 static void DecodeAdpcmMs ( decoder_t *, int16_t *, uint8_t * );
71 static void DecodeAdpcmImaWav( decoder_t *, int16_t *, uint8_t * );
72 static void DecodeAdpcmImaQT ( decoder_t *, int16_t *, uint8_t * );
73 static void DecodeAdpcmDk4 ( decoder_t *, int16_t *, uint8_t * );
74 static void DecodeAdpcmDk3 ( decoder_t *, int16_t *, uint8_t * );
76 static int pi_channels_maps[6] =
80 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
81 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER,
82 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT,
83 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
84 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT
87 /* Various table from http://www.pcisys.net/~melanson/codecs/adpcm.txt */
88 static int i_index_table[16] =
90 -1, -1, -1, -1, 2, 4, 6, 8,
91 -1, -1, -1, -1, 2, 4, 6, 8
94 static int i_step_table[89] =
96 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
97 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
98 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
99 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
100 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
101 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
102 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
103 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
104 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
107 static int i_adaptation_table[16] =
109 230, 230, 230, 230, 307, 409, 512, 614,
110 768, 614, 512, 409, 307, 230, 230, 230
113 static int i_adaptation_coeff1[7] =
115 256, 512, 0, 192, 240, 460, 392
118 static int i_adaptation_coeff2[7] =
120 0, -256, 0, 64, 0, -208, -232
123 /*****************************************************************************
124 * OpenDecoder: probe the decoder and return score
125 *****************************************************************************/
126 static int OpenDecoder( vlc_object_t *p_this )
128 decoder_t *p_dec = (decoder_t*)p_this;
129 decoder_sys_t *p_sys;
131 switch( p_dec->fmt_in.i_codec )
133 case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
134 case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
135 case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
136 case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
137 case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
143 /* Allocate the memory needed to store the decoder's structure */
144 if( ( p_dec->p_sys = p_sys =
145 (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
147 msg_Err( p_dec, "out of memory" );
151 if( p_dec->fmt_in.audio.i_channels <= 0 ||
152 p_dec->fmt_in.audio.i_channels > 5 )
154 msg_Err( p_dec, "bad channels count(1-5)" );
158 if( p_dec->fmt_in.audio.i_rate <= 0 )
160 msg_Err( p_dec, "bad samplerate" );
164 switch( p_dec->fmt_in.i_codec )
166 case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
167 p_sys->codec = ADPCM_IMA_QT;
169 case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
170 p_sys->codec = ADPCM_IMA_WAV;
172 case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
173 p_sys->codec = ADPCM_MS;
175 case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
176 p_sys->codec = ADPCM_DK4;
178 case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
179 p_sys->codec = ADPCM_DK3;
183 if( p_dec->fmt_in.audio.i_blockalign <= 0 )
185 p_sys->i_block = (p_sys->codec == ADPCM_IMA_QT) ?
186 34 * p_dec->fmt_in.audio.i_channels : 1024;
187 msg_Warn( p_dec, "block size undefined, using %d", p_sys->i_block );
191 p_sys->i_block = p_dec->fmt_in.audio.i_blockalign;
194 /* calculate samples per block */
195 switch( p_sys->codec )
198 p_sys->i_samplesperblock = 64;
201 p_sys->i_samplesperblock =
202 2 * ( p_sys->i_block - 4 * p_dec->fmt_in.audio.i_channels ) /
203 p_dec->fmt_in.audio.i_channels;
206 p_sys->i_samplesperblock =
207 2 * (p_sys->i_block - 7 * p_dec->fmt_in.audio.i_channels) /
208 p_dec->fmt_in.audio.i_channels + 2;
211 p_sys->i_samplesperblock =
212 2 * (p_sys->i_block - 4 * p_dec->fmt_in.audio.i_channels) /
213 p_dec->fmt_in.audio.i_channels + 1;
216 p_dec->fmt_in.audio.i_channels = 2;
217 p_sys->i_samplesperblock = ( 4 * ( p_sys->i_block - 16 ) + 2 )/ 3;
221 msg_Dbg( p_dec, "format: samplerate:%dHz channels:%d bits/sample:%d "
222 "blockalign:%d samplesperblock:%d",
223 p_dec->fmt_in.audio.i_rate, p_dec->fmt_in.audio.i_channels,
224 p_dec->fmt_in.audio.i_bitspersample, p_sys->i_block,
225 p_sys->i_samplesperblock );
227 p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
228 p_dec->fmt_out.audio.i_rate = p_dec->fmt_in.audio.i_rate;
229 p_dec->fmt_out.audio.i_channels = p_dec->fmt_in.audio.i_channels;
230 p_dec->fmt_out.audio.i_physical_channels =
231 p_dec->fmt_out.audio.i_original_channels =
232 pi_channels_maps[p_dec->fmt_in.audio.i_channels];
234 aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
235 aout_DateSet( &p_sys->end_date, 0 );
237 p_dec->pf_decode_audio = DecodeBlock;
242 /*****************************************************************************
244 *****************************************************************************/
245 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
247 decoder_sys_t *p_sys = p_dec->p_sys;
250 if( !pp_block || !*pp_block ) return NULL;
254 if( p_block->i_pts != 0 &&
255 p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
257 aout_DateSet( &p_sys->end_date, p_block->i_pts );
259 else if( !aout_DateGet( &p_sys->end_date ) )
261 /* We've just started the stream, wait for the first PTS. */
262 block_Release( p_block );
266 /* Don't re-use the same pts twice */
269 if( p_block->i_buffer >= p_sys->i_block )
271 aout_buffer_t *p_out;
273 p_out = p_dec->pf_aout_buffer_new( p_dec, p_sys->i_samplesperblock );
276 block_Release( p_block );
280 p_out->start_date = aout_DateGet( &p_sys->end_date );
282 aout_DateIncrement( &p_sys->end_date, p_sys->i_samplesperblock );
284 switch( p_sys->codec )
287 DecodeAdpcmImaQT( p_dec, (int16_t*)p_out->p_buffer,
291 DecodeAdpcmImaWav( p_dec, (int16_t*)p_out->p_buffer,
295 DecodeAdpcmMs( p_dec, (int16_t*)p_out->p_buffer,
299 DecodeAdpcmDk4( p_dec, (int16_t*)p_out->p_buffer,
303 DecodeAdpcmDk3( p_dec, (int16_t*)p_out->p_buffer,
310 p_block->p_buffer += p_sys->i_block;
311 p_block->i_buffer -= p_sys->i_block;
315 block_Release( p_block );
319 /*****************************************************************************
321 *****************************************************************************/
322 static void CloseDecoder( vlc_object_t *p_this )
324 decoder_t *p_dec = (decoder_t *)p_this;
325 decoder_sys_t *p_sys = p_dec->p_sys;
330 /*****************************************************************************
332 *****************************************************************************/
333 #define CLAMP( v, min, max ) \
334 if( (v) < (min) ) (v) = (min); \
335 if( (v) > (max) ) (v) = (max)
337 #define GetByte( v ) \
338 (v) = *p_buffer; p_buffer++;
340 #define GetWord( v ) \
341 (v) = *p_buffer; p_buffer++; \
342 (v) |= ( *p_buffer ) << 8; p_buffer++; \
343 if( (v)&0x8000 ) (v) -= 0x010000;
348 typedef struct adpcm_ms_channel_s
351 int i_sample1, i_sample2;
352 int i_coeff1, i_coeff2;
354 } adpcm_ms_channel_t;
357 static int AdpcmMsExpandNibble(adpcm_ms_channel_t *p_channel,
364 i_snibble = i_nibble - ( i_nibble&0x08 ? 0x10 : 0 );
366 i_predictor = ( p_channel->i_sample1 * p_channel->i_coeff1 +
367 p_channel->i_sample2 * p_channel->i_coeff2 ) / 256 +
368 i_snibble * p_channel->i_idelta;
370 CLAMP( i_predictor, -32768, 32767 );
372 p_channel->i_sample2 = p_channel->i_sample1;
373 p_channel->i_sample1 = i_predictor;
375 p_channel->i_idelta = ( i_adaptation_table[i_nibble] *
376 p_channel->i_idelta ) / 256;
377 if( p_channel->i_idelta < 16 )
379 p_channel->i_idelta = 16;
381 return( i_predictor );
384 static void DecodeAdpcmMs( decoder_t *p_dec, int16_t *p_sample,
387 decoder_sys_t *p_sys = p_dec->p_sys;
388 adpcm_ms_channel_t channel[2];
391 int i_block_predictor;
393 b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
395 GetByte( i_block_predictor );
396 CLAMP( i_block_predictor, 0, 6 );
397 channel[0].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
398 channel[0].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
402 GetByte( i_block_predictor );
403 CLAMP( i_block_predictor, 0, 6 );
404 channel[1].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
405 channel[1].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
407 GetWord( channel[0].i_idelta );
410 GetWord( channel[1].i_idelta );
413 GetWord( channel[0].i_sample1 );
416 GetWord( channel[1].i_sample1 );
419 GetWord( channel[0].i_sample2 );
422 GetWord( channel[1].i_sample2 );
427 *p_sample++ = channel[0].i_sample2;
428 *p_sample++ = channel[1].i_sample2;
429 *p_sample++ = channel[0].i_sample1;
430 *p_sample++ = channel[1].i_sample1;
434 *p_sample++ = channel[0].i_sample2;
435 *p_sample++ = channel[0].i_sample1;
438 for( i_nibbles = 2 * (p_sys->i_block - 7 * p_dec->fmt_in.audio.i_channels);
439 i_nibbles > 0; i_nibbles -= 2, p_buffer++ )
441 *p_sample++ = AdpcmMsExpandNibble( &channel[0], (*p_buffer) >> 4);
442 *p_sample++ = AdpcmMsExpandNibble( &channel[b_stereo ? 1 : 0],
450 typedef struct adpcm_ima_wav_channel_s
455 } adpcm_ima_wav_channel_t;
457 static int AdpcmImaWavExpandNibble(adpcm_ima_wav_channel_t *p_channel,
462 i_diff = i_step_table[p_channel->i_step_index] >> 3;
463 if( i_nibble&0x04 ) i_diff += i_step_table[p_channel->i_step_index];
464 if( i_nibble&0x02 ) i_diff += i_step_table[p_channel->i_step_index]>>1;
465 if( i_nibble&0x01 ) i_diff += i_step_table[p_channel->i_step_index]>>2;
467 p_channel->i_predictor -= i_diff;
469 p_channel->i_predictor += i_diff;
471 CLAMP( p_channel->i_predictor, -32768, 32767 );
473 p_channel->i_step_index += i_index_table[i_nibble];
475 CLAMP( p_channel->i_step_index, 0, 88 );
477 return( p_channel->i_predictor );
480 static void DecodeAdpcmImaWav( decoder_t *p_dec, int16_t *p_sample,
483 decoder_sys_t *p_sys = p_dec->p_sys;
484 adpcm_ima_wav_channel_t channel[2];
488 b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
490 GetWord( channel[0].i_predictor );
491 GetByte( channel[0].i_step_index );
492 CLAMP( channel[0].i_step_index, 0, 88 );
497 GetWord( channel[1].i_predictor );
498 GetByte( channel[1].i_step_index );
499 CLAMP( channel[1].i_step_index, 0, 88 );
505 for( i_nibbles = 2 * (p_sys->i_block - 8);
511 for( i = 0; i < 4; i++ )
514 AdpcmImaWavExpandNibble(&channel[0],p_buffer[i]&0x0f);
515 p_sample[i * 4 + 2] =
516 AdpcmImaWavExpandNibble(&channel[0],p_buffer[i] >> 4);
520 for( i = 0; i < 4; i++ )
522 p_sample[i * 4 + 1] =
523 AdpcmImaWavExpandNibble(&channel[1],p_buffer[i]&0x0f);
524 p_sample[i * 4 + 3] =
525 AdpcmImaWavExpandNibble(&channel[1],p_buffer[i] >> 4);
536 for( i_nibbles = 2 * (p_sys->i_block - 4);
538 i_nibbles -= 2, p_buffer++ )
540 *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer)&0x0f );
541 *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer) >> 4 );
549 static void DecodeAdpcmImaQT( decoder_t *p_dec, int16_t *p_sample,
552 adpcm_ima_wav_channel_t channel[2];
557 i_step = p_dec->fmt_in.audio.i_channels;
559 for( i_ch = 0; i_ch < p_dec->fmt_in.audio.i_channels; i_ch++ )
562 channel[i_ch].i_predictor = (int16_t)((( ( p_buffer[0] << 1 )|( p_buffer[1] >> 7 ) ))<<7);
563 channel[i_ch].i_step_index = p_buffer[1]&0x7f;
565 CLAMP( channel[i_ch].i_step_index, 0, 88 );
568 for( i_nibbles = 0; i_nibbles < 64; i_nibbles +=2 )
570 *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer)&0x0f);
573 *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer >> 4)&0x0f);
580 p_sample += 1 - 64 * i_step;
587 static void DecodeAdpcmDk4( decoder_t *p_dec, int16_t *p_sample,
590 decoder_sys_t *p_sys = p_dec->p_sys;
591 adpcm_ima_wav_channel_t channel[2];
595 b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
597 GetWord( channel[0].i_predictor );
598 GetByte( channel[0].i_step_index );
599 CLAMP( channel[0].i_step_index, 0, 88 );
604 GetWord( channel[1].i_predictor );
605 GetByte( channel[1].i_step_index );
606 CLAMP( channel[1].i_step_index, 0, 88 );
610 /* first output predictor */
611 *p_sample++ = channel[0].i_predictor;
614 *p_sample++ = channel[1].i_predictor;
618 i_nibbles < p_sys->i_block - 4 * (b_stereo ? 2:1 );
621 *p_sample++ = AdpcmImaWavExpandNibble( &channel[0],
623 *p_sample++ = AdpcmImaWavExpandNibble( &channel[b_stereo ? 1 : 0],
633 static void DecodeAdpcmDk3( decoder_t *p_dec, int16_t *p_sample,
636 decoder_sys_t *p_sys = p_dec->p_sys;
637 uint8_t *p_end = &p_buffer[p_sys->i_block];
638 adpcm_ima_wav_channel_t sum;
639 adpcm_ima_wav_channel_t diff;
644 GetWord( sum.i_predictor );
645 GetWord( diff.i_predictor );
646 GetByte( sum.i_step_index );
647 GetByte( diff.i_step_index );
649 i_diff_value = diff.i_predictor;
650 /* we process 6 nibbles at once */
651 while( p_buffer + 1 <= p_end )
653 /* first 3 nibbles */
654 AdpcmImaWavExpandNibble( &sum,
657 AdpcmImaWavExpandNibble( &diff,
660 i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
662 *p_sample++ = sum.i_predictor + i_diff_value;
663 *p_sample++ = sum.i_predictor - i_diff_value;
667 AdpcmImaWavExpandNibble( &sum,
670 *p_sample++ = sum.i_predictor + i_diff_value;
671 *p_sample++ = sum.i_predictor - i_diff_value;
673 /* now last 3 nibbles */
674 AdpcmImaWavExpandNibble( &sum,
677 if( p_buffer < p_end )
679 AdpcmImaWavExpandNibble( &diff,
682 i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
684 *p_sample++ = sum.i_predictor + i_diff_value;
685 *p_sample++ = sum.i_predictor - i_diff_value;
687 AdpcmImaWavExpandNibble( &sum,
691 *p_sample++ = sum.i_predictor + i_diff_value;
692 *p_sample++ = sum.i_predictor - i_diff_value;