开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
adpcm.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：20k
源码类别：

多媒体

开发平台：

MultiPlatform

adpcm.c：源码内容
  1. /*****************************************************************************
  2.  * adpcm.c : adpcm variant audio decoder
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 VideoLAN
  5.  * $Id: adpcm.c 6961 2004-03-05 17:34:23Z sam $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  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.
  13.  *
  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.
  18.  *
  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. /*****************************************************************************
  25.  * Preamble
  26.  *
  27.  * Documentation: http://www.pcisys.net/~melanson/codecs/adpcm.txt
  28.  *****************************************************************************/
  29. #include <vlc/vlc.h>
  30. #include <vlc/decoder.h>
  32. /*****************************************************************************
  33.  * Module descriptor
  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 ** );
  40. vlc_module_begin();
  41.     set_description( _("ADPCM audio decoder") );
  42.     set_capability( "decoder", 50 );
  43.     set_callbacks( OpenDecoder, CloseDecoder );
  44. vlc_module_end();
  46. /*****************************************************************************
  47.  * Local prototypes
  48.  *****************************************************************************/
  49. enum adpcm_codec_e
  50. {
  51.     ADPCM_IMA_QT,
  52.     ADPCM_IMA_WAV,
  53.     ADPCM_MS,
  54.     ADPCM_DK3,
  55.     ADPCM_DK4
  56. };
  58. struct decoder_sys_t
  59. {
  60.     enum adpcm_codec_e codec;
  62.     int                 i_block;
  63.     int                 i_samplesperblock;
  65.     audio_date_t        end_date;
  66. };
  68. static void DecodeAdpcmMs    ( decoder_t *, int16_t *, uint8_t * );
  69. static void DecodeAdpcmImaWav( decoder_t *, int16_t *, uint8_t * );
  70. static void DecodeAdpcmImaQT ( decoder_t *, int16_t *, uint8_t * );
  71. static void DecodeAdpcmDk4   ( decoder_t *, int16_t *, uint8_t * );
  72. static void DecodeAdpcmDk3   ( decoder_t *, int16_t *, uint8_t * );
  74. static int pi_channels_maps[6] =
  75. {
  76.     0,
  77.     AOUT_CHAN_CENTER,
  78.     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  79.     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER,
  80.     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT,
  81.     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
  82.      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT
  83. };
  85. /* Various table from http://www.pcisys.net/~melanson/codecs/adpcm.txt */
  86. static int i_index_table[16] =
  87. {
  88.     -1, -1, -1, -1, 2, 4, 6, 8,
  89.     -1, -1, -1, -1, 2, 4, 6, 8
  90. };
  92. static int i_step_table[89] =
  93. {
  94.     7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
  95.     19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
  96.     50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
  97.     130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
  98.     337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
  99.     876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
  100.     2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
  101.     5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
  102.     15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
  103. };
  105. static int i_adaptation_table[16] =
  106. {
  107.     230, 230, 230, 230, 307, 409, 512, 614,
  108.     768, 614, 512, 409, 307, 230, 230, 230
  109. };
  111. static int i_adaptation_coeff1[7] =
  112. {
  113.     256, 512, 0, 192, 240, 460, 392
  114. };
  116. static int i_adaptation_coeff2[7] =
  117. {
  118.     0, -256, 0, 64, 0, -208, -232
  119. };
  121. /*****************************************************************************
  122.  * OpenDecoder: probe the decoder and return score
  123.  *****************************************************************************/
  124. static int OpenDecoder( vlc_object_t *p_this )
  125. {
  126.     decoder_t *p_dec = (decoder_t*)p_this;
  127.     decoder_sys_t *p_sys;
  129.     switch( p_dec->fmt_in.i_codec )
  130.     {
  131.         case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
  132.         case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
  133.         case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
  134.         case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
  135.         case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
  136.             break;
  137.         default:
  138.             return VLC_EGENERIC;
  139.     }
  141.     /* Allocate the memory needed to store the decoder's structure */
  142.     if( ( p_dec->p_sys = p_sys =
  143.           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
  144.     {
  145.         msg_Err( p_dec, "out of memory" );
  146.         return VLC_EGENERIC;
  147.     }
  149.     if( p_dec->fmt_in.audio.i_channels <= 0 ||
  150.         p_dec->fmt_in.audio.i_channels > 5 )
  151.     {
  152.         msg_Err( p_dec, "bad channels count(1-5)" );
  153.         return VLC_EGENERIC;
  154.     }
  156.     if( p_dec->fmt_in.audio.i_rate <= 0 )
  157.     {
  158.         msg_Err( p_dec, "bad samplerate" );
  159.         return VLC_EGENERIC;
  160.     }
  162.     switch( p_dec->fmt_in.i_codec )
  163.     {
  164.         case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
  165.             p_sys->codec = ADPCM_IMA_QT;
  166.             break;
  167.         case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
  168.             p_sys->codec = ADPCM_IMA_WAV;
  169.             break;
  170.         case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
  171.             p_sys->codec = ADPCM_MS;
  172.             break;
  173.         case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
  174.             p_sys->codec = ADPCM_DK4;
  175.             break;
  176.         case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
  177.             p_sys->codec = ADPCM_DK3;
  178.             break;
  179.     }
  181.     if( p_dec->fmt_in.audio.i_blockalign <= 0 )
  182.     {
  183.         p_sys->i_block = (p_sys->codec == ADPCM_IMA_QT) ?
  184.             34 * p_dec->fmt_in.audio.i_channels : 1024;
  185.         msg_Warn( p_dec, "block size undefined, using %d", p_sys->i_block );
  186.     }
  187.     else
  188.     {
  189.         p_sys->i_block = p_dec->fmt_in.audio.i_blockalign;
  190.     }
  192.     /* calculate samples per block */
  193.     switch( p_sys->codec )
  194.     {
  195.     case ADPCM_IMA_QT:
  196.         p_sys->i_samplesperblock = 64;
  197.         break;
  198.     case ADPCM_IMA_WAV:
  199.         p_sys->i_samplesperblock =
  200.             2 * ( p_sys->i_block - 4 * p_dec->fmt_in.audio.i_channels ) /
  201.             p_dec->fmt_in.audio.i_channels;
  202.         break;
  203.     case ADPCM_MS:
  204.         p_sys->i_samplesperblock =
  205.             2 * (p_sys->i_block - 7 * p_dec->fmt_in.audio.i_channels) /
  206.             p_dec->fmt_in.audio.i_channels + 2;
  207.         break;
  208.     case ADPCM_DK4:
  209.         p_sys->i_samplesperblock =
  210.             2 * (p_sys->i_block - 4 * p_dec->fmt_in.audio.i_channels) /
  211.             p_dec->fmt_in.audio.i_channels + 1;
  212.         break;
  213.     case ADPCM_DK3:
  214.         p_dec->fmt_in.audio.i_channels = 2;
  215.         p_sys->i_samplesperblock = ( 4 * ( p_sys->i_block - 16 ) + 2 )/ 3;
  216.         break;
  217.     }
  219.     msg_Dbg( p_dec, "format: samplerate:%dHz channels:%d bits/sample:%d "
  220.              "blockalign:%d samplesperblock:%d",
  221.              p_dec->fmt_in.audio.i_rate, p_dec->fmt_in.audio.i_channels,
  222.              p_dec->fmt_in.audio.i_bitspersample, p_sys->i_block,
  223.              p_sys->i_samplesperblock );
  225.     p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
  226.     p_dec->fmt_out.audio.i_rate = p_dec->fmt_in.audio.i_rate;
  227.     p_dec->fmt_out.audio.i_channels = p_dec->fmt_in.audio.i_channels;
  228.     p_dec->fmt_out.audio.i_physical_channels =
  229.         p_dec->fmt_out.audio.i_original_channels =
  230.             pi_channels_maps[p_dec->fmt_in.audio.i_channels];
  232.     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
  233.     aout_DateSet( &p_sys->end_date, 0 );
  235.     p_dec->pf_decode_audio = DecodeBlock;
  237.     return VLC_SUCCESS;
  238. }
  240. /*****************************************************************************
  241.  * DecodeBlock:
  242.  *****************************************************************************/
  243. static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
  244. {
  245.     decoder_sys_t *p_sys  = p_dec->p_sys;
  246.     block_t *p_block;
  248.     if( !pp_block || !*pp_block ) return NULL;
  250.     p_block = *pp_block;
  252.     if( p_block->i_pts != 0 &&
  253.         p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
  254.     {
  255.         aout_DateSet( &p_sys->end_date, p_block->i_pts );
  256.     }
  257.     else if( !aout_DateGet( &p_sys->end_date ) )
  258.     {
  259.         /* We've just started the stream, wait for the first PTS. */
  260.         block_Release( p_block );
  261.         return NULL;
  262.     }
  264.     /* Don't re-use the same pts twice */
  265.     p_block->i_pts = 0;
  267.     if( p_block->i_buffer >= p_sys->i_block )
  268.     {
  269.         aout_buffer_t *p_out;
  271.         p_out = p_dec->pf_aout_buffer_new( p_dec, p_sys->i_samplesperblock );
  272.         if( p_out == NULL )
  273.         {
  274.             block_Release( p_block );
  275.             return NULL;
  276.         }
  278.         p_out->start_date = aout_DateGet( &p_sys->end_date );
  279.         p_out->end_date =
  280.             aout_DateIncrement( &p_sys->end_date, p_sys->i_samplesperblock );
  282.         switch( p_sys->codec )
  283.         {
  284.         case ADPCM_IMA_QT:
  285.             DecodeAdpcmImaQT( p_dec, (int16_t*)p_out->p_buffer,
  286.                               p_block->p_buffer );
  287.             break;
  288.         case ADPCM_IMA_WAV:
  289.             DecodeAdpcmImaWav( p_dec, (int16_t*)p_out->p_buffer,
  290.                                p_block->p_buffer );
  291.             break;
  292.         case ADPCM_MS:
  293.             DecodeAdpcmMs( p_dec, (int16_t*)p_out->p_buffer,
  294.                            p_block->p_buffer );
  295.             break;
  296.         case ADPCM_DK4:
  297.             DecodeAdpcmDk4( p_dec, (int16_t*)p_out->p_buffer,
  298.                             p_block->p_buffer );
  299.             break;
  300.         case ADPCM_DK3:
  301.             DecodeAdpcmDk3( p_dec, (int16_t*)p_out->p_buffer,
  302.                             p_block->p_buffer );
  303.             break;
  304.         default:
  305.             break;
  306.         }
  308.         p_block->p_buffer += p_sys->i_block;
  309.         p_block->i_buffer -= p_sys->i_block;
  310.         return p_out;
  311.     }
  313.     block_Release( p_block );
  314.     return NULL;
  315. }
  317. /*****************************************************************************
  318.  * CloseDecoder:
  319.  *****************************************************************************/
  320. static void CloseDecoder( vlc_object_t *p_this )
  321. {
  322.     decoder_t *p_dec = (decoder_t *)p_this;
  323.     decoder_sys_t *p_sys = p_dec->p_sys;
  325.     free( p_sys );
  326. }
  328. /*****************************************************************************
  329.  * Local functions
  330.  *****************************************************************************/
  331. #define CLAMP( v, min, max ) 
  332.     if( (v) < (min) ) (v) = (min); 
  333.     if( (v) > (max) ) (v) = (max)
  335. #define GetByte( v ) 
  336.     (v) = *p_buffer; p_buffer++;
  338. #define GetWord( v ) 
  339.     (v) = *p_buffer; p_buffer++; 
  340.     (v) |= ( *p_buffer ) << 8; p_buffer++; 
  341.     if( (v)&0x8000 ) (v) -= 0x010000;
  343. /*
  344.  * MS
  345.  */
  346. typedef struct adpcm_ms_channel_s
  347. {
  348.     int i_idelta;
  349.     int i_sample1, i_sample2;
  350.     int i_coeff1, i_coeff2;
  352. } adpcm_ms_channel_t;
  355. static int AdpcmMsExpandNibble(adpcm_ms_channel_t *p_channel,
  356.                                int i_nibble )
  357. {
  358.     int i_predictor;
  359.     int i_snibble;
  360.     /* expand sign */
  362.     i_snibble = i_nibble - ( i_nibble&0x08 ? 0x10 : 0 );
  364.     i_predictor = ( p_channel->i_sample1 * p_channel->i_coeff1 +
  365.                     p_channel->i_sample2 * p_channel->i_coeff2 ) / 256 +
  366.                   i_snibble * p_channel->i_idelta;
  368.     CLAMP( i_predictor, -32768, 32767 );
  370.     p_channel->i_sample2 = p_channel->i_sample1;
  371.     p_channel->i_sample1 = i_predictor;
  373.     p_channel->i_idelta = ( i_adaptation_table[i_nibble] *
  374.                             p_channel->i_idelta ) / 256;
  375.     if( p_channel->i_idelta < 16 )
  376.     {
  377.         p_channel->i_idelta = 16;
  378.     }
  379.     return( i_predictor );
  380. }
  382. static void DecodeAdpcmMs( decoder_t *p_dec, int16_t *p_sample,
  383.                            uint8_t *p_buffer )
  384. {
  385.     decoder_sys_t *p_sys  = p_dec->p_sys;
  386.     adpcm_ms_channel_t channel[2];
  387.     int i_nibbles;
  388.     int b_stereo;
  389.     int i_block_predictor;
  391.     b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
  393.     GetByte( i_block_predictor );
  394.     CLAMP( i_block_predictor, 0, 6 );
  395.     channel[0].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
  396.     channel[0].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
  398.     if( b_stereo )
  399.     {
  400.         GetByte( i_block_predictor );
  401.         CLAMP( i_block_predictor, 0, 6 );
  402.         channel[1].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
  403.         channel[1].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
  404.     }
  405.     GetWord( channel[0].i_idelta );
  406.     if( b_stereo )
  407.     {
  408.         GetWord( channel[1].i_idelta );
  409.     }
  411.     GetWord( channel[0].i_sample1 );
  412.     if( b_stereo )
  413.     {
  414.         GetWord( channel[1].i_sample1 );
  415.     }
  417.     GetWord( channel[0].i_sample2 );
  418.     if( b_stereo )
  419.     {
  420.         GetWord( channel[1].i_sample2 );
  421.     }
  423.     if( b_stereo )
  424.     {
  425.         *p_sample++ = channel[0].i_sample2;
  426.         *p_sample++ = channel[1].i_sample2;
  427.         *p_sample++ = channel[0].i_sample1;
  428.         *p_sample++ = channel[1].i_sample1;
  429.     }
  430.     else
  431.     {
  432.         *p_sample++ = channel[0].i_sample2;
  433.         *p_sample++ = channel[0].i_sample1;
  434.     }
  436.     for( i_nibbles = 2 * (p_sys->i_block - 7 * p_dec->fmt_in.audio.i_channels);
  437.          i_nibbles > 0; i_nibbles -= 2, p_buffer++ )
  438.     {
  439.         *p_sample++ = AdpcmMsExpandNibble( &channel[0], (*p_buffer) >> 4);
  440.         *p_sample++ = AdpcmMsExpandNibble( &channel[b_stereo ? 1 : 0],
  441.                                            (*p_buffer)&0x0f);
  442.     }
  443. }
  445. /*
  446.  * IMA-WAV
  447.  */
  448. typedef struct adpcm_ima_wav_channel_s
  449. {
  450.     int i_predictor;
  451.     int i_step_index;
  453. } adpcm_ima_wav_channel_t;
  455. static int AdpcmImaWavExpandNibble(adpcm_ima_wav_channel_t *p_channel,
  456.                                    int i_nibble )
  457. {
  458.     int i_diff;
  460.     i_diff = i_step_table[p_channel->i_step_index] >> 3;
  461.     if( i_nibble&0x04 ) i_diff += i_step_table[p_channel->i_step_index];
  462.     if( i_nibble&0x02 ) i_diff += i_step_table[p_channel->i_step_index]>>1;
  463.     if( i_nibble&0x01 ) i_diff += i_step_table[p_channel->i_step_index]>>2;
  464.     if( i_nibble&0x08 )
  465.         p_channel->i_predictor -= i_diff;
  466.     else
  467.         p_channel->i_predictor += i_diff;
  469.     CLAMP( p_channel->i_predictor, -32768, 32767 );
  471.     p_channel->i_step_index += i_index_table[i_nibble];
  473.     CLAMP( p_channel->i_step_index, 0, 88 );
  475.     return( p_channel->i_predictor );
  476. }
  478. static void DecodeAdpcmImaWav( decoder_t *p_dec, int16_t *p_sample,
  479.                                uint8_t *p_buffer )
  480. {
  481.     decoder_sys_t *p_sys  = p_dec->p_sys;
  482.     adpcm_ima_wav_channel_t channel[2];
  483.     int                     i_nibbles;
  484.     int                     b_stereo;
  486.     b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
  488.     GetWord( channel[0].i_predictor );
  489.     GetByte( channel[0].i_step_index );
  490.     CLAMP( channel[0].i_step_index, 0, 88 );
  491.     p_buffer++;
  493.     if( b_stereo )
  494.     {
  495.         GetWord( channel[1].i_predictor );
  496.         GetByte( channel[1].i_step_index );
  497.         CLAMP( channel[1].i_step_index, 0, 88 );
  498.         p_buffer++;
  499.     }
  501.     if( b_stereo )
  502.     {
  503.         for( i_nibbles = 2 * (p_sys->i_block - 8);
  504.              i_nibbles > 0;
  505.              i_nibbles -= 16 )
  506.         {
  507.             int i;
  509.             for( i = 0; i < 4; i++ )
  510.             {
  511.                 p_sample[i * 4] =
  512.                     AdpcmImaWavExpandNibble(&channel[0],p_buffer[i]&0x0f);
  513.                 p_sample[i * 4 + 2] =
  514.                     AdpcmImaWavExpandNibble(&channel[0],p_buffer[i] >> 4);
  515.             }
  516.             p_buffer += 4;
  518.             for( i = 0; i < 4; i++ )
  519.             {
  520.                 p_sample[i * 4 + 1] =
  521.                     AdpcmImaWavExpandNibble(&channel[1],p_buffer[i]&0x0f);
  522.                 p_sample[i * 4 + 3] =
  523.                     AdpcmImaWavExpandNibble(&channel[1],p_buffer[i] >> 4);
  524.             }
  525.             p_buffer += 4;
  526.             p_sample += 16;
  528.         }
  531.     }
  532.     else
  533.     {
  534.         for( i_nibbles = 2 * (p_sys->i_block - 4);
  535.              i_nibbles > 0;
  536.              i_nibbles -= 2, p_buffer++ )
  537.         {
  538.             *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer)&0x0f );
  539.             *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer) >> 4 );
  540.         }
  541.     }
  542. }
  544. /*
  545.  * Ima4 in QT file
  546.  */
  547. static void DecodeAdpcmImaQT( decoder_t *p_dec, int16_t *p_sample,
  548.                               uint8_t *p_buffer )
  549. {
  550.     adpcm_ima_wav_channel_t channel[2];
  551.     int                     i_nibbles;
  552.     int                     i_ch;
  553.     int                     i_step;
  555.     i_step = p_dec->fmt_in.audio.i_channels;
  557.     for( i_ch = 0; i_ch < p_dec->fmt_in.audio.i_channels; i_ch++ )
  558.     {
  559.         /* load preambule */
  560.         channel[i_ch].i_predictor  = (int16_t)((( ( p_buffer[0] << 1 )|(  p_buffer[1] >> 7 ) ))<<7);
  561.         channel[i_ch].i_step_index = p_buffer[1]&0x7f;
  563.         CLAMP( channel[i_ch].i_step_index, 0, 88 );
  564.         p_buffer += 2;
  566.         for( i_nibbles = 0; i_nibbles < 64; i_nibbles +=2 )
  567.         {
  568.             *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer)&0x0f);
  569.             p_sample += i_step;
  571.             *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer >> 4)&0x0f);
  572.             p_sample += i_step;
  574.             p_buffer++;
  575.         }
  577.         /* Next channel */
  578.         p_sample += 1 - 64 * i_step;
  579.     }
  580. }
  582. /*
  583.  * Dk4
  584.  */
  585. static void DecodeAdpcmDk4( decoder_t *p_dec, int16_t *p_sample,
  586.                             uint8_t *p_buffer )
  587. {
  588.     decoder_sys_t *p_sys  = p_dec->p_sys;
  589.     adpcm_ima_wav_channel_t channel[2];
  590.     int                     i_nibbles;
  591.     int                     b_stereo;
  593.     b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
  595.     GetWord( channel[0].i_predictor );
  596.     GetByte( channel[0].i_step_index );
  597.     CLAMP( channel[0].i_step_index, 0, 88 );
  598.     p_buffer++;
  600.     if( b_stereo )
  601.     {
  602.         GetWord( channel[1].i_predictor );
  603.         GetByte( channel[1].i_step_index );
  604.         CLAMP( channel[1].i_step_index, 0, 88 );
  605.         p_buffer++;
  606.     }
  608.     /* first output predictor */
  609.     *p_sample++ = channel[0].i_predictor;
  610.     if( b_stereo )
  611.     {
  612.         *p_sample++ = channel[1].i_predictor;
  613.     }
  615.     for( i_nibbles = 0;
  616.          i_nibbles < p_sys->i_block - 4 * (b_stereo ? 2:1 );
  617.          i_nibbles++ )
  618.     {
  619.         *p_sample++ = AdpcmImaWavExpandNibble( &channel[0],
  620.                                               (*p_buffer) >> 4);
  621.         *p_sample++ = AdpcmImaWavExpandNibble( &channel[b_stereo ? 1 : 0],
  622.                                                (*p_buffer)&0x0f);
  624.         p_buffer++;
  625.     }
  626. }
  628. /*
  629.  * Dk3
  630.  */
  631. static void DecodeAdpcmDk3( decoder_t *p_dec, int16_t *p_sample,
  632.                             uint8_t *p_buffer )
  633. {
  634.     decoder_sys_t *p_sys  = p_dec->p_sys;
  635.     uint8_t                 *p_end = &p_buffer[p_sys->i_block];
  636.     adpcm_ima_wav_channel_t sum;
  637.     adpcm_ima_wav_channel_t diff;
  638.     int                     i_diff_value;
  640.     p_buffer += 10;
  642.     GetWord( sum.i_predictor );
  643.     GetWord( diff.i_predictor );
  644.     GetByte( sum.i_step_index );
  645.     GetByte( diff.i_step_index );
  647.     i_diff_value = diff.i_predictor;
  648.     /* we process 6 nibbles at once */
  649.     while( p_buffer + 1 <= p_end )
  650.     {
  651.         /* first 3 nibbles */
  652.         AdpcmImaWavExpandNibble( &sum,
  653.                                  (*p_buffer)&0x0f);
  655.         AdpcmImaWavExpandNibble( &diff,
  656.                                  (*p_buffer) >> 4 );
  658.         i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
  660.         *p_sample++ = sum.i_predictor + i_diff_value;
  661.         *p_sample++ = sum.i_predictor - i_diff_value;
  663.         p_buffer++;
  665.         AdpcmImaWavExpandNibble( &sum,
  666.                                  (*p_buffer)&0x0f);
  668.         *p_sample++ = sum.i_predictor + i_diff_value;
  669.         *p_sample++ = sum.i_predictor - i_diff_value;
  671.         /* now last 3 nibbles */
  672.         AdpcmImaWavExpandNibble( &sum,
  673.                                  (*p_buffer)>>4);
  674.         p_buffer++;
  675.         if( p_buffer < p_end )
  676.         {
  677.             AdpcmImaWavExpandNibble( &diff,
  678.                                      (*p_buffer)&0x0f );
  680.             i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
  682.             *p_sample++ = sum.i_predictor + i_diff_value;
  683.             *p_sample++ = sum.i_predictor - i_diff_value;
  685.             AdpcmImaWavExpandNibble( &sum,
  686.                                      (*p_buffer)>>4);
  687.             p_buffer++;
  689.             *p_sample++ = sum.i_predictor + i_diff_value;
  690.             *p_sample++ = sum.i_predictor - i_diff_value;
  691.         }
  692.     }
  693. }