libmedia/AudioDecoderSimple.cpp

   1 // AudioDecoderSimple.cpp: Audio decoding using "simple" internal decoders.
   2 //
   3 //   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
   4 //   Free Software Foundation, Inc.
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19 //
  20
  21
  22 #include "AudioDecoderSimple.h"
  23 #include "AudioResampler.h"
  24 #include "BitsReader.h"
  25 #include "SoundInfo.h"
  26 #include "MediaParser.h" // for AudioInfo definition..
  27 #include "GnashNumeric.h" // for clamp
  28
  29 #include "log.h"
  30
  31 #include <algorithm> // for std::swap
  32
  33 namespace gnash {
  34 namespace media {
  35
  36 // ----------------------------------------------------------------------------
  37 // ADPCMDecoder class
  38 // ----------------------------------------------------------------------------
  39
  40 /// ADPCM decoder utilities
  41 //
  42 /// Algo from http://www.circuitcellar.com/pastissues/articles/richey110/text.htm
  43 /// And also Jansen.
  44 /// Here's another reference: http://www.geocities.com/SiliconValley/8682/aud3.txt
  45 /// Original IMA spec doesn't seem to be on the web :(
  46 ///
  47 /// TODO: move in it's own file
  48 ///
  49 class ADPCMDecoder {
  50
  51 private:
  52
  53         // Data from Alexis' SWF reference
  54         static int _index_update_table_2bits[2];
  55         static int _index_update_table_3bits[4];
  56         static int _index_update_table_4bits[8];
  57         static int _index_update_table_5bits[16];
  58
  59         static int* s_index_update_tables[4];
  60
  61         // Data from Jansen.  http://homepages.cwi.nl/~jack/
  62         // Check out his Dutch retro punk songs, heh heh :)
  63         static const int STEPSIZE_CT = 89;
  64         static int s_stepsize[STEPSIZE_CT];
  65
  66
  67         static void doSample(int n_bits, int& sample, int& stepsize_index, int raw_code)
  68         {
  69                 assert(raw_code >= 0 && raw_code < (1 << n_bits));
  70
  71                 static const int        HI_BIT = (1 << (n_bits - 1));
  72                 int*    index_update_table = s_index_update_tables[n_bits - 2];
  73
  74                 /* Core of ADPCM. */
  75
  76                 int     code_mag = raw_code & (HI_BIT - 1);
  77                 bool    code_sign_bit = (raw_code & HI_BIT) ? 1 : 0;
  78                 int     mag = (code_mag << 1) + 1;      /* shift in LSB (they do this so that pos & neg zero are different)*/
  79
  80                 int     stepsize = s_stepsize[stepsize_index];
  81
  82                 /* Compute the new sample.  It's the predicted value                    */
  83                 /* (i.e. the previous value), plus a delta.  The delta                  */
  84                 /* comes from the code times the stepsize.  going for                   */
  85                 /* something like: delta = stepsize * (code * 2 + 1) >> code_bits       */
  86                 int     delta = (stepsize * mag) >> (n_bits - 1);
  87                 if (code_sign_bit) delta = -delta;
  88
  89                 sample += delta;
  90                 sample = clamp<int>(sample, -32768, 32767);
  91
  92                 /* Update our stepsize index.  Use a lookup table. */
  93                 stepsize_index += index_update_table[code_mag];
  94                 stepsize_index = clamp<int>(stepsize_index, 0, STEPSIZE_CT - 1);
  95         }
  96
  97         /* Uncompress 4096 mono samples of ADPCM. */
  98         static std::uint32_t doMonoBlock(std::int16_t** out_data, int n_bits, BitsReader& in, int sample, int stepsize_index)
  99         {
 100                 /* First sample doesn't need to be decompressed. */
 101                 std::uint32_t sample_count = 1;
 102                 *(*out_data)++ = (std::int16_t) sample;
 103
 104                 while (sample_count < 4096 && in.gotBits(n_bits))
 105                 {
 106                         int     raw_code = in.read_uint(n_bits);
 107                         doSample(n_bits, sample, stepsize_index, raw_code);     /* sample & stepsize_index are in/out params */
 108                         *(*out_data)++ = (std::int16_t) sample;
 109
 110                         sample_count++;
 111                 }
 112                 return sample_count;
 113         }
 114
 115
 116         /* Uncompress 4096 stereo sample pairs of ADPCM. */
 117         static int doStereoBlock(
 118                         std::int16_t** out_data,        // in/out param
 119                         int n_bits,
 120                         BitsReader& in,
 121                         int left_sample,
 122                         int left_stepsize_index,
 123                         int right_sample,
 124                         int right_stepsize_index
 125                         )
 126         {
 127                 /* First samples don't need to be decompressed. */
 128                 std::uint32_t sample_count = 2;
 129                 *(*out_data)++ = (std::int16_t) left_sample;
 130                 *(*out_data)++ = (std::int16_t) right_sample;
 131
 132                 unsigned bitsNeeded = n_bits*2;
 133                 while (sample_count < 4096 && in.gotBits(bitsNeeded))
 134                 {
 135                         int     left_raw_code = in.read_uint(n_bits);
 136                         doSample(n_bits, left_sample, left_stepsize_index, left_raw_code);
 137                         *(*out_data)++ = (std::int16_t) left_sample;
 138
 139                         int     right_raw_code = in.read_uint(n_bits);
 140                         doSample(n_bits, right_sample, right_stepsize_index, right_raw_code);
 141                         *(*out_data)++ = (std::int16_t) right_sample;
 142
 143                         sample_count++;
 144                 }
 145                 return sample_count;
 146         }
 147
 148 public:
 149
 150         // Utility function: uncompress ADPCM data from in BitReader to
 151         // out_data[]. Returns the output samplecount.
 152         static std::uint32_t adpcm_expand(
 153                 unsigned char* &data,
 154                 BitsReader& in,
 155                 unsigned int insize,
 156                 bool stereo)
 157         {
 158                 // Read header.
 159                 if ( ! in.gotBits(2) )
 160                 {
 161                         IF_VERBOSE_MALFORMED_SWF(
 162                         log_swferror(_("corrupted ADPCM header"));
 163                         );
 164                         return 0;
 165                 }
 166                 unsigned int n_bits = in.read_uint(2) + 2; // 2 to 5 bits
 167
 168                 // The compression ratio is 4:1, so this should be enough...
 169                 std::int16_t* out_data = new std::int16_t[insize * 5];
 170                 data = reinterpret_cast<unsigned char *>(out_data);
 171
 172                 std::uint32_t sample_count = 0;
 173
 174                 while ( in.gotBits(22) )
 175                 {
 176                         // Read initial sample & index values.
 177
 178                         int     sample = in.read_sint(16);
 179
 180                         int     stepsize_index = in.read_uint(6);
 181                         assert(STEPSIZE_CT >= (1 << 6));        // ensure we don't need to clamp.
 182
 183                         if (stereo == false)
 184                         {
 185
 186                                 if (n_bits == 0) {
 187                                         abort();
 188                                 } else if (n_bits == 2) {
 189                                         sample_count += doMonoBlock(&out_data, 2, in, sample, stepsize_index);
 190                                 } else if (n_bits == 3) {
 191                                         sample_count += doMonoBlock(&out_data, 3, in, sample, stepsize_index);
 192                                 } else if (n_bits == 4) {
 193                                         sample_count += doMonoBlock(&out_data, 4, in, sample, stepsize_index);
 194                                 } else if (n_bits == 5) {
 195                                         sample_count += doMonoBlock(&out_data, 5, in, sample, stepsize_index);
 196                                 }
 197                         }
 198                         else
 199                         {
 200                                 // Stereo.
 201
 202                                 // Got values for left channel; now get initial sample
 203                                 // & index for right channel.
 204                                 int     right_sample = in.read_sint(16);
 205
 206                                 int     right_stepsize_index = in.read_uint(6);
 207                                 assert(STEPSIZE_CT >= (1 << 6));        // ensure we don't need to clamp.
 208
 209                                 if (n_bits == 0) {
 210                                         abort();
 211                                 } else if (n_bits == 2) {
 212                                         sample_count += doStereoBlock(&out_data, 2, in, sample, stepsize_index, right_sample, right_stepsize_index);
 213                                 } else if (n_bits == 3) {
 214                                         sample_count += doStereoBlock(&out_data, 3, in, sample, stepsize_index, right_sample, right_stepsize_index);
 215                                 } else if (n_bits == 4) {
 216                                         sample_count += doStereoBlock(&out_data, 4, in, sample, stepsize_index, right_sample, right_stepsize_index);
 217                                 } else if (n_bits == 5) {
 218                                         sample_count += doStereoBlock(&out_data, 5, in, sample, stepsize_index, right_sample, right_stepsize_index);
 219                                 }
 220
 221                         }
 222                 }
 223                 return sample_count;
 224
 225         }
 226
 227 };
 228
 229 int ADPCMDecoder::_index_update_table_2bits[2] = { -1,  2 };
 230 int ADPCMDecoder::_index_update_table_3bits[4] = { -1, -1,  2,  4 };
 231 int ADPCMDecoder::_index_update_table_4bits[8] = { -1, -1, -1, -1,  2,  4,  6,  8 };
 232 int ADPCMDecoder::_index_update_table_5bits[16] = { -1, -1, -1, -1, -1, -1, -1, -1, 1,  2,  4,  6,  8, 10, 13, 16 };
 233
 234 int* ADPCMDecoder::s_index_update_tables[4] = {
 235         ADPCMDecoder::_index_update_table_2bits,
 236         ADPCMDecoder::_index_update_table_3bits,
 237         ADPCMDecoder::_index_update_table_4bits,
 238         ADPCMDecoder::_index_update_table_5bits
 239 };
 240
 241 int ADPCMDecoder::s_stepsize[STEPSIZE_CT] = {
 242         7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
 243         19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
 244         50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
 245         130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
 246         337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
 247         876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
 248         2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
 249         5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
 250         15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
 251 };
 252
 253 // ----------------------------------------------------------------------------
 254 // END OF ADPCMDecoder class
 255 // ----------------------------------------------------------------------------
 256
 257 //
 258 // Unsigned 8-bit expansion (128 is silence)
 259 //
 260 // u8_expand allocates the memory for its "data" pointer.
 261 //
 262
 263 static void
 264 u8_expand(unsigned char * &data,
 265         const unsigned char* input,
 266         std::uint32_t input_size) // This is also the number of u8bit samples
 267 {
 268         std::int16_t    *out_data = new std::int16_t[input_size];
 269
 270         // Convert 8-bit to 16
 271         const std::uint8_t *inp = input;
 272         std::int16_t *outp = out_data;
 273         for (unsigned int i = input_size; i>0; i--) {
 274                 *outp++ = ((std::int16_t)(*inp++) - 128) * 256;
 275         }
 276
 277         data = (unsigned char *)out_data;
 278 }
 279
 280
 281 AudioDecoderSimple::AudioDecoderSimple(const AudioInfo& info)
 282         :
 283         _sampleRate(0),
 284         _sampleCount(0),
 285         _stereo(false),
 286         _is16bit(true)
 287 {
 288     setup(info);
 289
 290         log_debug(_("AudioDecoderSimple: initialized flash codec %s (%d)"),
 291                 (int)_codec, _codec);
 292 }
 293
 294 AudioDecoderSimple::AudioDecoderSimple(const SoundInfo& info)
 295         :
 296         _sampleRate(0),
 297         _sampleCount(0),
 298         _stereo(false),
 299         _is16bit(true)
 300 {
 301     setup(info);
 302
 303         log_debug(_("AudioDecoderSimple: initialized flash codec %s (%d)"),
 304                 (int)_codec, _codec);
 305 }
 306
 307
 308 AudioDecoderSimple::~AudioDecoderSimple()
 309 {
 310 }
 311
 312 void
 313 AudioDecoderSimple::setup(const SoundInfo& info)
 314 {
 315         _codec = info.getFormat();
 316     switch (_codec)
 317     {
 318         case AUDIO_CODEC_ADPCM:
 319         case AUDIO_CODEC_RAW:
 320         case AUDIO_CODEC_UNCOMPRESSED:
 321                     _sampleRate = info.getSampleRate();
 322                     _sampleCount = info.getSampleCount();
 323                     _stereo = info.isStereo();
 324                     _is16bit = info.is16bit();
 325             break;
 326
 327         default:
 328             boost::format err = boost::format(
 329                 _("AudioDecoderSimple: unsupported flash codec %d (%s)"))
 330                 % (int)_codec % _codec;
 331             throw MediaException(err.str());
 332         }
 333 }
 334
 335 void
 336 AudioDecoderSimple::setup(const AudioInfo& info)
 337 {
 338     if (info.type != CODEC_TYPE_FLASH) {
 339         boost::format err = boost::format(
 340             _("AudioDecoderSimple: unable to intepret custom audio codec id %s"))
 341             % info.codec;
 342         throw MediaException(err.str());
 343     }
 344
 345     _codec = static_cast<audioCodecType>(info.codec);
 346     switch (_codec)
 347     {
 348         case AUDIO_CODEC_ADPCM:
 349         case AUDIO_CODEC_RAW:
 350         case AUDIO_CODEC_UNCOMPRESSED:
 351             _sampleRate = info.sampleRate;
 352             _stereo = info.stereo;
 353             _is16bit = (info.sampleSize==2); // check this!
 354             if ( info.sampleSize > 2 ) // troubles...
 355                 log_unimpl("Sample size > 2 in %s sound!", _codec);
 356             break;
 357
 358         default:
 359             boost::format err = boost::format(
 360                 _("AudioDecoderSimple: unsupported flash codec %d (%s)"))
 361                 % (int)_codec % _codec;
 362             throw MediaException(err.str());
 363         }
 364 }
 365
 366 std::uint8_t*
 367 AudioDecoderSimple::decode(const std::uint8_t* input, std::uint32_t inputSize,
 368         std::uint32_t& outputSize, std::uint32_t& decodedBytes)
 369 {
 370
 371         unsigned char* decodedData = nullptr;
 372         std::uint32_t outsize = 0;
 373
 374     switch (_codec) {
 375         case AUDIO_CODEC_ADPCM:
 376                 {
 377                 //std::uint32_t sample_count = inputSize * ( _stereo ? 1 : 2 ); //(_sampleCount == 0 ? inputSize / ( _stereo ? 4 : 2 ) : _sampleCount);
 378                 BitsReader br(input, inputSize);
 379                 std::uint32_t sample_count = ADPCMDecoder::adpcm_expand(decodedData, br, inputSize, _stereo);
 380                 outsize = sample_count * (_stereo ? 4 : 2);
 381                 }
 382                 break;
 383         case AUDIO_CODEC_RAW:
 384                 if (_is16bit) {
 385                         // FORMAT_RAW 16-bit is exactly what we want!
 386                         decodedData = new unsigned char[inputSize];
 387                         memcpy(decodedData, input, inputSize);
 388                         outsize = inputSize;
 389                 } else {
 390                         // Convert 8-bit unsigned to 16-bit signed range
 391                         // Allocate as many shorts as there are samples
 392                         u8_expand(decodedData, input, inputSize);
 393                         outsize = inputSize * 2;
 394                 }
 395                 break;
 396         case AUDIO_CODEC_UNCOMPRESSED:
 397                 // 8- or 16-bit mono or stereo little-endian audio
 398                 // Convert to 16-bit host-endian.
 399                 if (!_is16bit)
 400                 {
 401                         // Convert 8-bit unsigned to 16-bit signed range
 402                         // Allocate as many shorts as there are 8-bit samples
 403                         u8_expand(decodedData, input, inputSize);
 404                         outsize = inputSize * 2;
 405
 406                 } else {
 407                         // Allocate a destination buffer
 408                         // Read 16-bit data into buffer
 409                         decodedData = new unsigned char[inputSize];
 410                         outsize = inputSize;
 411
 412                         // Convert 16-bit little-endian data to host-endian.
 413
 414                         // Runtime detection of host endianness costs almost
 415                         // nothing and is less of a continual maintenance headache
 416                         // than compile-time detection.
 417                         union u {
 418                                 std::uint16_t s;
 419                                 struct {
 420                                         std::uint8_t c0;
 421                                         std::uint8_t c1;
 422                                 } c;
 423                         } u = { 0x0001 };
 424
 425                         switch (u.c.c0) {
 426                                 default:        // Impossible
 427                                         log_error(_("Host endianness not detected in AudioDecoderSimple"));
 428                                         // Just carry on anyway...
 429                                 case 0x01:      // Little-endian host: sample is already native.
 430                                         // If the input data is the output data, then we probably
 431                                         // can't move the data faster than memcpy.
 432                                         memcpy((char *)decodedData, input, inputSize);
 433                                         break;
 434                                 case 0x00:  // Big-endian host
 435                                         // Swap sample bytes to get big-endian format.
 436                                         assert((inputSize & 1) == 0);
 437
 438                                         // Cast the buffers to help the compiler understand that we
 439                                         // swapping 16-bit words. This should produce a single-instruction
 440                                         // swap for each 16-bit word.
 441                                         const std::uint16_t* input16 = reinterpret_cast<const std::uint16_t*>(input);
 442                                         std::uint16_t* decodedData16 = reinterpret_cast<std::uint16_t*>(decodedData);
 443                                         unsigned inputSize16 = inputSize / sizeof(std::uint16_t);
 444                                         for ( unsigned i = 0; i < inputSize16; i++ )
 445                                         {
 446                                                 std::uint16_t sample = input16[i];
 447                                                 decodedData16[i] = ((sample << 8) & 0xFF00) | ((sample >> 8) & 0x00FF);
 448                                         }
 449                                         break;
 450                         }
 451                 }
 452                 break;
 453                 default:
 454                 break;
 455                 // ???, this should only decode ADPCM, RAW and UNCOMPRESSED
 456         }
 457
 458         std::uint8_t* tmp_raw_buffer = decodedData;
 459         std::uint32_t tmp_raw_buffer_size = 0;
 460
 461         // If we need to convert samplerate or/and from mono to stereo...
 462         if (outsize > 0 && (_sampleRate != 44100 || !_stereo)) {
 463
 464                 std::int16_t* adjusted_data = nullptr;
 465                 int     adjusted_size = 0;
 466                 int sample_count = outsize / (_stereo ? 4 : 2); // samples are of size 2
 467
 468                 // Convert to needed samplerate - this converter only support standard flash samplerates
 469                 AudioResampler::convert_raw_data(&adjusted_data, &adjusted_size,
 470                 tmp_raw_buffer,
 471                 sample_count, 2,  // input sample size is 2 !
 472                                 _sampleRate, _stereo,
 473                                 44100,  true /* stereo */);
 474
 475                 // Hopefully this wont happen
 476                 if (!adjusted_data) {
 477                         log_error(_("Error in sound sample conversion"));
 478                         delete[] tmp_raw_buffer;
 479                         outputSize = 0;
 480                         decodedBytes = 0;
 481                         return nullptr;
 482                 }
 483
 484                 // Move the new data to the sound-struct
 485                 delete[] tmp_raw_buffer;
 486                 tmp_raw_buffer = reinterpret_cast<std::uint8_t*>(adjusted_data);
 487                 tmp_raw_buffer_size = adjusted_size;
 488
 489         } else {
 490                 tmp_raw_buffer_size = outsize;
 491         }
 492
 493         outputSize = tmp_raw_buffer_size;
 494
 495         decodedBytes = inputSize;
 496         return tmp_raw_buffer;
 497 }
 498
 499 } // gnash.media namespace
 500 } // gnash namespace