modules/codec/adpcm.c

   1 /*****************************************************************************
   2  * adpcm.c : adpcm variant audio decoder
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VLC authors and VideoLAN
   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 it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * 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_codec.h>
  37
  38 /*****************************************************************************
  39  * Module descriptor
  40  *****************************************************************************/
  41 static int  OpenDecoder( vlc_object_t * );
  42 static void CloseDecoder( vlc_object_t * );
  43
  44 static int DecodeAudio( decoder_t *, block_t * );
  45 static void Flush( decoder_t * );
  46
  47 vlc_module_begin ()
  48     set_description( N_("ADPCM audio decoder") )
  49     set_capability( "audio 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 typedef struct
  69 {
  70     enum adpcm_codec_e codec;
  71
  72     size_t              i_block;
  73     size_t              i_samplesperblock;
  74
  75     date_t              end_date;
  76     int16_t            *prev;
  77 } decoder_sys_t;
  78
  79 static void DecodeAdpcmMs    ( decoder_t *, int16_t *, uint8_t * );
  80 static void DecodeAdpcmImaWav( decoder_t *, int16_t *, uint8_t * );
  81 static void DecodeAdpcmImaQT ( decoder_t *, int16_t *, uint8_t * );
  82 static void DecodeAdpcmDk4   ( decoder_t *, int16_t *, uint8_t * );
  83 static void DecodeAdpcmDk3   ( decoder_t *, int16_t *, uint8_t * );
  84 static void DecodeAdpcmEA    ( decoder_t *, int16_t *, uint8_t * );
  85
  86 /* Various table from http://www.pcisys.net/~melanson/codecs/adpcm.txt */
  87 static const int i_index_table[16] =
  88 {
  89     -1, -1, -1, -1, 2, 4, 6, 8,
  90     -1, -1, -1, -1, 2, 4, 6, 8
  91 };
  92
  93 static const int i_step_table[89] =
  94 {
  95     7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
  96     19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
  97     50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
  98     130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
  99     337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
 100     876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
 101     2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
 102     5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
 103     15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
 104 };
 105
 106 static const int i_adaptation_table[16] =
 107 {
 108     230, 230, 230, 230, 307, 409, 512, 614,
 109     768, 614, 512, 409, 307, 230, 230, 230
 110 };
 111
 112 static const int i_adaptation_coeff1[7] =
 113 {
 114     256, 512, 0, 192, 240, 460, 392
 115 };
 116
 117 static const int i_adaptation_coeff2[7] =
 118 {
 119     0, -256, 0, 64, 0, -208, -232
 120 };
 121
 122 /*****************************************************************************
 123  * OpenDecoder: probe the decoder and return score
 124  *****************************************************************************/
 125 static int OpenDecoder( vlc_object_t *p_this )
 126 {
 127     decoder_t *p_dec = (decoder_t*)p_this;
 128     decoder_sys_t *p_sys;
 129
 130     switch( p_dec->fmt_in.i_codec )
 131     {
 132         case VLC_CODEC_ADPCM_IMA_QT:
 133         case VLC_CODEC_ADPCM_IMA_WAV:
 134         case VLC_CODEC_ADPCM_MS:
 135         case VLC_CODEC_ADPCM_DK4:
 136         case VLC_CODEC_ADPCM_DK3:
 137         case VLC_CODEC_ADPCM_XA_EA:
 138             break;
 139         default:
 140             return VLC_EGENERIC;
 141     }
 142
 143     if( p_dec->fmt_in.audio.i_rate <= 0 )
 144     {
 145         msg_Err( p_dec, "bad samplerate" );
 146         return VLC_EGENERIC;
 147     }
 148
 149     /* Allocate the memory needed to store the decoder's structure */
 150     p_sys = malloc(sizeof(*p_sys));
 151     if( unlikely(p_sys == NULL) )
 152         return VLC_ENOMEM;
 153
 154     p_sys->prev = NULL;
 155     p_sys->i_samplesperblock = 0;
 156
 157     unsigned i_channels = p_dec->fmt_in.audio.i_channels;
 158     uint8_t i_max_channels = 5;
 159     switch( p_dec->fmt_in.i_codec )
 160     {
 161         case VLC_CODEC_ADPCM_IMA_QT: /* IMA ADPCM */
 162             p_sys->codec = ADPCM_IMA_QT;
 163             i_max_channels = 2;
 164             break;
 165         case VLC_CODEC_ADPCM_IMA_WAV: /* IMA ADPCM */
 166             p_sys->codec = ADPCM_IMA_WAV;
 167             i_max_channels = 2;
 168             break;
 169         case VLC_CODEC_ADPCM_MS: /* MS ADPCM */
 170             p_sys->codec = ADPCM_MS;
 171             i_max_channels = 2;
 172             break;
 173         case VLC_CODEC_ADPCM_DK4: /* Duck DK4 ADPCM */
 174             p_sys->codec = ADPCM_DK4;
 175             i_max_channels = 2;
 176             break;
 177         case VLC_CODEC_ADPCM_DK3: /* Duck DK3 ADPCM */
 178             p_sys->codec = ADPCM_DK3;
 179             i_max_channels = 2;
 180             break;
 181         case VLC_CODEC_ADPCM_XA_EA: /* EA ADPCM */
 182             p_sys->codec = ADPCM_EA;
 183             p_sys->prev = calloc( 2 * p_dec->fmt_in.audio.i_channels,
 184                                   sizeof( int16_t ) );
 185             if( unlikely(p_sys->prev == NULL) )
 186             {
 187                 free( p_sys );
 188                 return VLC_ENOMEM;
 189             }
 190             break;
 191     }
 192
 193     if (i_channels > i_max_channels || i_channels == 0)
 194     {
 195         free(p_sys->prev);
 196         free(p_sys);
 197         msg_Err( p_dec, "Invalid number of channels %i", p_dec->fmt_in.audio.i_channels );
 198         return VLC_EGENERIC;
 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         if( p_sys->i_block >= 4 * i_channels )
 220         {
 221             p_sys->i_samplesperblock = 2 * ( p_sys->i_block - 4 * i_channels )
 222                                      / i_channels;
 223         }
 224         break;
 225     case ADPCM_MS:
 226         if( p_sys->i_block >= 7 * i_channels )
 227         {
 228             p_sys->i_samplesperblock =
 229                 2 * (p_sys->i_block - 7 * i_channels) / i_channels + 2;
 230         }
 231         break;
 232     case ADPCM_DK4:
 233         if( p_sys->i_block >= 4 * i_channels )
 234         {
 235             p_sys->i_samplesperblock =
 236                 2 * (p_sys->i_block - 4 * i_channels) / i_channels + 1;
 237         }
 238         break;
 239     case ADPCM_DK3:
 240         i_channels = 2;
 241         if( p_sys->i_block >= 16 )
 242             p_sys->i_samplesperblock = ( 4 * ( p_sys->i_block - 16 ) + 2 )/ 3;
 243         break;
 244     case ADPCM_EA:
 245         if( p_sys->i_block >= i_channels )
 246         {
 247             p_sys->i_samplesperblock =
 248                 2 * (p_sys->i_block - i_channels) / i_channels;
 249         }
 250     }
 251
 252     msg_Dbg( p_dec, "format: samplerate:%d Hz channels:%d bits/sample:%d "
 253              "blockalign:%zu samplesperblock:%zu",
 254              p_dec->fmt_in.audio.i_rate, i_channels,
 255              p_dec->fmt_in.audio.i_bitspersample, p_sys->i_block,
 256              p_sys->i_samplesperblock );
 257
 258     if (p_sys->i_samplesperblock == 0)
 259     {
 260         free(p_sys->prev);
 261         free(p_sys);
 262         msg_Err( p_dec, "Error computing number of samples per block");
 263         return VLC_EGENERIC;
 264     }
 265
 266     p_dec->p_sys = p_sys;
 267     p_dec->fmt_out.i_codec = VLC_CODEC_S16N;
 268     p_dec->fmt_out.audio.i_rate = p_dec->fmt_in.audio.i_rate;
 269     p_dec->fmt_out.audio.i_channels = i_channels;
 270     p_dec->fmt_out.audio.i_physical_channels = vlc_chan_maps[i_channels];
 271
 272     date_Init( &p_sys->end_date, p_dec->fmt_out.audio.i_rate, 1 );
 273
 274     p_dec->pf_decode = DecodeAudio;
 275     p_dec->pf_flush  = Flush;
 276
 277     return VLC_SUCCESS;
 278 }
 279
 280 /*****************************************************************************
 281  * Flush:
 282  *****************************************************************************/
 283 static void Flush( decoder_t *p_dec )
 284 {
 285     decoder_sys_t *p_sys = p_dec->p_sys;
 286
 287     date_Set( &p_sys->end_date, VLC_TICK_INVALID );
 288 }
 289
 290 /*****************************************************************************
 291  * DecodeBlock:
 292  *****************************************************************************/
 293 static block_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 294 {
 295     decoder_sys_t *p_sys  = p_dec->p_sys;
 296     block_t *p_block;
 297
 298     if( !*pp_block ) return NULL;
 299
 300     p_block = *pp_block;
 301
 302     if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 303     {
 304         Flush( p_dec );
 305         if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
 306             goto drop;
 307     }
 308
 309     if( p_block->i_pts != VLC_TICK_INVALID &&
 310         p_block->i_pts != date_Get( &p_sys->end_date ) )
 311     {
 312         date_Set( &p_sys->end_date, p_block->i_pts );
 313     }
 314     else if( date_Get( &p_sys->end_date ) == VLC_TICK_INVALID )
 315         /* We've just started the stream, wait for the first PTS. */
 316         goto drop;
 317
 318     /* Don't re-use the same pts twice */
 319     p_block->i_pts = VLC_TICK_INVALID;
 320
 321     if( p_block->i_buffer >= p_sys->i_block )
 322     {
 323         block_t *p_out;
 324
 325         if( decoder_UpdateAudioFormat( p_dec ) )
 326             goto drop;
 327         p_out = decoder_NewAudioBuffer( p_dec, p_sys->i_samplesperblock );
 328         if( p_out == NULL )
 329             goto drop;
 330
 331         p_out->i_pts = date_Get( &p_sys->end_date );
 332         p_out->i_length = date_Increment( &p_sys->end_date,
 333                                      p_sys->i_samplesperblock ) - p_out->i_pts;
 334
 335         switch( p_sys->codec )
 336         {
 337         case ADPCM_IMA_QT:
 338             DecodeAdpcmImaQT( p_dec, (int16_t*)p_out->p_buffer,
 339                               p_block->p_buffer );
 340             break;
 341         case ADPCM_IMA_WAV:
 342             DecodeAdpcmImaWav( p_dec, (int16_t*)p_out->p_buffer,
 343                                p_block->p_buffer );
 344             break;
 345         case ADPCM_MS:
 346             DecodeAdpcmMs( p_dec, (int16_t*)p_out->p_buffer,
 347                            p_block->p_buffer );
 348             break;
 349         case ADPCM_DK4:
 350             DecodeAdpcmDk4( p_dec, (int16_t*)p_out->p_buffer,
 351                             p_block->p_buffer );
 352             break;
 353         case ADPCM_DK3:
 354             DecodeAdpcmDk3( p_dec, (int16_t*)p_out->p_buffer,
 355                             p_block->p_buffer );
 356             break;
 357         case ADPCM_EA:
 358             DecodeAdpcmEA( p_dec, (int16_t*)p_out->p_buffer,
 359                            p_block->p_buffer );
 360         default:
 361             break;
 362         }
 363
 364         p_block->p_buffer += p_sys->i_block;
 365         p_block->i_buffer -= p_sys->i_block;
 366         return p_out;
 367     }
 368
 369 drop:
 370     block_Release( p_block );
 371     *pp_block = NULL;
 372     return NULL;
 373 }
 374
 375 static int DecodeAudio( decoder_t *p_dec, block_t *p_block )
 376 {
 377     if( p_block == NULL ) /* No Drain */
 378         return VLCDEC_SUCCESS;
 379
 380     block_t **pp_block = &p_block, *p_out;
 381     while( ( p_out = DecodeBlock( p_dec, pp_block ) ) != NULL )
 382         decoder_QueueAudio( p_dec, p_out );
 383     return VLCDEC_SUCCESS;
 384 }
 385
 386 /*****************************************************************************
 387  * CloseDecoder:
 388  *****************************************************************************/
 389 static void CloseDecoder( vlc_object_t *p_this )
 390 {
 391     decoder_t *p_dec = (decoder_t *)p_this;
 392     decoder_sys_t *p_sys = p_dec->p_sys;
 393
 394     free( p_sys->prev );
 395     free( p_sys );
 396 }
 397
 398 /*****************************************************************************
 399  * Local functions
 400  *****************************************************************************/
 401 #define CLAMP( v, min, max ) \
 402     if( (v) < (min) ) (v) = (min); \
 403     if( (v) > (max) ) (v) = (max)
 404
 405 #define GetByte( v ) \
 406     (v) = *p_buffer; p_buffer++;
 407
 408 #define GetWord( v ) \
 409     (v) = *p_buffer; p_buffer++; \
 410     (v) |= ( *p_buffer ) << 8; p_buffer++; \
 411     if( (v)&0x8000 ) (v) -= 0x010000;
 412
 413 /*
 414  * MS
 415  */
 416 typedef struct adpcm_ms_channel_s
 417 {
 418     int i_idelta;
 419     int i_sample1, i_sample2;
 420     int i_coeff1, i_coeff2;
 421
 422 } adpcm_ms_channel_t;
 423
 424
 425 static int AdpcmMsExpandNibble(adpcm_ms_channel_t *p_channel,
 426                                int i_nibble )
 427 {
 428     int i_predictor;
 429     int i_snibble;
 430     /* expand sign */
 431
 432     i_snibble = i_nibble - ( i_nibble&0x08 ? 0x10 : 0 );
 433
 434     i_predictor = ( p_channel->i_sample1 * p_channel->i_coeff1 +
 435                     p_channel->i_sample2 * p_channel->i_coeff2 ) / 256 +
 436                   i_snibble * p_channel->i_idelta;
 437
 438     CLAMP( i_predictor, -32768, 32767 );
 439
 440     p_channel->i_sample2 = p_channel->i_sample1;
 441     p_channel->i_sample1 = i_predictor;
 442
 443     p_channel->i_idelta = ( i_adaptation_table[i_nibble] *
 444                             p_channel->i_idelta ) / 256;
 445     if( p_channel->i_idelta < 16 )
 446     {
 447         p_channel->i_idelta = 16;
 448     }
 449     return( i_predictor );
 450 }
 451
 452 static void DecodeAdpcmMs( decoder_t *p_dec, int16_t *p_sample,
 453                            uint8_t *p_buffer )
 454 {
 455     decoder_sys_t *p_sys  = p_dec->p_sys;
 456     adpcm_ms_channel_t channel[2];
 457     int b_stereo;
 458     int i_block_predictor;
 459
 460     size_t i_total_samples = p_sys->i_samplesperblock;
 461     if(i_total_samples < 2)
 462         return;
 463
 464     b_stereo = p_dec->fmt_out.audio.i_channels == 2 ? 1 : 0;
 465
 466     GetByte( i_block_predictor );
 467     CLAMP( i_block_predictor, 0, 6 );
 468     channel[0].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
 469     channel[0].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
 470
 471     if( b_stereo )
 472     {
 473         GetByte( i_block_predictor );
 474         CLAMP( i_block_predictor, 0, 6 );
 475         channel[1].i_coeff1 = i_adaptation_coeff1[i_block_predictor];
 476         channel[1].i_coeff2 = i_adaptation_coeff2[i_block_predictor];
 477     }
 478     GetWord( channel[0].i_idelta );
 479     if( b_stereo )
 480     {
 481         GetWord( channel[1].i_idelta );
 482     }
 483
 484     GetWord( channel[0].i_sample1 );
 485     if( b_stereo )
 486     {
 487         GetWord( channel[1].i_sample1 );
 488     }
 489
 490     GetWord( channel[0].i_sample2 );
 491     if( b_stereo )
 492     {
 493         GetWord( channel[1].i_sample2 );
 494     }
 495
 496     if( b_stereo )
 497     {
 498         *p_sample++ = channel[0].i_sample2;
 499         *p_sample++ = channel[1].i_sample2;
 500         *p_sample++ = channel[0].i_sample1;
 501         *p_sample++ = channel[1].i_sample1;
 502     }
 503     else
 504     {
 505         *p_sample++ = channel[0].i_sample2;
 506         *p_sample++ = channel[0].i_sample1;
 507     }
 508
 509     for( i_total_samples -= 2; i_total_samples >= 2; i_total_samples -= 2, p_buffer++ )
 510     {
 511         *p_sample++ = AdpcmMsExpandNibble( &channel[0], (*p_buffer) >> 4);
 512         *p_sample++ = AdpcmMsExpandNibble( &channel[b_stereo ? 1 : 0],
 513                                            (*p_buffer)&0x0f);
 514     }
 515 }
 516
 517 /*
 518  * IMA-WAV
 519  */
 520 typedef struct adpcm_ima_wav_channel_s
 521 {
 522     int i_predictor;
 523     int i_step_index;
 524
 525 } adpcm_ima_wav_channel_t;
 526
 527 static int AdpcmImaWavExpandNibble(adpcm_ima_wav_channel_t *p_channel,
 528                                    int i_nibble )
 529 {
 530     int i_diff;
 531
 532     i_diff = i_step_table[p_channel->i_step_index] >> 3;
 533     if( i_nibble&0x04 ) i_diff += i_step_table[p_channel->i_step_index];
 534     if( i_nibble&0x02 ) i_diff += i_step_table[p_channel->i_step_index]>>1;
 535     if( i_nibble&0x01 ) i_diff += i_step_table[p_channel->i_step_index]>>2;
 536     if( i_nibble&0x08 )
 537         p_channel->i_predictor -= i_diff;
 538     else
 539         p_channel->i_predictor += i_diff;
 540
 541     CLAMP( p_channel->i_predictor, -32768, 32767 );
 542
 543     p_channel->i_step_index += i_index_table[i_nibble];
 544
 545     CLAMP( p_channel->i_step_index, 0, 88 );
 546
 547     return( p_channel->i_predictor );
 548 }
 549
 550 static void DecodeAdpcmImaWav( decoder_t *p_dec, int16_t *p_sample,
 551                                uint8_t *p_buffer )
 552 {
 553     decoder_sys_t *p_sys  = p_dec->p_sys;
 554     adpcm_ima_wav_channel_t channel[2];
 555     int                     i_nibbles;
 556     int                     b_stereo;
 557
 558     b_stereo = p_dec->fmt_out.audio.i_channels == 2 ? 1 : 0;
 559
 560     GetWord( channel[0].i_predictor );
 561     GetByte( channel[0].i_step_index );
 562     CLAMP( channel[0].i_step_index, 0, 88 );
 563     p_buffer++;
 564
 565     if( b_stereo )
 566     {
 567         GetWord( channel[1].i_predictor );
 568         GetByte( channel[1].i_step_index );
 569         CLAMP( channel[1].i_step_index, 0, 88 );
 570         p_buffer++;
 571     }
 572
 573     if( b_stereo )
 574     {
 575         for( i_nibbles = 2 * (p_sys->i_block - 8);
 576              i_nibbles > 0;
 577              i_nibbles -= 16 )
 578         {
 579             int i;
 580
 581             for( i = 0; i < 4; i++ )
 582             {
 583                 p_sample[i * 4] =
 584                     AdpcmImaWavExpandNibble(&channel[0],p_buffer[i]&0x0f);
 585                 p_sample[i * 4 + 2] =
 586                     AdpcmImaWavExpandNibble(&channel[0],p_buffer[i] >> 4);
 587             }
 588             p_buffer += 4;
 589
 590             for( i = 0; i < 4; i++ )
 591             {
 592                 p_sample[i * 4 + 1] =
 593                     AdpcmImaWavExpandNibble(&channel[1],p_buffer[i]&0x0f);
 594                 p_sample[i * 4 + 3] =
 595                     AdpcmImaWavExpandNibble(&channel[1],p_buffer[i] >> 4);
 596             }
 597             p_buffer += 4;
 598             p_sample += 16;
 599
 600         }
 601
 602
 603     }
 604     else
 605     {
 606         for( i_nibbles = 2 * (p_sys->i_block - 4);
 607              i_nibbles > 0;
 608              i_nibbles -= 2, p_buffer++ )
 609         {
 610             *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer)&0x0f );
 611             *p_sample++ =AdpcmImaWavExpandNibble( &channel[0], (*p_buffer) >> 4 );
 612         }
 613     }
 614 }
 615
 616 /*
 617  * Ima4 in QT file
 618  */
 619 static void DecodeAdpcmImaQT( decoder_t *p_dec, int16_t *p_sample,
 620                               uint8_t *p_buffer )
 621 {
 622     adpcm_ima_wav_channel_t channel[2];
 623     int                     i_nibbles;
 624     int                     i_ch;
 625     int                     i_step;
 626
 627     i_step = p_dec->fmt_out.audio.i_channels;
 628
 629     for( i_ch = 0; i_ch < p_dec->fmt_out.audio.i_channels; i_ch++ )
 630     {
 631         /* load preambule */
 632         channel[i_ch].i_predictor  = (int16_t)((( ( p_buffer[0] << 1 )|(  p_buffer[1] >> 7 ) ))<<7);
 633         channel[i_ch].i_step_index = p_buffer[1]&0x7f;
 634
 635         CLAMP( channel[i_ch].i_step_index, 0, 88 );
 636         p_buffer += 2;
 637
 638         for( i_nibbles = 0; i_nibbles < 64; i_nibbles +=2 )
 639         {
 640             *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer)&0x0f);
 641             p_sample += i_step;
 642
 643             *p_sample = AdpcmImaWavExpandNibble( &channel[i_ch], (*p_buffer >> 4)&0x0f);
 644             p_sample += i_step;
 645
 646             p_buffer++;
 647         }
 648
 649         /* Next channel */
 650         p_sample += 1 - 64 * i_step;
 651     }
 652 }
 653
 654 /*
 655  * Dk4
 656  */
 657 static void DecodeAdpcmDk4( decoder_t *p_dec, int16_t *p_sample,
 658                             uint8_t *p_buffer )
 659 {
 660     decoder_sys_t *p_sys  = p_dec->p_sys;
 661     adpcm_ima_wav_channel_t channel[2];
 662     size_t                  i_nibbles;
 663     int                     b_stereo;
 664
 665     b_stereo = p_dec->fmt_out.audio.i_channels == 2 ? 1 : 0;
 666
 667     GetWord( channel[0].i_predictor );
 668     GetByte( channel[0].i_step_index );
 669     CLAMP( channel[0].i_step_index, 0, 88 );
 670     p_buffer++;
 671
 672     if( b_stereo )
 673     {
 674         GetWord( channel[1].i_predictor );
 675         GetByte( channel[1].i_step_index );
 676         CLAMP( channel[1].i_step_index, 0, 88 );
 677         p_buffer++;
 678     }
 679
 680     /* first output predictor */
 681     *p_sample++ = channel[0].i_predictor;
 682     if( b_stereo )
 683     {
 684         *p_sample++ = channel[1].i_predictor;
 685     }
 686
 687     for( i_nibbles = 0;
 688          i_nibbles < p_sys->i_block - 4 * (b_stereo ? 2:1 );
 689          i_nibbles++ )
 690     {
 691         *p_sample++ = AdpcmImaWavExpandNibble( &channel[0],
 692                                               (*p_buffer) >> 4);
 693         *p_sample++ = AdpcmImaWavExpandNibble( &channel[b_stereo ? 1 : 0],
 694                                                (*p_buffer)&0x0f);
 695
 696         p_buffer++;
 697     }
 698 }
 699
 700 /*
 701  * Dk3
 702  */
 703 static void DecodeAdpcmDk3( decoder_t *p_dec, int16_t *p_sample,
 704                             uint8_t *p_buffer )
 705 {
 706     decoder_sys_t *p_sys  = p_dec->p_sys;
 707     uint8_t                 *p_end = &p_buffer[p_sys->i_block];
 708     adpcm_ima_wav_channel_t sum;
 709     adpcm_ima_wav_channel_t diff;
 710     int                     i_diff_value;
 711
 712     p_buffer += 10;
 713
 714     GetWord( sum.i_predictor );
 715     GetWord( diff.i_predictor );
 716     GetByte( sum.i_step_index );
 717     GetByte( diff.i_step_index );
 718
 719     i_diff_value = diff.i_predictor;
 720     /* we process 6 nibbles at once */
 721     while( p_buffer + 1 <= p_end )
 722     {
 723         /* first 3 nibbles */
 724         AdpcmImaWavExpandNibble( &sum,
 725                                  (*p_buffer)&0x0f);
 726
 727         AdpcmImaWavExpandNibble( &diff,
 728                                  (*p_buffer) >> 4 );
 729
 730         i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
 731
 732         *p_sample++ = sum.i_predictor + i_diff_value;
 733         *p_sample++ = sum.i_predictor - i_diff_value;
 734
 735         p_buffer++;
 736
 737         AdpcmImaWavExpandNibble( &sum,
 738                                  (*p_buffer)&0x0f);
 739
 740         *p_sample++ = sum.i_predictor + i_diff_value;
 741         *p_sample++ = sum.i_predictor - i_diff_value;
 742
 743         /* now last 3 nibbles */
 744         AdpcmImaWavExpandNibble( &sum,
 745                                  (*p_buffer)>>4);
 746         p_buffer++;
 747         if( p_buffer < p_end )
 748         {
 749             AdpcmImaWavExpandNibble( &diff,
 750                                      (*p_buffer)&0x0f );
 751
 752             i_diff_value = ( i_diff_value + diff.i_predictor ) / 2;
 753
 754             *p_sample++ = sum.i_predictor + i_diff_value;
 755             *p_sample++ = sum.i_predictor - i_diff_value;
 756
 757             AdpcmImaWavExpandNibble( &sum,
 758                                      (*p_buffer)>>4);
 759             p_buffer++;
 760
 761             *p_sample++ = sum.i_predictor + i_diff_value;
 762             *p_sample++ = sum.i_predictor - i_diff_value;
 763         }
 764     }
 765 }
 766
 767
 768 /*
 769  * EA ADPCM
 770  */
 771 #define MAX_CHAN 5
 772 static void DecodeAdpcmEA( decoder_t *p_dec, int16_t *p_sample,
 773                            uint8_t *p_buffer )
 774 {
 775     static const int16_t EATable[]=
 776     {
 777         0x0000, 0x00F0, 0x01CC, 0x0188, 0x0000, 0x0000, 0xFF30, 0xFF24,
 778         0x0000, 0x0001, 0x0003, 0x0004, 0x0007, 0x0008, 0x000A, 0x000B,
 779         0x0000, 0xFFFF, 0xFFFD, 0xFFFC,
 780     };
 781     decoder_sys_t *p_sys  = p_dec->p_sys;
 782     int_fast32_t c1[MAX_CHAN], c2[MAX_CHAN];
 783     int_fast8_t d[MAX_CHAN];
 784
 785     unsigned chans = p_dec->fmt_out.audio.i_channels;
 786     const uint8_t *p_end = &p_buffer[p_sys->i_block];
 787     int16_t *prev = p_sys->prev;
 788     int16_t *cur = prev + chans;
 789
 790     for (unsigned c = 0; c < chans; c++)
 791     {
 792         uint8_t input = p_buffer[c];
 793
 794         c1[c] = EATable[input >> 4];
 795         c2[c] = EATable[(input >> 4) + 4];
 796         d[c] = (input & 0xf) + 8;
 797     }
 798
 799     for (p_buffer += chans; p_buffer < p_end; p_buffer += chans)
 800     {
 801         union { uint32_t u; int32_t i; } spl;
 802
 803         for (unsigned c = 0; c < chans; c++)
 804         {
 805             spl.u = (p_buffer[c] & 0xf0u) << 24u;
 806             spl.i >>= d[c];
 807             spl.i = (spl.i + cur[c] * c1[c] + prev[c] * c2[c] + 0x80) >> 8;
 808             CLAMP(spl.i, -32768, 32767);
 809             prev[c] = cur[c];
 810             cur[c] = spl.i;
 811
 812             *(p_sample++) = spl.i;
 813         }
 814
 815         for (unsigned c = 0; c < chans; c++)
 816         {
 817             spl.u = (p_buffer[c] & 0x0fu) << 28u;
 818             spl.i >>= d[c];
 819             spl.i = (spl.i + cur[c] * c1[c] + prev[c] * c2[c] + 0x80) >> 8;
 820             CLAMP(spl.i, -32768, 32767);
 821             prev[c] = cur[c];
 822             cur[c] = spl.i;
 823
 824             *(p_sample++) = spl.i;
 825         }
 826     }
 827 }