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