1 /*****************************************************************************
2 * adpcm.c : adpcm variant audio decoder
3 *****************************************************************************
4 * Copyright (C) 2001, 2002 VideoLAN
5 * $Id: adpcm.c,v 1.8 2003/02/16 11:18:11 fenrir Exp $
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 *****************************************************************************/
31 #include <vlc/decoder.h>
32 #include <vlc/input.h>
34 #include <stdlib.h> /* malloc(), free() */
35 #include <string.h> /* strdup() */
37 /*****************************************************************************
39 *****************************************************************************/
41 #define ADPCM_IMA_QT 1
42 #define ADPCM_IMA_WAV 2
47 typedef struct adec_thread_s
55 int i_samplesperblock;
57 uint8_t *p_buffer; /* buffer for gather pes */ \
58 int i_buffer; /* bytes present in p_buffer */
60 /* Input properties */
61 decoder_fifo_t *p_fifo;
63 /* Output properties */
64 aout_instance_t * p_aout; /* opaque */
65 aout_input_t * p_aout_input; /* opaque */
66 audio_sample_format_t output_format;
73 static int OpenDecoder ( vlc_object_t * );
75 static int RunDecoder ( decoder_fifo_t * );
76 static int InitThread ( adec_thread_t * );
77 static void DecodeThread ( adec_thread_t * );
78 static void EndThread ( adec_thread_t * );
81 static void DecodeAdpcmMs( adec_thread_t *, aout_buffer_t * );
82 static void DecodeAdpcmImaWav( adec_thread_t *, aout_buffer_t * );
83 static void DecodeAdpcmDk4( adec_thread_t *, aout_buffer_t * );
84 static void DecodeAdpcmDk3( adec_thread_t *, aout_buffer_t * );
86 /*****************************************************************************
88 *****************************************************************************/
91 set_description( _("ADPCM audio deocder") );
92 set_capability( "decoder", 50 );
93 set_callbacks( OpenDecoder, NULL );
97 static int pi_channels_maps[6] =
101 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
102 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER,
103 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT,
104 AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
105 | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT
108 /* Various table from http://www.pcisys.net/~melanson/codecs/adpcm.txt */
109 static int i_index_table[16] =
111 -1, -1, -1, -1, 2, 4, 6, 8,
112 -1, -1, -1, -1, 2, 4, 6, 8
115 static int i_step_table[89] =
117 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
118 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
119 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
120 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
121 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
122 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
123 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
124 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
125 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
128 static int i_adaptation_table[16] =
130 230, 230, 230, 230, 307, 409, 512, 614,
131 768, 614, 512, 409, 307, 230, 230, 230
134 static int i_adaptation_coeff1[7] =
136 256, 512, 0, 192, 240, 460, 392
139 static int i_adaptation_coeff2[7] =
141 0, -256, 0, 64, 0, -208, -232
145 /*****************************************************************************
146 * OpenDecoder: probe the decoder and return score
147 *****************************************************************************
148 * Tries to launch a decoder and return score so that the interface is able
150 *****************************************************************************/
151 static int OpenDecoder( vlc_object_t *p_this )
153 decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
155 switch( p_fifo->i_fourcc )
157 // case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
158 case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
159 case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
160 case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
161 case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
163 p_fifo->pf_run = RunDecoder;
172 /*****************************************************************************
173 * RunDecoder: this function is called just after the thread is created
174 *****************************************************************************/
175 static int RunDecoder( decoder_fifo_t *p_fifo )
177 adec_thread_t *p_adec;
180 if( !( p_adec = malloc( sizeof( adec_thread_t ) ) ) )
182 msg_Err( p_fifo, "out of memory" );
183 DecoderError( p_fifo );
186 memset( p_adec, 0, sizeof( adec_thread_t ) );
188 p_adec->p_fifo = p_fifo;
190 if( InitThread( p_adec ) != 0 )
192 DecoderError( p_fifo );
196 while( ( !p_adec->p_fifo->b_die )&&( !p_adec->p_fifo->b_error ) )
198 DecodeThread( p_adec );
202 if( ( b_error = p_adec->p_fifo->b_error ) )
204 DecoderError( p_adec->p_fifo );
217 #define FREE( p ) if( p ) free( p ); p = NULL
218 #define GetWLE( p ) \
219 ( *(uint8_t*)(p) + ( *((uint8_t*)(p)+1) << 8 ) )
221 #define GetDWLE( p ) \
222 ( *(uint8_t*)(p) + ( *((uint8_t*)(p)+1) << 8 ) + \
223 ( *((uint8_t*)(p)+2) << 16 ) + ( *((uint8_t*)(p)+3) << 24 ) )
225 /*****************************************************************************
226 * InitThread: initialize data before entering main loop
227 *****************************************************************************/
229 static int InitThread( adec_thread_t * p_adec )
231 if( ( p_adec->p_wf = (WAVEFORMATEX*)p_adec->p_fifo->p_waveformatex ) == NULL )
233 msg_Err( p_adec->p_fifo, "missing format" );
236 /* fourcc to codec */
237 switch( p_adec->p_fifo->i_fourcc )
239 case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
240 p_adec->i_codec = ADPCM_IMA_QT;
242 case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
243 p_adec->i_codec = ADPCM_IMA_WAV;
245 case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
246 p_adec->i_codec = ADPCM_MS;
248 case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
249 p_adec->i_codec = ADPCM_DK4;
251 case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
252 p_adec->i_codec = ADPCM_DK3;
256 if( p_adec->p_wf->nChannels < 1 ||
257 p_adec->p_wf->nChannels > 2 )
259 msg_Err( p_adec->p_fifo, "bad channels count(1-2)" );
262 if( !( p_adec->i_block = p_adec->p_wf->nBlockAlign ) )
264 if( p_adec->i_codec == ADPCM_IMA_QT )
266 p_adec->i_block = 34;
270 p_adec->i_block = 1024; // XXX FIXME
272 msg_Err( p_adec->p_fifo,
273 "block size undefined, using %d default",
276 p_adec->p_block = NULL;
278 /* calculate samples per block */
279 switch( p_adec->i_codec )
282 p_adec->i_samplesperblock = 64;
285 p_adec->i_samplesperblock =
286 2 * ( p_adec->i_block - 4 * p_adec->p_wf->nChannels )/
287 p_adec->p_wf->nChannels;
290 p_adec->i_samplesperblock =
291 2 * ( p_adec->i_block - 7 * p_adec->p_wf->nChannels ) /
292 p_adec->p_wf->nChannels + 2;
295 p_adec->i_samplesperblock =
296 2 * ( p_adec->i_block - 4 * p_adec->p_wf->nChannels ) /
297 p_adec->p_wf->nChannels + 1;
300 p_adec->p_wf->nChannels = 2;
301 p_adec->i_samplesperblock = ( 4 * ( p_adec->i_block - 16 ) + 2 )/ 3;
304 msg_Err( p_adec->p_fifo, "unknown adpcm variant" );
308 msg_Dbg( p_adec->p_fifo,
309 "format: samplerate:%dHz channels:%d bits/sample:%d blockalign:%d samplesperblock %d",
310 p_adec->p_wf->nSamplesPerSec,
311 p_adec->p_wf->nChannels,
312 p_adec->p_wf->wBitsPerSample,
313 p_adec->p_wf->nBlockAlign,
314 p_adec->i_samplesperblock );
316 //p_adec->output_format.i_format = VLC_FOURCC('s','1','6','l');
317 /* FIXME good way ? */
318 p_adec->output_format.i_format = AOUT_FMT_S16_NE;
319 p_adec->output_format.i_rate = p_adec->p_wf->nSamplesPerSec;
322 p_adec->output_format.i_physical_channels =
323 p_adec->output_format.i_original_channels =
324 pi_channels_maps[p_adec->p_wf->nChannels];
325 p_adec->p_aout = NULL;
326 p_adec->p_aout_input = NULL;
328 /* **** Create a new audio output **** */
329 aout_DateInit( &p_adec->date, p_adec->output_format.i_rate );
330 p_adec->p_aout_input = aout_DecNew( p_adec->p_fifo,
332 &p_adec->output_format );
333 if( !p_adec->p_aout_input )
335 msg_Err( p_adec->p_fifo, "cannot create aout" );
339 /* Init the BitStream */
340 // InitBitstream( &p_adec->bit_stream, p_adec->p_fifo,
347 static void GetPESData( uint8_t *p_buf, int i_max, pes_packet_t *p_pes )
352 data_packet_t *p_data;
355 p_data = p_pes->p_first;
356 while( p_data != NULL && i_count < i_max )
359 i_copy = __MIN( p_data->p_payload_end - p_data->p_payload_start,
365 p_data->p_payload_start,
369 p_data = p_data->p_next;
374 if( i_count < i_max )
376 memset( p_buf, 0, i_max - i_count );
380 /*****************************************************************************
381 * DecodeThread: decodes a frame
382 *****************************************************************************/
383 static void DecodeThread( adec_thread_t *p_adec )
385 aout_buffer_t *p_aout_buffer;
390 /* **** Get a new frames from streams **** */
393 input_ExtractPES( p_adec->p_fifo, &p_pes );
396 p_adec->p_fifo->b_error = 1;
399 if( p_pes->i_pts != 0 )
401 p_adec->pts = p_pes->i_pts;
403 i_frame_size = p_pes->i_pes_size;
405 if( i_frame_size > 0 )
407 if( p_adec->i_buffer < i_frame_size + 16 )
409 FREE( p_adec->p_buffer );
410 p_adec->p_buffer = malloc( i_frame_size + 16 );
411 p_adec->i_buffer = i_frame_size + 16;
414 GetPESData( p_adec->p_buffer, p_adec->i_buffer, p_pes );
416 input_DeletePES( p_adec->p_fifo->p_packets_mgt, p_pes );
418 } while( i_frame_size <= 0 );
420 for( p_adec->p_block = p_adec->p_buffer;
421 i_frame_size >= p_adec->i_block;
422 p_adec->p_block += p_adec->i_block, i_frame_size -= p_adec->i_block )
424 /* get output buffer */
425 if( p_adec->pts != 0 && p_adec->pts != aout_DateGet( &p_adec->date ) )
427 aout_DateSet( &p_adec->date, p_adec->pts );
429 else if( !aout_DateGet( &p_adec->date ) )
435 p_aout_buffer = aout_DecNewBuffer( p_adec->p_aout,
436 p_adec->p_aout_input,
437 p_adec->i_samplesperblock );
440 msg_Err( p_adec->p_fifo, "cannot get aout buffer" );
441 p_adec->p_fifo->b_error = 1;
445 p_aout_buffer->start_date = aout_DateGet( &p_adec->date );
446 p_aout_buffer->end_date = aout_DateIncrement( &p_adec->date,
447 p_adec->i_samplesperblock );
451 switch( p_adec->i_codec )
456 DecodeAdpcmImaWav( p_adec, p_aout_buffer );
459 DecodeAdpcmMs( p_adec, p_aout_buffer );
462 DecodeAdpcmDk4( p_adec, p_aout_buffer );
464 DecodeAdpcmDk3( p_adec, p_aout_buffer );
470 /* **** Now we can output these samples **** */
471 aout_DecPlay( p_adec->p_aout, p_adec->p_aout_input, p_aout_buffer );
476 /*****************************************************************************
477 * EndThread : faad decoder thread destruction
478 *****************************************************************************/
479 static void EndThread (adec_thread_t *p_adec)
481 if( p_adec->p_aout_input )
483 aout_DecDelete( p_adec->p_aout, p_adec->p_aout_input );
486 msg_Dbg( p_adec->p_fifo, "adpcm audio decoder closed" );
488 FREE( p_adec->p_buffer );
491 #define CLAMP( v, min, max ) \
492 if( (v) < (min) ) (v) = (min); \
493 if( (v) > (max) ) (v) = (max)
495 #define GetByte( v ) \
496 (v) = *p_buffer; p_buffer++;
498 #define GetWord( v ) \
499 (v) = *p_buffer; p_buffer++; \
500 (v) |= ( *p_buffer ) << 8; p_buffer++; \
501 if( (v)&0x8000 ) (v) -= 0x010000;
506 typedef struct adpcm_ms_channel_s
509 int i_sample1, i_sample2;
510 int i_coeff1, i_coeff2;
512 } adpcm_ms_channel_t;
515 static int AdpcmMsExpandNibble(adpcm_ms_channel_t *p_channel,
522 i_snibble = i_nibble - ( i_nibble&0x08 ? 0x10 : 0 );
524 i_predictor = ( p_channel->i_sample1 * p_channel->i_coeff1 +
525 p_channel->i_sample2 * p_channel->i_coeff2 ) / 256 +
526 i_snibble * p_channel->i_idelta;
528 CLAMP( i_predictor, -32768, 32767 );
530 p_channel->i_sample2 = p_channel->i_sample1;
531 p_channel->i_sample1 = i_predictor;
533 p_channel->i_idelta = ( i_adaptation_table[i_nibble] *
534 p_channel->i_idelta ) / 256;
535 if( p_channel->i_idelta < 16 )
537 p_channel->i_idelta = 16;
539 return( i_predictor );
542 static void DecodeAdpcmMs( adec_thread_t *p_adec,
543 aout_buffer_t *p_aout_buffer)
546 adpcm_ms_channel_t channel[2];
550 int i_block_predictor;
552 p_buffer = p_adec->p_block;
553 b_stereo = p_adec->p_wf->nChannels == 2 ? 1 : 0;
555 GetByte( i_block_predictor );
556 CLAMP( i_block_predictor, 0, 6 );
557 channel[0].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
558 channel[0].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
562 GetByte( i_block_predictor );
563 CLAMP( i_block_predictor, 0, 6 );
564 channel[1].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
565 channel[1].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
567 GetWord( channel[0].i_idelta );
570 GetWord( channel[1].i_idelta );
573 GetWord( channel[0].i_sample1 );
576 GetWord( channel[1].i_sample1 );
579 GetWord( channel[0].i_sample2 );
582 GetWord( channel[1].i_sample2 );
585 p_sample = (int16_t*)p_aout_buffer->p_buffer;
589 *p_sample = channel[0].i_sample2; p_sample++;
590 *p_sample = channel[1].i_sample2; p_sample++;
591 *p_sample = channel[0].i_sample1; p_sample++;
592 *p_sample = channel[1].i_sample1; p_sample++;
596 *p_sample = channel[0].i_sample2; p_sample++;
597 *p_sample = channel[0].i_sample1; p_sample++;
600 for( i_nibbles = 2 *( p_adec->i_block - 7 * p_adec->p_wf->nChannels );
601 i_nibbles > 0; i_nibbles -= 2,p_buffer++ )
603 *p_sample = AdpcmMsExpandNibble( &channel[0], (*p_buffer) >> 4);
606 *p_sample = AdpcmMsExpandNibble( &channel[b_stereo ? 1 : 0],
617 typedef struct adpcm_ima_wav_channel_s
622 } adpcm_ima_wav_channel_t;
624 static int AdpcmImaWavExpandNibble(adpcm_ima_wav_channel_t *p_channel,
629 i_diff = i_step_table[p_channel->i_step_index] >> 3;
630 if( i_nibble&0x04 ) i_diff += i_step_table[p_channel->i_step_index];
631 if( i_nibble&0x02 ) i_diff += i_step_table[p_channel->i_step_index]>>1;
632 if( i_nibble&0x01 ) i_diff += i_step_table[p_channel->i_step_index]>>2;
634 p_channel->i_predictor -= i_diff;
636 p_channel->i_predictor += i_diff;
638 CLAMP( p_channel->i_predictor, -32768, 32767 );
640 p_channel->i_step_index += i_index_table[i_nibble];
642 CLAMP( p_channel->i_step_index, 0, 88 );
644 return( p_channel->i_predictor );
647 static void DecodeAdpcmImaWav( adec_thread_t *p_adec,
648 aout_buffer_t *p_aout_buffer)
651 adpcm_ima_wav_channel_t channel[2];
656 p_buffer = p_adec->p_block;
657 b_stereo = p_adec->p_wf->nChannels == 2 ? 1 : 0;
659 GetWord( channel[0].i_predictor );
660 GetByte( channel[0].i_step_index );
661 CLAMP( channel[0].i_step_index, 0, 88 );
666 GetWord( channel[1].i_predictor );
667 GetByte( channel[1].i_step_index );
668 CLAMP( channel[1].i_step_index, 0, 88 );
672 p_sample = (int16_t*)p_aout_buffer->p_buffer;
675 for( i_nibbles = 2 * (p_adec->i_block - 8);
681 for( i = 0; i < 4; i++ )
684 AdpcmImaWavExpandNibble(&channel[0],p_buffer[i]&0x0f);
685 p_sample[i * 4 + 2] =
686 AdpcmImaWavExpandNibble(&channel[0],p_buffer[i] >> 4);
690 for( i = 0; i < 4; i++ )
692 p_sample[i * 4 + 1] =
693 AdpcmImaWavExpandNibble(&channel[1],p_buffer[i]&0x0f);
694 p_sample[i * 4 + 3] =
695 AdpcmImaWavExpandNibble(&channel[1],p_buffer[i] >> 4);
706 for( i_nibbles = 2 * (p_adec->i_block - 4);
708 i_nibbles -= 2, p_buffer++ )
710 *p_sample =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer)&0x0f );
712 *p_sample =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer) >> 4 );
722 static void DecodeAdpcmDk4( adec_thread_t *p_adec,
723 aout_buffer_t *p_aout_buffer)
726 adpcm_ima_wav_channel_t channel[2];
731 p_buffer = p_adec->p_block;
732 b_stereo = p_adec->p_wf->nChannels == 2 ? 1 : 0;
734 GetWord( channel[0].i_predictor );
735 GetByte( channel[0].i_step_index );
736 CLAMP( channel[0].i_step_index, 0, 88 );
741 GetWord( channel[1].i_predictor );
742 GetByte( channel[1].i_step_index );
743 CLAMP( channel[1].i_step_index, 0, 88 );
747 p_sample = (int16_t*)p_aout_buffer->p_buffer;
749 /* first output predictor */
750 *p_sample++ = channel[0].i_predictor;
753 *p_sample++ = channel[1].i_predictor;
757 i_nibbles < p_adec->i_block - 4 * (b_stereo ? 2:1 );
760 *p_sample++ = AdpcmImaWavExpandNibble( &channel[0],
762 *p_sample++ = AdpcmImaWavExpandNibble( &channel[b_stereo ? 1 : 0],
773 static void DecodeAdpcmDk3( adec_thread_t *p_adec,
774 aout_buffer_t *p_aout_buffer)
776 uint8_t *p_buffer, *p_end;
777 adpcm_ima_wav_channel_t sum;
778 adpcm_ima_wav_channel_t diff;
782 p_buffer = p_adec->p_block;
783 p_end = p_buffer + p_adec->i_block;
786 GetWord( sum.i_predictor );
787 GetWord( diff.i_predictor );
788 GetByte( sum.i_step_index );
789 GetByte( diff.i_step_index );
791 p_sample = (int16_t*)p_aout_buffer->p_buffer;
792 i_diff_value = diff.i_predictor;
793 /* we process 6 nibbles at once */
794 //for( i_group = 0; i_group < ( p_adec->i_block -16 ) / 3; i_group++ )
795 while( p_buffer + 1 <= p_end )
797 /* first 3 nibbles */
798 AdpcmImaWavExpandNibble( &sum,
801 AdpcmImaWavExpandNibble( &diff,
804 i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
806 *p_sample++ = sum.i_predictor + i_diff_value;
807 *p_sample++ = sum.i_predictor - i_diff_value;
811 AdpcmImaWavExpandNibble( &sum,
814 *p_sample++ = sum.i_predictor + i_diff_value;
815 *p_sample++ = sum.i_predictor - i_diff_value;
817 /* now last 3 nibbles */
818 AdpcmImaWavExpandNibble( &sum,
821 if( p_buffer < p_end )
823 AdpcmImaWavExpandNibble( &diff,
826 i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
828 *p_sample++ = sum.i_predictor + i_diff_value;
829 *p_sample++ = sum.i_predictor - i_diff_value;
831 AdpcmImaWavExpandNibble( &sum,
835 *p_sample++ = sum.i_predictor + i_diff_value;
836 *p_sample++ = sum.i_predictor - i_diff_value;