git.sesse.net Git - vlc/blob - modules/codec/adpcm.c

   1 /*****************************************************************************
   2  * adpcm.c : adpcm variant audio decoder
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Rémi Denis-Courmont <rem # videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *
  28  * Documentation: http://www.pcisys.net/~melanson/codecs/adpcm.txt
  29  *****************************************************************************/
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_aout.h>
  37 #include <vlc_codec.h>
  38
  39 /*****************************************************************************
  40  * Module descriptor
  41  *****************************************************************************/
  42 static int  OpenDecoder( vlc_object_t * );
  43 static void CloseDecoder( vlc_object_t * );
  44
  45 static aout_buffer_t *DecodeBlock( decoder_t *, block_t ** );
  46
  47 vlc_module_begin ()
  48     set_description( N_("ADPCM audio decoder") )
  49     set_capability( "decoder", 50 )
  50     set_category( CAT_INPUT )
  51     set_subcategory( SUBCAT_INPUT_ACODEC )
  52     set_callbacks( OpenDecoder, CloseDecoder )
  53 vlc_module_end ()
  54
  55 /*****************************************************************************
  56  * Local prototypes
  57  *****************************************************************************/
  58 enum adpcm_codec_e
  59 {
  60     ADPCM_IMA_QT,
  61     ADPCM_IMA_WAV,
  62     ADPCM_MS,
  63     ADPCM_DK3,
  64     ADPCM_DK4,
  65     ADPCM_EA
  66 };
  67
  68 struct decoder_sys_t
  69 {
  70     enum adpcm_codec_e codec;
  71
  72     size_t              i_block;
  73     size_t              i_samplesperblock;
  74
  75     audio_date_t        end_date;
  76 };
  77
  78 static void DecodeAdpcmMs    ( decoder_t *, int16_t *, uint8_t * );
  79 static void DecodeAdpcmImaWav( decoder_t *, int16_t *, uint8_t * );
  80 static void DecodeAdpcmImaQT ( decoder_t *, int16_t *, uint8_t * );
  81 static void DecodeAdpcmDk4   ( decoder_t *, int16_t *, uint8_t * );
  82 static void DecodeAdpcmDk3   ( decoder_t *, int16_t *, uint8_t * );
  83 static void DecodeAdpcmEA    ( decoder_t *, int16_t *, uint8_t * );
  84
  85 static const int pi_channels_maps[6] =
  86 {
  87     0,
  88     AOUT_CHAN_CENTER,
  89     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  90     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER,
  91     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT,
  92     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
  93      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARLEFT
  94 };
  95
  96 /* Various table from http://www.pcisys.net/~melanson/codecs/adpcm.txt */
  97 static const int i_index_table[16] =
  98 {
  99     -1, -1, -1, -1, 2, 4, 6, 8,
 100     -1, -1, -1, -1, 2, 4, 6, 8
 101 };
 102
 103 static const int i_step_table[89] =
 104 {
 105     7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
 106     19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
 107     50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
 108     130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
 109     337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
 110     876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
 111     2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
 112     5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
 113     15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
 114 };
 115
 116 static const int i_adaptation_table[16] =
 117 {
 118     230, 230, 230, 230, 307, 409, 512, 614,
 119     768, 614, 512, 409, 307, 230, 230, 230
 120 };
 121
 122 static const int i_adaptation_coeff1[7] =
 123 {
 124     256, 512, 0, 192, 240, 460, 392
 125 };
 126
 127 static const int i_adaptation_coeff2[7] =
 128 {
 129     0, -256, 0, 64, 0, -208, -232
 130 };
 131
 132 /*****************************************************************************
 133  * OpenDecoder: probe the decoder and return score
 134  *****************************************************************************/
 135 static int OpenDecoder( vlc_object_t *p_this )
 136 {
 137     decoder_t *p_dec = (decoder_t*)p_this;
 138     decoder_sys_t *p_sys;
 139
 140     switch( p_dec->fmt_in.i_codec )
 141     {
 142         case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
 143         case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
 144         case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
 145         case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
 146         case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
 147         case VLC_FOURCC('X','A','J', 0): /* EA ADPCM */
 148             break;
 149         default:
 150             return VLC_EGENERIC;
 151     }
 152
 153     if( p_dec->fmt_in.audio.i_channels <= 0 ||
 154         p_dec->fmt_in.audio.i_channels > 5 )
 155     {
 156         msg_Err( p_dec, "invalid number of channel (not between 1 and 5): %i",
 157                  p_dec->fmt_in.audio.i_channels );
 158         return VLC_EGENERIC;
 159     }
 160
 161     if( p_dec->fmt_in.audio.i_rate <= 0 )
 162     {
 163         msg_Err( p_dec, "bad samplerate" );
 164         return VLC_EGENERIC;
 165     }
 166
 167     /* Allocate the memory needed to store the decoder's structure */
 168     if( ( p_dec->p_sys = p_sys =
 169           (decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
 170         return VLC_ENOMEM;
 171
 172     switch( p_dec->fmt_in.i_codec )
 173     {
 174         case VLC_FOURCC('i','m','a', '4'): /* IMA ADPCM */
 175             p_sys->codec = ADPCM_IMA_QT;
 176             break;
 177         case VLC_FOURCC('m','s',0x00,0x11): /* IMA ADPCM */
 178             p_sys->codec = ADPCM_IMA_WAV;
 179             break;
 180         case VLC_FOURCC('m','s',0x00,0x02): /* MS ADPCM */
 181             p_sys->codec = ADPCM_MS;
 182             break;
 183         case VLC_FOURCC('m','s',0x00,0x61): /* Duck DK4 ADPCM */
 184             p_sys->codec = ADPCM_DK4;
 185             break;
 186         case VLC_FOURCC('m','s',0x00,0x62): /* Duck DK3 ADPCM */
 187             p_sys->codec = ADPCM_DK3;
 188             break;
 189         case VLC_FOURCC('X','A','J', 0): /* EA ADPCM */
 190             p_sys->codec = ADPCM_EA;
 191             p_dec->fmt_in.p_extra = calloc( 2 * p_dec->fmt_in.audio.i_channels,
 192                                             sizeof( int16_t ) );
 193             if( p_dec->fmt_in.p_extra == NULL )
 194             {
 195                 free( p_sys );
 196                 return VLC_ENOMEM;
 197             }
 198             break;
 199     }
 200
 201     if( p_dec->fmt_in.audio.i_blockalign <= 0 )
 202     {
 203         p_sys->i_block = (p_sys->codec == ADPCM_IMA_QT) ?
 204             34 * p_dec->fmt_in.audio.i_channels : 1024;
 205         msg_Warn( p_dec, "block size undefined, using %zu", p_sys->i_block );
 206     }
 207     else
 208     {
 209         p_sys->i_block = p_dec->fmt_in.audio.i_blockalign;
 210     }
 211
 212     /* calculate samples per block */
 213     switch( p_sys->codec )
 214     {
 215     case ADPCM_IMA_QT:
 216         p_sys->i_samplesperblock = 64;
 217         break;
 218     case ADPCM_IMA_WAV:
 219         p_sys->i_samplesperblock =
 220             2 * ( p_sys->i_block - 4 * p_dec->fmt_in.audio.i_channels ) /
 221             p_dec->fmt_in.audio.i_channels;
 222         break;
 223     case ADPCM_MS:
 224         p_sys->i_samplesperblock =
 225             2 * (p_sys->i_block - 7 * p_dec->fmt_in.audio.i_channels) /
 226             p_dec->fmt_in.audio.i_channels + 2;
 227         break;
 228     case ADPCM_DK4:
 229         p_sys->i_samplesperblock =
 230             2 * (p_sys->i_block - 4 * p_dec->fmt_in.audio.i_channels) /
 231             p_dec->fmt_in.audio.i_channels + 1;
 232         break;
 233     case ADPCM_DK3:
 234         p_dec->fmt_in.audio.i_channels = 2;
 235         p_sys->i_samplesperblock = ( 4 * ( p_sys->i_block - 16 ) + 2 )/ 3;
 236         break;
 237     case ADPCM_EA:
 238         p_sys->i_samplesperblock =
 239             2 * (p_sys->i_block - p_dec->fmt_in.audio.i_channels) /
 240             p_dec->fmt_in.audio.i_channels;
 241     }
 242
 243     msg_Dbg( p_dec, "format: samplerate:%d Hz channels:%d bits/sample:%d "
 244              "blockalign:%zu samplesperblock:%zu",
 245              p_dec->fmt_in.audio.i_rate, p_dec->fmt_in.audio.i_channels,
 246              p_dec->fmt_in.audio.i_bitspersample, p_sys->i_block,
 247              p_sys->i_samplesperblock );
 248
 249     p_dec->fmt_out.i_codec = AOUT_FMT_S16_NE;
 250     p_dec->fmt_out.audio.i_rate = p_dec->fmt_in.audio.i_rate;
 251     p_dec->fmt_out.audio.i_channels = p_dec->fmt_in.audio.i_channels;
 252     p_dec->fmt_out.audio.i_physical_channels =
 253         p_dec->fmt_out.audio.i_original_channels =
 254             pi_channels_maps[p_dec->fmt_in.audio.i_channels];
 255
 256     aout_DateInit( &p_sys->end_date, p_dec->fmt_out.audio.i_rate );
 257     aout_DateSet( &p_sys->end_date, 0 );
 258
 259     p_dec->pf_decode_audio = DecodeBlock;
 260
 261     return VLC_SUCCESS;
 262 }
 263
 264 /*****************************************************************************
 265  * DecodeBlock:
 266  *****************************************************************************/
 267 static aout_buffer_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 268 {
 269     decoder_sys_t *p_sys  = p_dec->p_sys;
 270     block_t *p_block;
 271
 272     if( !pp_block || !*pp_block ) return NULL;
 273
 274     p_block = *pp_block;
 275
 276     if( p_block->i_pts != 0 &&
 277         p_block->i_pts != aout_DateGet( &p_sys->end_date ) )
 278     {
 279         aout_DateSet( &p_sys->end_date, p_block->i_pts );
 280     }
 281     else if( !aout_DateGet( &p_sys->end_date ) )
 282     {
 283         /* We've just started the stream, wait for the first PTS. */
 284         block_Release( p_block );
 285         return NULL;
 286     }
 287
 288     /* Don't re-use the same pts twice */
 289     p_block->i_pts = 0;
 290
 291     if( p_block->i_buffer >= p_sys->i_block )
 292     {
 293         aout_buffer_t *p_out;
 294
 295         p_out = decoder_NewAudioBuffer( p_dec, p_sys->i_samplesperblock );
 296         if( p_out == NULL )
 297         {
 298             block_Release( p_block );
 299             return NULL;
 300         }
 301
 302         p_out->start_date = aout_DateGet( &p_sys->end_date );
 303         p_out->end_date =
 304             aout_DateIncrement( &p_sys->end_date, p_sys->i_samplesperblock );
 305
 306         switch( p_sys->codec )
 307         {
 308         case ADPCM_IMA_QT:
 309             DecodeAdpcmImaQT( p_dec, (int16_t*)p_out->p_buffer,
 310                               p_block->p_buffer );
 311             break;
 312         case ADPCM_IMA_WAV:
 313             DecodeAdpcmImaWav( p_dec, (int16_t*)p_out->p_buffer,
 314                                p_block->p_buffer );
 315             break;
 316         case ADPCM_MS:
 317             DecodeAdpcmMs( p_dec, (int16_t*)p_out->p_buffer,
 318                            p_block->p_buffer );
 319             break;
 320         case ADPCM_DK4:
 321             DecodeAdpcmDk4( p_dec, (int16_t*)p_out->p_buffer,
 322                             p_block->p_buffer );
 323             break;
 324         case ADPCM_DK3:
 325             DecodeAdpcmDk3( p_dec, (int16_t*)p_out->p_buffer,
 326                             p_block->p_buffer );
 327             break;
 328         case ADPCM_EA:
 329             DecodeAdpcmEA( p_dec, (int16_t*)p_out->p_buffer,
 330                            p_block->p_buffer );
 331         default:
 332             break;
 333         }
 334
 335         p_block->p_buffer += p_sys->i_block;
 336         p_block->i_buffer -= p_sys->i_block;
 337         return p_out;
 338     }
 339
 340     block_Release( p_block );
 341     return NULL;
 342 }
 343
 344 /*****************************************************************************
 345  * CloseDecoder:
 346  *****************************************************************************/
 347 static void CloseDecoder( vlc_object_t *p_this )
 348 {
 349     decoder_t *p_dec = (decoder_t *)p_this;
 350     decoder_sys_t *p_sys = p_dec->p_sys;
 351
 352     if( p_sys->codec == ADPCM_EA )
 353         free( p_dec->fmt_in.p_extra );
 354     free( p_sys );
 355 }
 356
 357 /*****************************************************************************
 358  * Local functions
 359  *****************************************************************************/
 360 #define CLAMP( v, min, max ) \
 361     if( (v) < (min) ) (v) = (min); \
 362     if( (v) > (max) ) (v) = (max)
 363
 364 #define GetByte( v ) \
 365     (v) = *p_buffer; p_buffer++;
 366
 367 #define GetWord( v ) \
 368     (v) = *p_buffer; p_buffer++; \
 369     (v) |= ( *p_buffer ) << 8; p_buffer++; \
 370     if( (v)&0x8000 ) (v) -= 0x010000;
 371
 372 /*
 373  * MS
 374  */
 375 typedef struct adpcm_ms_channel_s
 376 {
 377     int i_idelta;
 378     int i_sample1, i_sample2;
 379     int i_coeff1, i_coeff2;
 380
 381 } adpcm_ms_channel_t;
 382
 383
 384 static int AdpcmMsExpandNibble(adpcm_ms_channel_t *p_channel,
 385                                int i_nibble )
 386 {
 387     int i_predictor;
 388     int i_snibble;
 389     /* expand sign */
 390
 391     i_snibble = i_nibble - ( i_nibble&0x08 ? 0x10 : 0 );
 392
 393     i_predictor = ( p_channel->i_sample1 * p_channel->i_coeff1 +
 394                     p_channel->i_sample2 * p_channel->i_coeff2 ) / 256 +
 395                   i_snibble * p_channel->i_idelta;
 396
 397     CLAMP( i_predictor, -32768, 32767 );
 398
 399     p_channel->i_sample2 = p_channel->i_sample1;
 400     p_channel->i_sample1 = i_predictor;
 401
 402     p_channel->i_idelta = ( i_adaptation_table[i_nibble] *
 403                             p_channel->i_idelta ) / 256;
 404     if( p_channel->i_idelta < 16 )
 405     {
 406         p_channel->i_idelta = 16;
 407     }
 408     return( i_predictor );
 409 }
 410
 411 static void DecodeAdpcmMs( decoder_t *p_dec, int16_t *p_sample,
 412                            uint8_t *p_buffer )
 413 {
 414     decoder_sys_t *p_sys  = p_dec->p_sys;
 415     adpcm_ms_channel_t channel[2];
 416     int i_nibbles;
 417     int b_stereo;
 418     int i_block_predictor;
 419
 420     b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
 421
 422     GetByte( i_block_predictor );
 423     CLAMP( i_block_predictor, 0, 6 );
 424     channel[0].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
 425     channel[0].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
 426
 427     if( b_stereo )
 428     {
 429         GetByte( i_block_predictor );
 430         CLAMP( i_block_predictor, 0, 6 );
 431         channel[1].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
 432         channel[1].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
 433     }
 434     GetWord( channel[0].i_idelta );
 435     if( b_stereo )
 436     {
 437         GetWord( channel[1].i_idelta );
 438     }
 439
 440     GetWord( channel[0].i_sample1 );
 441     if( b_stereo )
 442     {
 443         GetWord( channel[1].i_sample1 );
 444     }
 445
 446     GetWord( channel[0].i_sample2 );
 447     if( b_stereo )
 448     {
 449         GetWord( channel[1].i_sample2 );
 450     }
 451
 452     if( b_stereo )
 453     {
 454         *p_sample++ = channel[0].i_sample2;
 455         *p_sample++ = channel[1].i_sample2;
 456         *p_sample++ = channel[0].i_sample1;
 457         *p_sample++ = channel[1].i_sample1;
 458     }
 459     else
 460     {
 461         *p_sample++ = channel[0].i_sample2;
 462         *p_sample++ = channel[0].i_sample1;
 463     }
 464
 465     for( i_nibbles = 2 * (p_sys->i_block - 7 * p_dec->fmt_in.audio.i_channels);
 466          i_nibbles > 0; i_nibbles -= 2, p_buffer++ )
 467     {
 468         *p_sample++ = AdpcmMsExpandNibble( &channel[0], (*p_buffer) >> 4);
 469         *p_sample++ = AdpcmMsExpandNibble( &channel[b_stereo ? 1 : 0],
 470                                            (*p_buffer)&0x0f);
 471     }
 472 }
 473
 474 /*
 475  * IMA-WAV
 476  */
 477 typedef struct adpcm_ima_wav_channel_s
 478 {
 479     int i_predictor;
 480     int i_step_index;
 481
 482 } adpcm_ima_wav_channel_t;
 483
 484 static int AdpcmImaWavExpandNibble(adpcm_ima_wav_channel_t *p_channel,
 485                                    int i_nibble )
 486 {
 487     int i_diff;
 488
 489     i_diff = i_step_table[p_channel->i_step_index] >> 3;
 490     if( i_nibble&0x04 ) i_diff += i_step_table[p_channel->i_step_index];
 491     if( i_nibble&0x02 ) i_diff += i_step_table[p_channel->i_step_index]>>1;
 492     if( i_nibble&0x01 ) i_diff += i_step_table[p_channel->i_step_index]>>2;
 493     if( i_nibble&0x08 )
 494         p_channel->i_predictor -= i_diff;
 495     else
 496         p_channel->i_predictor += i_diff;
 497
 498     CLAMP( p_channel->i_predictor, -32768, 32767 );
 499
 500     p_channel->i_step_index += i_index_table[i_nibble];
 501
 502     CLAMP( p_channel->i_step_index, 0, 88 );
 503
 504     return( p_channel->i_predictor );
 505 }
 506
 507 static void DecodeAdpcmImaWav( decoder_t *p_dec, int16_t *p_sample,
 508                                uint8_t *p_buffer )
 509 {
 510     decoder_sys_t *p_sys  = p_dec->p_sys;
 511     adpcm_ima_wav_channel_t channel[2];
 512     int                     i_nibbles;
 513     int                     b_stereo;
 514
 515     b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
 516
 517     GetWord( channel[0].i_predictor );
 518     GetByte( channel[0].i_step_index );
 519     CLAMP( channel[0].i_step_index, 0, 88 );
 520     p_buffer++;
 521
 522     if( b_stereo )
 523     {
 524         GetWord( channel[1].i_predictor );
 525         GetByte( channel[1].i_step_index );
 526         CLAMP( channel[1].i_step_index, 0, 88 );
 527         p_buffer++;
 528     }
 529
 530     if( b_stereo )
 531     {
 532         for( i_nibbles = 2 * (p_sys->i_block - 8);
 533              i_nibbles > 0;
 534              i_nibbles -= 16 )
 535         {
 536             int i;
 537
 538             for( i = 0; i < 4; i++ )
 539             {
 540                 p_sample[i * 4] =
 541                     AdpcmImaWavExpandNibble(&channel[0],p_buffer[i]&0x0f);
 542                 p_sample[i * 4 + 2] =
 543                     AdpcmImaWavExpandNibble(&channel[0],p_buffer[i] >> 4);
 544             }
 545             p_buffer += 4;
 546
 547             for( i = 0; i < 4; i++ )
 548             {
 549                 p_sample[i * 4 + 1] =
 550                     AdpcmImaWavExpandNibble(&channel[1],p_buffer[i]&0x0f);
 551                 p_sample[i * 4 + 3] =
 552                     AdpcmImaWavExpandNibble(&channel[1],p_buffer[i] >> 4);
 553             }
 554             p_buffer += 4;
 555             p_sample += 16;
 556
 557         }
 558
 559
 560     }
 561     else
 562     {
 563         for( i_nibbles = 2 * (p_sys->i_block - 4);
 564              i_nibbles > 0;
 565              i_nibbles -= 2, p_buffer++ )
 566         {
 567             *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer)&0x0f );
 568             *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer) >> 4 );
 569         }
 570     }
 571 }
 572
 573 /*
 574  * Ima4 in QT file
 575  */
 576 static void DecodeAdpcmImaQT( decoder_t *p_dec, int16_t *p_sample,
 577                               uint8_t *p_buffer )
 578 {
 579     adpcm_ima_wav_channel_t channel[2];
 580     int                     i_nibbles;
 581     int                     i_ch;
 582     int                     i_step;
 583
 584     i_step = p_dec->fmt_in.audio.i_channels;
 585
 586     for( i_ch = 0; i_ch < p_dec->fmt_in.audio.i_channels; i_ch++ )
 587     {
 588         /* load preambule */
 589         channel[i_ch].i_predictor  = (int16_t)((( ( p_buffer[0] << 1 )|(  p_buffer[1] >> 7 ) ))<<7);
 590         channel[i_ch].i_step_index = p_buffer[1]&0x7f;
 591
 592         CLAMP( channel[i_ch].i_step_index, 0, 88 );
 593         p_buffer += 2;
 594
 595         for( i_nibbles = 0; i_nibbles < 64; i_nibbles +=2 )
 596         {
 597             *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer)&0x0f);
 598             p_sample += i_step;
 599
 600             *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer >> 4)&0x0f);
 601             p_sample += i_step;
 602
 603             p_buffer++;
 604         }
 605
 606         /* Next channel */
 607         p_sample += 1 - 64 * i_step;
 608     }
 609 }
 610
 611 /*
 612  * Dk4
 613  */
 614 static void DecodeAdpcmDk4( decoder_t *p_dec, int16_t *p_sample,
 615                             uint8_t *p_buffer )
 616 {
 617     decoder_sys_t *p_sys  = p_dec->p_sys;
 618     adpcm_ima_wav_channel_t channel[2];
 619     size_t                  i_nibbles;
 620     int                     b_stereo;
 621
 622     b_stereo = p_dec->fmt_in.audio.i_channels == 2 ? 1 : 0;
 623
 624     GetWord( channel[0].i_predictor );
 625     GetByte( channel[0].i_step_index );
 626     CLAMP( channel[0].i_step_index, 0, 88 );
 627     p_buffer++;
 628
 629     if( b_stereo )
 630     {
 631         GetWord( channel[1].i_predictor );
 632         GetByte( channel[1].i_step_index );
 633         CLAMP( channel[1].i_step_index, 0, 88 );
 634         p_buffer++;
 635     }
 636
 637     /* first output predictor */
 638     *p_sample++ = channel[0].i_predictor;
 639     if( b_stereo )
 640     {
 641         *p_sample++ = channel[1].i_predictor;
 642     }
 643
 644     for( i_nibbles = 0;
 645          i_nibbles < p_sys->i_block - 4 * (b_stereo ? 2:1 );
 646          i_nibbles++ )
 647     {
 648         *p_sample++ = AdpcmImaWavExpandNibble( &channel[0],
 649                                               (*p_buffer) >> 4);
 650         *p_sample++ = AdpcmImaWavExpandNibble( &channel[b_stereo ? 1 : 0],
 651                                                (*p_buffer)&0x0f);
 652
 653         p_buffer++;
 654     }
 655 }
 656
 657 /*
 658  * Dk3
 659  */
 660 static void DecodeAdpcmDk3( decoder_t *p_dec, int16_t *p_sample,
 661                             uint8_t *p_buffer )
 662 {
 663     decoder_sys_t *p_sys  = p_dec->p_sys;
 664     uint8_t                 *p_end = &p_buffer[p_sys->i_block];
 665     adpcm_ima_wav_channel_t sum;
 666     adpcm_ima_wav_channel_t diff;
 667     int                     i_diff_value;
 668
 669     p_buffer += 10;
 670
 671     GetWord( sum.i_predictor );
 672     GetWord( diff.i_predictor );
 673     GetByte( sum.i_step_index );
 674     GetByte( diff.i_step_index );
 675
 676     i_diff_value = diff.i_predictor;
 677     /* we process 6 nibbles at once */
 678     while( p_buffer + 1 <= p_end )
 679     {
 680         /* first 3 nibbles */
 681         AdpcmImaWavExpandNibble( &sum,
 682                                  (*p_buffer)&0x0f);
 683
 684         AdpcmImaWavExpandNibble( &diff,
 685                                  (*p_buffer) >> 4 );
 686
 687         i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
 688
 689         *p_sample++ = sum.i_predictor + i_diff_value;
 690         *p_sample++ = sum.i_predictor - i_diff_value;
 691
 692         p_buffer++;
 693
 694         AdpcmImaWavExpandNibble( &sum,
 695                                  (*p_buffer)&0x0f);
 696
 697         *p_sample++ = sum.i_predictor + i_diff_value;
 698         *p_sample++ = sum.i_predictor - i_diff_value;
 699
 700         /* now last 3 nibbles */
 701         AdpcmImaWavExpandNibble( &sum,
 702                                  (*p_buffer)>>4);
 703         p_buffer++;
 704         if( p_buffer < p_end )
 705         {
 706             AdpcmImaWavExpandNibble( &diff,
 707                                      (*p_buffer)&0x0f );
 708
 709             i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
 710
 711             *p_sample++ = sum.i_predictor + i_diff_value;
 712             *p_sample++ = sum.i_predictor - i_diff_value;
 713
 714             AdpcmImaWavExpandNibble( &sum,
 715                                      (*p_buffer)>>4);
 716             p_buffer++;
 717
 718             *p_sample++ = sum.i_predictor + i_diff_value;
 719             *p_sample++ = sum.i_predictor - i_diff_value;
 720         }
 721     }
 722 }
 723
 724
 725 /*
 726  * EA ADPCM
 727  */
 728 #define MAX_CHAN 5
 729 static void DecodeAdpcmEA( decoder_t *p_dec, int16_t *p_sample,
 730                            uint8_t *p_buffer )
 731 {
 732     static const uint32_t EATable[]=
 733     {
 734         0x00000000, 0x000000F0, 0x000001CC, 0x00000188,
 735         0x00000000, 0x00000000, 0xFFFFFF30, 0xFFFFFF24,
 736         0x00000000, 0x00000001, 0x00000003, 0x00000004,
 737         0x00000007, 0x00000008, 0x0000000A, 0x0000000B,
 738         0x00000000, 0xFFFFFFFF, 0xFFFFFFFD, 0xFFFFFFFC
 739     };
 740     decoder_sys_t *p_sys  = p_dec->p_sys;
 741     uint8_t *p_end;
 742     unsigned i_channels, c;
 743     int16_t *prev, *cur;
 744     int32_t c1[MAX_CHAN], c2[MAX_CHAN];
 745     int8_t d[MAX_CHAN];
 746
 747     i_channels = p_dec->fmt_in.audio.i_channels;
 748     p_end = &p_buffer[p_sys->i_block];
 749
 750     prev = (int16_t *)p_dec->fmt_in.p_extra;
 751     cur = prev + i_channels;
 752
 753     for (c = 0; c < i_channels; c++)
 754     {
 755         uint8_t input;
 756
 757         input = p_buffer[c];
 758         c1[c] = EATable[input >> 4];
 759         c2[c] = EATable[(input >> 4) + 4];
 760         d[c] = (input & 0xf) + 8;
 761     }
 762
 763     for( p_buffer += i_channels; p_buffer < p_end ; p_buffer += i_channels)
 764     {
 765         for (c = 0; c < i_channels; c++)
 766         {
 767             int32_t spl;
 768
 769             spl = (p_buffer[c] >> 4) & 0xf;
 770             spl = (spl << 0x1c) >> d[c];
 771             spl = (spl + cur[c] * c1[c] + prev[c] * c2[c] + 0x80) >> 8;
 772             CLAMP( spl, -32768, 32767 );
 773             prev[c] = cur[c];
 774             cur[c] = spl;
 775
 776             *(p_sample++) = spl;
 777         }
 778
 779         for (c = 0; c < i_channels; c++)
 780         {
 781             int32_t spl;
 782
 783             spl = p_buffer[c] & 0xf;
 784             spl = (spl << 0x1c) >> d[c];
 785             spl = (spl + cur[c] * c1[c] + prev[c] * c2[c] + 0x80) >> 8;
 786             CLAMP( spl, -32768, 32767 );
 787             prev[c] = cur[c];
 788             cur[c] = spl;
 789
 790             *(p_sample++) = spl;
 791         }
 792     }
 793 }