src/audio/SDL_wave.c
author Sam Lantinga
Fri, 27 Nov 2020 18:57:42 -0800
changeset 14413 0ba75e4da3e1
parent 14254 128c76b761ad
permissions -rw-r--r--
Remember to close the game controller when we're done with it
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 #include "../SDL_internal.h"
    22 
    23 #ifdef HAVE_LIMITS_H
    24 #include <limits.h>
    25 #endif
    26 #ifndef INT_MAX
    27 /* Make a lucky guess. */
    28 #define INT_MAX SDL_MAX_SINT32
    29 #endif
    30 #ifndef SIZE_MAX
    31 #define SIZE_MAX ((size_t)-1)
    32 #endif
    33 
    34 /* Microsoft WAVE file loading routines */
    35 
    36 #include "SDL_hints.h"
    37 #include "SDL_audio.h"
    38 #include "SDL_wave.h"
    39 #include "SDL_audio_c.h"
    40 
    41 /* Reads the value stored at the location of the f1 pointer, multiplies it
    42  * with the second argument and then stores the result to f1.
    43  * Returns 0 on success, or -1 if the multiplication overflows, in which case f1
    44  * does not get modified.
    45  */
    46 static int
    47 SafeMult(size_t *f1, size_t f2)
    48 {
    49     if (*f1 > 0 && SIZE_MAX / *f1 <= f2) {
    50         return -1;
    51     }
    52     *f1 *= f2;
    53     return 0;
    54 }
    55 
    56 typedef struct ADPCM_DecoderState
    57 {
    58     Uint32 channels;        /* Number of channels. */
    59     size_t blocksize;       /* Size of an ADPCM block in bytes. */
    60     size_t blockheadersize; /* Size of an ADPCM block header in bytes. */
    61     size_t samplesperblock; /* Number of samples per channel in an ADPCM block. */
    62     size_t framesize;       /* Size of a sample frame (16-bit PCM) in bytes. */
    63     Sint64 framestotal;     /* Total number of sample frames. */
    64     Sint64 framesleft;      /* Number of sample frames still to be decoded. */
    65     void *ddata;            /* Decoder data from initialization. */
    66     void *cstate;           /* Decoding state for each channel. */
    67 
    68     /* ADPCM data. */
    69     struct {
    70         Uint8 *data;
    71         size_t size;
    72         size_t pos;
    73     } input;
    74 
    75     /* Current ADPCM block in the ADPCM data above. */
    76     struct {
    77         Uint8 *data;
    78         size_t size;
    79         size_t pos;
    80     } block;
    81 
    82     /* Decoded 16-bit PCM data. */
    83     struct {
    84         Sint16 *data;
    85         size_t size;
    86         size_t pos;
    87     } output;
    88 } ADPCM_DecoderState;
    89 
    90 typedef struct MS_ADPCM_CoeffData
    91 {
    92     Uint16 coeffcount;
    93     Sint16 *coeff;
    94     Sint16 aligndummy; /* Has to be last member. */
    95 } MS_ADPCM_CoeffData;
    96 
    97 typedef struct MS_ADPCM_ChannelState
    98 {
    99     Uint16 delta;
   100     Sint16 coeff1;
   101     Sint16 coeff2;
   102 } MS_ADPCM_ChannelState;
   103 
   104 #ifdef SDL_WAVE_DEBUG_LOG_FORMAT
   105 static void
   106 WaveDebugLogFormat(WaveFile *file)
   107 {
   108     WaveFormat *format = &file->format;
   109     const char *fmtstr = "WAVE file: %s, %u Hz, %s, %u bits, %u %s/s";
   110     const char *waveformat, *wavechannel, *wavebpsunit = "B";
   111     Uint32 wavebps = format->byterate;
   112     char channelstr[64];
   113 
   114     SDL_zeroa(channelstr);
   115 
   116     switch (format->encoding) {
   117     case PCM_CODE:
   118         waveformat = "PCM";
   119         break;
   120     case IEEE_FLOAT_CODE:
   121         waveformat = "IEEE Float";
   122         break;
   123     case ALAW_CODE:
   124         waveformat = "A-law";
   125         break;
   126     case MULAW_CODE:
   127         waveformat = "\xc2\xb5-law";
   128         break;
   129     case MS_ADPCM_CODE:
   130         waveformat = "MS ADPCM";
   131         break;
   132     case IMA_ADPCM_CODE:
   133         waveformat = "IMA ADPCM";
   134         break;
   135     default:
   136         waveformat = "Unknown";
   137         break;
   138     }
   139 
   140 #define SDL_WAVE_DEBUG_CHANNELCFG(STR, CODE) case CODE: wavechannel = STR; break;
   141 #define SDL_WAVE_DEBUG_CHANNELSTR(STR, CODE) if (format->channelmask & CODE) { \
   142     SDL_strlcat(channelstr, channelstr[0] ? "-" STR : STR, sizeof(channelstr));}
   143 
   144     if (format->formattag == EXTENSIBLE_CODE && format->channelmask > 0) {
   145         switch (format->channelmask) {
   146             SDL_WAVE_DEBUG_CHANNELCFG("1.0 Mono",         0x4)
   147             SDL_WAVE_DEBUG_CHANNELCFG("1.1 Mono",         0xc)
   148             SDL_WAVE_DEBUG_CHANNELCFG("2.0 Stereo",       0x3)
   149             SDL_WAVE_DEBUG_CHANNELCFG("2.1 Stereo",       0xb)
   150             SDL_WAVE_DEBUG_CHANNELCFG("3.0 Stereo",       0x7)
   151             SDL_WAVE_DEBUG_CHANNELCFG("3.1 Stereo",       0xf)
   152             SDL_WAVE_DEBUG_CHANNELCFG("3.0 Surround",     0x103)
   153             SDL_WAVE_DEBUG_CHANNELCFG("3.1 Surround",     0x10b)
   154             SDL_WAVE_DEBUG_CHANNELCFG("4.0 Quad",         0x33)
   155             SDL_WAVE_DEBUG_CHANNELCFG("4.1 Quad",         0x3b)
   156             SDL_WAVE_DEBUG_CHANNELCFG("4.0 Surround",     0x107)
   157             SDL_WAVE_DEBUG_CHANNELCFG("4.1 Surround",     0x10f)
   158             SDL_WAVE_DEBUG_CHANNELCFG("5.0",              0x37)
   159             SDL_WAVE_DEBUG_CHANNELCFG("5.1",              0x3f)
   160             SDL_WAVE_DEBUG_CHANNELCFG("5.0 Side",         0x607)
   161             SDL_WAVE_DEBUG_CHANNELCFG("5.1 Side",         0x60f)
   162             SDL_WAVE_DEBUG_CHANNELCFG("6.0",              0x137)
   163             SDL_WAVE_DEBUG_CHANNELCFG("6.1",              0x13f)
   164             SDL_WAVE_DEBUG_CHANNELCFG("6.0 Side",         0x707)
   165             SDL_WAVE_DEBUG_CHANNELCFG("6.1 Side",         0x70f)
   166             SDL_WAVE_DEBUG_CHANNELCFG("7.0",              0xf7)
   167             SDL_WAVE_DEBUG_CHANNELCFG("7.1",              0xff)
   168             SDL_WAVE_DEBUG_CHANNELCFG("7.0 Side",         0x6c7)
   169             SDL_WAVE_DEBUG_CHANNELCFG("7.1 Side",         0x6cf)
   170             SDL_WAVE_DEBUG_CHANNELCFG("7.0 Surround",     0x637)
   171             SDL_WAVE_DEBUG_CHANNELCFG("7.1 Surround",     0x63f)
   172             SDL_WAVE_DEBUG_CHANNELCFG("9.0 Surround",     0x5637)
   173             SDL_WAVE_DEBUG_CHANNELCFG("9.1 Surround",     0x563f)
   174             SDL_WAVE_DEBUG_CHANNELCFG("11.0 Surround",    0x56f7)
   175             SDL_WAVE_DEBUG_CHANNELCFG("11.1 Surround",    0x56ff)
   176         default:
   177             SDL_WAVE_DEBUG_CHANNELSTR("FL",  0x1)
   178             SDL_WAVE_DEBUG_CHANNELSTR("FR",  0x2)
   179             SDL_WAVE_DEBUG_CHANNELSTR("FC",  0x4)
   180             SDL_WAVE_DEBUG_CHANNELSTR("LF",  0x8)
   181             SDL_WAVE_DEBUG_CHANNELSTR("BL",  0x10)
   182             SDL_WAVE_DEBUG_CHANNELSTR("BR",  0x20)
   183             SDL_WAVE_DEBUG_CHANNELSTR("FLC", 0x40)
   184             SDL_WAVE_DEBUG_CHANNELSTR("FRC", 0x80)
   185             SDL_WAVE_DEBUG_CHANNELSTR("BC",  0x100)
   186             SDL_WAVE_DEBUG_CHANNELSTR("SL",  0x200)
   187             SDL_WAVE_DEBUG_CHANNELSTR("SR",  0x400)
   188             SDL_WAVE_DEBUG_CHANNELSTR("TC",  0x800)
   189             SDL_WAVE_DEBUG_CHANNELSTR("TFL", 0x1000)
   190             SDL_WAVE_DEBUG_CHANNELSTR("TFC", 0x2000)
   191             SDL_WAVE_DEBUG_CHANNELSTR("TFR", 0x4000)
   192             SDL_WAVE_DEBUG_CHANNELSTR("TBL", 0x8000)
   193             SDL_WAVE_DEBUG_CHANNELSTR("TBC", 0x10000)
   194             SDL_WAVE_DEBUG_CHANNELSTR("TBR", 0x20000)
   195             break;
   196         }
   197     } else {
   198         switch (format->channels) {
   199         default:
   200             if (SDL_snprintf(channelstr, sizeof(channelstr), "%u channels", format->channels) >= 0) {
   201                 wavechannel = channelstr;
   202                 break;
   203             }
   204         case 0:
   205             wavechannel = "Unknown";
   206             break;
   207         case 1:
   208             wavechannel = "Mono";
   209             break;
   210         case 2:
   211             wavechannel = "Setero";
   212             break;
   213         }
   214     }
   215 
   216 #undef SDL_WAVE_DEBUG_CHANNELCFG
   217 #undef SDL_WAVE_DEBUG_CHANNELSTR
   218 
   219     if (wavebps >= 1024) {
   220         wavebpsunit = "KiB";
   221         wavebps = wavebps / 1024 + (wavebps & 0x3ff ? 1 : 0);
   222     }
   223 
   224     SDL_LogDebug(SDL_LOG_CATEGORY_AUDIO, fmtstr, waveformat, format->frequency, wavechannel, format->bitspersample, wavebps, wavebpsunit);
   225 }
   226 #endif
   227 
   228 #ifdef SDL_WAVE_DEBUG_DUMP_FORMAT
   229 static void
   230 WaveDebugDumpFormat(WaveFile *file, Uint32 rifflen, Uint32 fmtlen, Uint32 datalen)
   231 {
   232     WaveFormat *format = &file->format;
   233     const char *fmtstr1 = "WAVE chunk dump:\n"
   234         "-------------------------------------------\n"
   235         "RIFF                            %11u\n"
   236         "-------------------------------------------\n"
   237         "    fmt                         %11u\n"
   238         "        wFormatTag                   0x%04x\n"
   239         "        nChannels               %11u\n"
   240         "        nSamplesPerSec          %11u\n"
   241         "        nAvgBytesPerSec         %11u\n"
   242         "        nBlockAlign             %11u\n";
   243     const char *fmtstr2 = "        wBitsPerSample          %11u\n";
   244     const char *fmtstr3 = "        cbSize                  %11u\n";
   245     const char *fmtstr4a = "        wValidBitsPerSample     %11u\n";
   246     const char *fmtstr4b = "        wSamplesPerBlock        %11u\n";
   247     const char *fmtstr5 = "        dwChannelMask            0x%08x\n"
   248         "        SubFormat\n"
   249         "        %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x\n";
   250     const char *fmtstr6 = "-------------------------------------------\n"
   251         " fact\n"
   252         "  dwSampleLength                %11u\n";
   253     const char *fmtstr7 = "-------------------------------------------\n"
   254         " data                           %11u\n"
   255         "-------------------------------------------\n";
   256     char *dumpstr;
   257     size_t dumppos = 0;
   258     const size_t bufsize = 1024;
   259     int res;
   260 
   261     dumpstr = SDL_malloc(bufsize);
   262     if (dumpstr == NULL) {
   263         return;
   264     }
   265     dumpstr[0] = 0;
   266 
   267     res = SDL_snprintf(dumpstr, bufsize, fmtstr1, rifflen, fmtlen, format->formattag, format->channels, format->frequency, format->byterate, format->blockalign);
   268     dumppos += res > 0 ? res : 0;
   269     if (fmtlen >= 16) {
   270         res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr2, format->bitspersample);
   271         dumppos += res > 0 ? res : 0;
   272     }
   273     if (fmtlen >= 18) {
   274         res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr3, format->extsize);
   275         dumppos += res > 0 ? res : 0;
   276     }
   277     if (format->formattag == EXTENSIBLE_CODE && fmtlen >= 40 && format->extsize >= 22) {
   278         const Uint8 *g = format->subformat;
   279         const Uint32 g1 = g[0] | ((Uint32)g[1] << 8) | ((Uint32)g[2] << 16) | ((Uint32)g[3] << 24);
   280         const Uint32 g2 = g[4] | ((Uint32)g[5] << 8);
   281         const Uint32 g3 = g[6] | ((Uint32)g[7] << 8);
   282 
   283         switch (format->encoding) {
   284         default:
   285             res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr4a, format->validsamplebits);
   286             dumppos += res > 0 ? res : 0;
   287             break;
   288         case MS_ADPCM_CODE:
   289         case IMA_ADPCM_CODE:
   290             res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr4b, format->samplesperblock);
   291             dumppos += res > 0 ? res : 0;
   292             break;
   293         }
   294         res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr5, format->channelmask, g1, g2, g3, g[8], g[9], g[10], g[11], g[12], g[13], g[14], g[15]);
   295         dumppos += res > 0 ? res : 0;
   296     } else {
   297         switch (format->encoding) {
   298         case MS_ADPCM_CODE:
   299         case IMA_ADPCM_CODE:
   300             if (fmtlen >= 20 && format->extsize >= 2) {
   301                 res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr4b, format->samplesperblock);
   302                 dumppos += res > 0 ? res : 0;
   303             }
   304             break;
   305         }
   306     }
   307     if (file->fact.status >= 1) {
   308         res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr6, file->fact.samplelength);
   309         dumppos += res > 0 ? res : 0;
   310     }
   311     res = SDL_snprintf(dumpstr + dumppos, bufsize - dumppos, fmtstr7, datalen);
   312     dumppos += res > 0 ? res : 0;
   313 
   314     SDL_LogDebug(SDL_LOG_CATEGORY_AUDIO, "%s", dumpstr);
   315 
   316     free(dumpstr);
   317 }
   318 #endif
   319 
   320 static Sint64
   321 WaveAdjustToFactValue(WaveFile *file, Sint64 sampleframes)
   322 {
   323     if (file->fact.status == 2) {
   324         if (file->facthint == FactStrict && sampleframes < file->fact.samplelength) {
   325             return SDL_SetError("Invalid number of sample frames in WAVE fact chunk (too many)");
   326         } else if (sampleframes > file->fact.samplelength) {
   327             return file->fact.samplelength;
   328         }
   329     }
   330 
   331     return sampleframes;
   332 }
   333 
   334 static int
   335 MS_ADPCM_CalculateSampleFrames(WaveFile *file, size_t datalength)
   336 {
   337     WaveFormat *format = &file->format;
   338     const size_t blockheadersize = (size_t)file->format.channels * 7;
   339     const size_t availableblocks = datalength / file->format.blockalign;
   340     const size_t blockframebitsize = (size_t)file->format.bitspersample * file->format.channels;
   341     const size_t trailingdata = datalength % file->format.blockalign;
   342 
   343     if (file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict) {
   344         /* The size of the data chunk must be a multiple of the block size. */
   345         if (datalength < blockheadersize || trailingdata > 0) {
   346             return SDL_SetError("Truncated MS ADPCM block");
   347         }
   348     }
   349 
   350     /* Calculate number of sample frames that will be decoded. */
   351     file->sampleframes = (Sint64)availableblocks * format->samplesperblock;
   352     if (trailingdata > 0) {
   353         /* The last block is truncated. Check if we can get any samples out of it. */
   354         if (file->trunchint == TruncDropFrame) {
   355             /* Drop incomplete sample frame. */
   356             if (trailingdata >= blockheadersize) {
   357                 size_t trailingsamples = 2 + (trailingdata - blockheadersize) * 8 / blockframebitsize;
   358                 if (trailingsamples > format->samplesperblock) {
   359                     trailingsamples = format->samplesperblock;
   360                 }
   361                 file->sampleframes += trailingsamples;
   362             }
   363         }
   364     }
   365 
   366     file->sampleframes = WaveAdjustToFactValue(file, file->sampleframes);
   367     if (file->sampleframes < 0) {
   368         return -1;
   369     }
   370 
   371     return 0;
   372 }
   373 
   374 static int
   375 MS_ADPCM_Init(WaveFile *file, size_t datalength)
   376 {
   377     WaveFormat *format = &file->format;
   378     WaveChunk *chunk = &file->chunk;
   379     const size_t blockheadersize = (size_t)format->channels * 7;
   380     const size_t blockdatasize = (size_t)format->blockalign - blockheadersize;
   381     const size_t blockframebitsize = (size_t)format->bitspersample * format->channels;
   382     const size_t blockdatasamples = (blockdatasize * 8) / blockframebitsize;
   383     const Sint16 presetcoeffs[14] = {256, 0, 512, -256, 0, 0, 192, 64, 240, 0, 460, -208, 392, -232};
   384     size_t i, coeffcount;
   385     MS_ADPCM_CoeffData *coeffdata;
   386 
   387     /* Sanity checks. */
   388 
   389     /* While it's clear how IMA ADPCM handles more than two channels, the nibble
   390      * order of MS ADPCM makes it awkward. The Standards Update does not talk
   391      * about supporting more than stereo anyway.
   392      */
   393     if (format->channels > 2) {
   394         return SDL_SetError("Invalid number of channels");
   395     }
   396 
   397     if (format->bitspersample != 4) {
   398         return SDL_SetError("Invalid MS ADPCM bits per sample of %u", (unsigned int)format->bitspersample);
   399     }
   400 
   401     /* The block size must be big enough to contain the block header. */
   402     if (format->blockalign < blockheadersize) {
   403         return SDL_SetError("Invalid MS ADPCM block size (nBlockAlign)");
   404     }
   405 
   406     if (format->formattag == EXTENSIBLE_CODE) {
   407         /* Does have a GUID (like all format tags), but there's no specification
   408          * for how the data is packed into the extensible header. Making
   409          * assumptions here could lead to new formats nobody wants to support.
   410          */
   411         return SDL_SetError("MS ADPCM with the extensible header is not supported");
   412     }
   413 
   414     /* There are wSamplesPerBlock, wNumCoef, and at least 7 coefficient pairs in
   415      * the extended part of the header.
   416      */
   417     if (chunk->size < 22) {
   418         return SDL_SetError("Could not read MS ADPCM format header");
   419     }
   420 
   421     format->samplesperblock = chunk->data[18] | ((Uint16)chunk->data[19] << 8);
   422     /* Number of coefficient pairs. A pair has two 16-bit integers. */
   423     coeffcount = chunk->data[20] | ((size_t)chunk->data[21] << 8);
   424     /* bPredictor, the integer offset into the coefficients array, is only
   425      * 8 bits. It can only address the first 256 coefficients. Let's limit
   426      * the count number here.
   427      */
   428     if (coeffcount > 256) {
   429         coeffcount = 256;
   430     }
   431 
   432     if (chunk->size < 22 + coeffcount * 4) {
   433         return SDL_SetError("Could not read custom coefficients in MS ADPCM format header");
   434     } else if (format->extsize < 4 + coeffcount * 4) {
   435         return SDL_SetError("Invalid MS ADPCM format header (too small)");
   436     } else if (coeffcount < 7) {
   437         return SDL_SetError("Missing required coefficients in MS ADPCM format header");
   438     }
   439 
   440     coeffdata = (MS_ADPCM_CoeffData *)SDL_malloc(sizeof(MS_ADPCM_CoeffData) + coeffcount * 4);
   441     file->decoderdata = coeffdata; /* Freed in cleanup. */
   442     if (coeffdata == NULL) {
   443         return SDL_OutOfMemory();
   444     }
   445     coeffdata->coeff = &coeffdata->aligndummy;
   446     coeffdata->coeffcount = (Uint16)coeffcount;
   447 
   448     /* Copy the 16-bit pairs. */
   449     for (i = 0; i < coeffcount * 2; i++) {
   450         Sint32 c = chunk->data[22 + i * 2] | ((Sint32)chunk->data[23 + i * 2] << 8);
   451         if (c >= 0x8000) {
   452             c -= 0x10000;
   453         }
   454         if (i < 14 && c != presetcoeffs[i]) {
   455             return SDL_SetError("Wrong preset coefficients in MS ADPCM format header");
   456         }
   457         coeffdata->coeff[i] = (Sint16)c;
   458     }
   459 
   460     /* Technically, wSamplesPerBlock is required, but we have all the
   461      * information in the other fields to calculate it, if it's zero.
   462      */
   463     if (format->samplesperblock == 0) {
   464         /* Let's be nice to the encoders that didn't know how to fill this.
   465          * The Standards Update calculates it this way:
   466          *
   467          *   x = Block size (in bits) minus header size (in bits)
   468          *   y = Bit depth multiplied by channel count
   469          *   z = Number of samples per channel in block header
   470          *   wSamplesPerBlock = x / y + z
   471          */
   472         format->samplesperblock = (Uint32)blockdatasamples + 2;
   473     }
   474 
   475     /* nBlockAlign can be in conflict with wSamplesPerBlock. For example, if
   476      * the number of samples doesn't fit into the block. The Standards Update
   477      * also describes wSamplesPerBlock with a formula that makes it necessary to
   478      * always fill the block with the maximum amount of samples, but this is not
   479      * enforced here as there are no compatibility issues.
   480      * A truncated block header with just one sample is not supported.
   481      */
   482     if (format->samplesperblock == 1 || blockdatasamples < format->samplesperblock - 2) {
   483         return SDL_SetError("Invalid number of samples per MS ADPCM block (wSamplesPerBlock)");
   484     }
   485 
   486     if (MS_ADPCM_CalculateSampleFrames(file, datalength) < 0) {
   487         return -1;
   488     }
   489 
   490     return 0;
   491 }
   492 
   493 static Sint16
   494 MS_ADPCM_ProcessNibble(MS_ADPCM_ChannelState *cstate, Sint32 sample1, Sint32 sample2, Uint8 nybble)
   495 {
   496     const Sint32 max_audioval = 32767;
   497     const Sint32 min_audioval = -32768;
   498     const Uint16 max_deltaval = 65535;
   499     const Uint16 adaptive[] = {
   500         230, 230, 230, 230, 307, 409, 512, 614,
   501         768, 614, 512, 409, 307, 230, 230, 230
   502     };
   503     Sint32 new_sample;
   504     Sint32 errordelta;
   505     Uint32 delta = cstate->delta;
   506 
   507     new_sample = (sample1 * cstate->coeff1 + sample2 * cstate->coeff2) / 256;
   508     /* The nibble is a signed 4-bit error delta. */
   509     errordelta = (Sint32)nybble - (nybble >= 0x08 ? 0x10 : 0);
   510     new_sample += (Sint32)delta * errordelta;
   511     if (new_sample < min_audioval) {
   512         new_sample = min_audioval;
   513     } else if (new_sample > max_audioval) {
   514         new_sample = max_audioval;
   515     }
   516     delta = (delta * adaptive[nybble]) / 256;
   517     if (delta < 16) {
   518         delta = 16;
   519     } else if (delta > max_deltaval) {
   520         /* This issue is not described in the Standards Update and therefore
   521          * undefined. It seems sensible to prevent overflows with a limit.
   522          */
   523         delta = max_deltaval;
   524     }
   525 
   526     cstate->delta = (Uint16)delta;
   527     return (Sint16)new_sample;
   528 }
   529 
   530 static int
   531 MS_ADPCM_DecodeBlockHeader(ADPCM_DecoderState *state)
   532 {
   533     Uint8 coeffindex;
   534     const Uint32 channels = state->channels;
   535     Sint32 sample;
   536     Uint32 c;
   537     MS_ADPCM_ChannelState *cstate = (MS_ADPCM_ChannelState *)state->cstate;
   538     MS_ADPCM_CoeffData *ddata = (MS_ADPCM_CoeffData *)state->ddata;
   539 
   540     for (c = 0; c < channels; c++) {
   541         size_t o = c;
   542 
   543         /* Load the coefficient pair into the channel state. */
   544         coeffindex = state->block.data[o];
   545         if (coeffindex > ddata->coeffcount) {
   546             return SDL_SetError("Invalid MS ADPCM coefficient index in block header");
   547         }
   548         cstate[c].coeff1 = ddata->coeff[coeffindex * 2];
   549         cstate[c].coeff2 = ddata->coeff[coeffindex * 2 + 1];
   550 
   551         /* Initial delta value. */
   552         o = channels + c * 2;
   553         cstate[c].delta = state->block.data[o] | ((Uint16)state->block.data[o + 1] << 8);
   554 
   555         /* Load the samples from the header. Interestingly, the sample later in
   556          * the output stream comes first.
   557          */
   558         o = channels * 3 + c * 2;
   559         sample = state->block.data[o] | ((Sint32)state->block.data[o + 1] << 8);
   560         if (sample >= 0x8000) {
   561             sample -= 0x10000;
   562         }
   563         state->output.data[state->output.pos + channels] = (Sint16)sample;
   564 
   565         o = channels * 5 + c * 2;
   566         sample = state->block.data[o] | ((Sint32)state->block.data[o + 1] << 8);
   567         if (sample >= 0x8000) {
   568             sample -= 0x10000;
   569         }
   570         state->output.data[state->output.pos] = (Sint16)sample;
   571 
   572         state->output.pos++;
   573     }
   574 
   575     state->block.pos += state->blockheadersize;
   576 
   577     /* Skip second sample frame that came from the header. */
   578     state->output.pos += state->channels;
   579 
   580     /* Header provided two sample frames. */
   581     state->framesleft -= 2;
   582 
   583     return 0;
   584 }
   585 
   586 /* Decodes the data of the MS ADPCM block. Decoding will stop if a block is too
   587  * short, returning with none or partially decoded data. The partial data
   588  * will always contain full sample frames (same sample count for each channel).
   589  * Incomplete sample frames are discarded.
   590  */
   591 static int
   592 MS_ADPCM_DecodeBlockData(ADPCM_DecoderState *state)
   593 {
   594     Uint16 nybble = 0;
   595     Sint16 sample1, sample2;
   596     const Uint32 channels = state->channels;
   597     Uint32 c;
   598     MS_ADPCM_ChannelState *cstate = (MS_ADPCM_ChannelState *)state->cstate;
   599 
   600     size_t blockpos = state->block.pos;
   601     size_t blocksize = state->block.size;
   602 
   603     size_t outpos = state->output.pos;
   604 
   605     Sint64 blockframesleft = state->samplesperblock - 2;
   606     if (blockframesleft > state->framesleft) {
   607         blockframesleft = state->framesleft;
   608     }
   609 
   610     while (blockframesleft > 0) {
   611         for (c = 0; c < channels; c++) {
   612             if (nybble & 0x4000) {
   613                 nybble <<= 4;
   614             } else if (blockpos < blocksize) {
   615                 nybble = state->block.data[blockpos++] | 0x4000;
   616             } else {
   617                 /* Out of input data. Drop the incomplete frame and return. */
   618                 state->output.pos = outpos - c;
   619                 return -1;
   620             }
   621 
   622             /* Load previous samples which may come from the block header. */
   623             sample1 = state->output.data[outpos - channels];
   624             sample2 = state->output.data[outpos - channels * 2];
   625 
   626             sample1 = MS_ADPCM_ProcessNibble(cstate + c, sample1, sample2, (nybble >> 4) & 0x0f);
   627             state->output.data[outpos++] = sample1;
   628         }
   629 
   630         state->framesleft--;
   631         blockframesleft--;
   632     }
   633 
   634     state->output.pos = outpos;
   635 
   636     return 0;
   637 }
   638 
   639 static int
   640 MS_ADPCM_Decode(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
   641 {
   642     int result;
   643     size_t bytesleft, outputsize;
   644     WaveChunk *chunk = &file->chunk;
   645     ADPCM_DecoderState state;
   646     MS_ADPCM_ChannelState cstate[2];
   647 
   648     SDL_zero(state);
   649     SDL_zeroa(cstate);
   650 
   651     if (chunk->size != chunk->length) {
   652         /* Could not read everything. Recalculate number of sample frames. */
   653         if (MS_ADPCM_CalculateSampleFrames(file, chunk->size) < 0) {
   654             return -1;
   655         }
   656     }
   657 
   658     /* Nothing to decode, nothing to return. */
   659     if (file->sampleframes == 0) {
   660         *audio_buf = NULL;
   661         *audio_len = 0;
   662         return 0;
   663     }
   664 
   665     state.blocksize = file->format.blockalign;
   666     state.channels = file->format.channels;
   667     state.blockheadersize = (size_t)state.channels * 7;
   668     state.samplesperblock = file->format.samplesperblock;
   669     state.framesize = state.channels * sizeof(Sint16);
   670     state.ddata = file->decoderdata;
   671     state.framestotal = file->sampleframes;
   672     state.framesleft = state.framestotal;
   673 
   674     state.input.data = chunk->data;
   675     state.input.size = chunk->size;
   676     state.input.pos = 0;
   677 
   678     /* The output size in bytes. May get modified if data is truncated. */
   679     outputsize = (size_t)state.framestotal;
   680     if (SafeMult(&outputsize, state.framesize)) {
   681         return SDL_OutOfMemory();
   682     } else if (outputsize > SDL_MAX_UINT32 || state.framestotal > SIZE_MAX) {
   683         return SDL_SetError("WAVE file too big");
   684     }
   685 
   686     state.output.pos = 0;
   687     state.output.size = outputsize / sizeof(Sint16);
   688     state.output.data = (Sint16 *)SDL_malloc(outputsize);
   689     if (state.output.data == NULL) {
   690         return SDL_OutOfMemory();
   691     }
   692 
   693     state.cstate = cstate;
   694 
   695     /* Decode block by block. A truncated block will stop the decoding. */
   696     bytesleft = state.input.size - state.input.pos;
   697     while (state.framesleft > 0 && bytesleft >= state.blockheadersize) {
   698         state.block.data = state.input.data + state.input.pos;
   699         state.block.size = bytesleft < state.blocksize ? bytesleft : state.blocksize;
   700         state.block.pos = 0;
   701 
   702         if (state.output.size - state.output.pos < (Uint64)state.framesleft * state.channels) {
   703             /* Somehow didn't allocate enough space for the output. */
   704             SDL_free(state.output.data);
   705             return SDL_SetError("Unexpected overflow in MS ADPCM decoder");
   706         }
   707 
   708         /* Initialize decoder with the values from the block header. */
   709         result = MS_ADPCM_DecodeBlockHeader(&state);
   710         if (result == -1) {
   711             SDL_free(state.output.data);
   712             return -1;
   713         }
   714 
   715         /* Decode the block data. It stores the samples directly in the output. */
   716         result = MS_ADPCM_DecodeBlockData(&state);
   717         if (result == -1) {
   718             /* Unexpected end. Stop decoding and return partial data if necessary. */
   719             if (file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict) {
   720                 SDL_free(state.output.data);
   721                 return SDL_SetError("Truncated data chunk");
   722             } else if (file->trunchint != TruncDropFrame) {
   723                 state.output.pos -= state.output.pos % (state.samplesperblock * state.channels);
   724             }
   725             outputsize = state.output.pos * sizeof(Sint16); /* Can't overflow, is always smaller. */
   726             break;
   727         }
   728 
   729         state.input.pos += state.block.size;
   730         bytesleft = state.input.size - state.input.pos;
   731     }
   732 
   733     *audio_buf = (Uint8 *)state.output.data;
   734     *audio_len = (Uint32)outputsize;
   735 
   736     return 0;
   737 }
   738 
   739 static int
   740 IMA_ADPCM_CalculateSampleFrames(WaveFile *file, size_t datalength)
   741 {
   742     WaveFormat *format = &file->format;
   743     const size_t blockheadersize = (size_t)format->channels * 4;
   744     const size_t subblockframesize = (size_t)format->channels * 4;
   745     const size_t availableblocks = datalength / format->blockalign;
   746     const size_t trailingdata = datalength % format->blockalign;
   747 
   748     if (file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict) {
   749         /* The size of the data chunk must be a multiple of the block size. */
   750         if (datalength < blockheadersize || trailingdata > 0) {
   751             return SDL_SetError("Truncated IMA ADPCM block");
   752         }
   753     }
   754 
   755     /* Calculate number of sample frames that will be decoded. */
   756     file->sampleframes = (Uint64)availableblocks * format->samplesperblock;
   757     if (trailingdata > 0) {
   758         /* The last block is truncated. Check if we can get any samples out of it. */
   759         if (file->trunchint == TruncDropFrame && trailingdata > blockheadersize - 2) {
   760             /* The sample frame in the header of the truncated block is present.
   761              * Drop incomplete sample frames.
   762              */
   763             size_t trailingsamples = 1;
   764 
   765             if (trailingdata > blockheadersize) {
   766                 /* More data following after the header. */
   767                 const size_t trailingblockdata = trailingdata - blockheadersize;
   768                 const size_t trailingsubblockdata = trailingblockdata % subblockframesize;
   769                 trailingsamples += (trailingblockdata / subblockframesize) * 8;
   770                 /* Due to the interleaved sub-blocks, the last 4 bytes determine
   771                  * how many samples of the truncated sub-block are lost.
   772                  */
   773                 if (trailingsubblockdata > subblockframesize - 4) {
   774                     trailingsamples += (trailingsubblockdata % 4) * 2;
   775                 }
   776             }
   777 
   778             if (trailingsamples > format->samplesperblock) {
   779                 trailingsamples = format->samplesperblock;
   780             }
   781             file->sampleframes += trailingsamples;
   782         }
   783     }
   784 
   785     file->sampleframes = WaveAdjustToFactValue(file, file->sampleframes);
   786     if (file->sampleframes < 0) {
   787         return -1;
   788     }
   789 
   790     return 0;
   791 }
   792 
   793 static int
   794 IMA_ADPCM_Init(WaveFile *file, size_t datalength)
   795 {
   796     WaveFormat *format = &file->format;
   797     WaveChunk *chunk = &file->chunk;
   798     const size_t blockheadersize = (size_t)format->channels * 4;
   799     const size_t blockdatasize = (size_t)format->blockalign - blockheadersize;
   800     const size_t blockframebitsize = (size_t)format->bitspersample * format->channels;
   801     const size_t blockdatasamples = (blockdatasize * 8) / blockframebitsize;
   802 
   803     /* Sanity checks. */
   804 
   805     /* IMA ADPCM can also have 3-bit samples, but it's not supported by SDL at this time. */
   806     if (format->bitspersample == 3) {
   807         return SDL_SetError("3-bit IMA ADPCM currently not supported");
   808     } else if (format->bitspersample != 4) {
   809         return SDL_SetError("Invalid IMA ADPCM bits per sample of %u", (unsigned int)format->bitspersample);
   810     }
   811 
   812     /* The block size is required to be a multiple of 4 and it must be able to
   813      * hold a block header.
   814      */
   815     if (format->blockalign < blockheadersize || format->blockalign % 4) {
   816         return SDL_SetError("Invalid IMA ADPCM block size (nBlockAlign)");
   817     }
   818 
   819     if (format->formattag == EXTENSIBLE_CODE) {
   820         /* There's no specification for this, but it's basically the same
   821          * format because the extensible header has wSampePerBlocks too.
   822          */
   823     } else  {
   824         /* The Standards Update says there 'should' be 2 bytes for wSamplesPerBlock. */
   825         if (chunk->size >= 20 && format->extsize >= 2) {
   826             format->samplesperblock = chunk->data[18] | ((Uint16)chunk->data[19] << 8);
   827         }
   828     }
   829 
   830     if (format->samplesperblock == 0) {
   831         /* Field zero? No problem. We just assume the encoder packed the block.
   832          * The specification calculates it this way:
   833          *
   834          *   x = Block size (in bits) minus header size (in bits)
   835          *   y = Bit depth multiplied by channel count
   836          *   z = Number of samples per channel in header
   837          *   wSamplesPerBlock = x / y + z
   838          */
   839         format->samplesperblock = (Uint32)blockdatasamples + 1;
   840     }
   841 
   842     /* nBlockAlign can be in conflict with wSamplesPerBlock. For example, if
   843      * the number of samples doesn't fit into the block. The Standards Update
   844      * also describes wSamplesPerBlock with a formula that makes it necessary
   845      * to always fill the block with the maximum amount of samples, but this is
   846      * not enforced here as there are no compatibility issues.
   847      */
   848     if (blockdatasamples < format->samplesperblock - 1) {
   849         return SDL_SetError("Invalid number of samples per IMA ADPCM block (wSamplesPerBlock)");
   850     }
   851 
   852     if (IMA_ADPCM_CalculateSampleFrames(file, datalength) < 0) {
   853         return -1;
   854     }
   855 
   856     return 0;
   857 }
   858 
   859 static Sint16
   860 IMA_ADPCM_ProcessNibble(Sint8 *cindex, Sint16 lastsample, Uint8 nybble)
   861 {
   862     const Sint32 max_audioval = 32767;
   863     const Sint32 min_audioval = -32768;
   864     const Sint8 index_table_4b[16] = {
   865         -1, -1, -1, -1,
   866         2, 4, 6, 8,
   867         -1, -1, -1, -1,
   868         2, 4, 6, 8
   869     };
   870     const Uint16 step_table[89] = {
   871         7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
   872         34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
   873         143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
   874         449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
   875         1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
   876         3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
   877         9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
   878         22385, 24623, 27086, 29794, 32767
   879     };
   880     Uint32 step;
   881     Sint32 sample, delta;
   882     Sint8 index = *cindex;
   883 
   884     /* Clamp index into valid range. */
   885     if (index > 88) {
   886         index = 88;
   887     } else if (index < 0) {
   888         index = 0;
   889     }
   890 
   891     /* explicit cast to avoid gcc warning about using 'char' as array index */
   892     step = step_table[(size_t)index];
   893 
   894     /* Update index value */
   895     *cindex = index + index_table_4b[nybble];
   896 
   897     /* This calculation uses shifts and additions because multiplications were
   898      * much slower back then. Sadly, this can't just be replaced with an actual
   899      * multiplication now as the old algorithm drops some bits. The closest
   900      * approximation I could find is something like this:
   901      * (nybble & 0x8 ? -1 : 1) * ((nybble & 0x7) * step / 4 + step / 8)
   902      */
   903     delta = step >> 3;
   904     if (nybble & 0x04)
   905         delta += step;
   906     if (nybble & 0x02)
   907         delta += step >> 1;
   908     if (nybble & 0x01)
   909         delta += step >> 2;
   910     if (nybble & 0x08)
   911         delta = -delta;
   912 
   913     sample = lastsample + delta;
   914 
   915     /* Clamp output sample */
   916     if (sample > max_audioval) {
   917         sample = max_audioval;
   918     } else if (sample < min_audioval) {
   919         sample = min_audioval;
   920     }
   921 
   922     return (Sint16)sample;
   923 }
   924 
   925 static int
   926 IMA_ADPCM_DecodeBlockHeader(ADPCM_DecoderState *state)
   927 {
   928     Sint16 step;
   929     Uint32 c;
   930     Uint8 *cstate = (Uint8 *) state->cstate;
   931 
   932     for (c = 0; c < state->channels; c++) {
   933         size_t o = state->block.pos + c * 4;
   934 
   935         /* Extract the sample from the header. */
   936         Sint32 sample = state->block.data[o] | ((Sint32)state->block.data[o + 1] << 8);
   937         if (sample >= 0x8000) {
   938             sample -= 0x10000;
   939         }
   940         state->output.data[state->output.pos++] = (Sint16)sample;
   941 
   942         /* Channel step index. */
   943         step = (Sint16)state->block.data[o + 2];
   944         cstate[c] = (Sint8)(step > 0x80 ? step - 0x100 : step);
   945 
   946         /* Reserved byte in block header, should be 0. */
   947         if (state->block.data[o + 3] != 0) {
   948             /* Uh oh, corrupt data?  Buggy code? */ ;
   949         }
   950     }
   951 
   952     state->block.pos += state->blockheadersize;
   953 
   954     /* Header provided one sample frame. */
   955     state->framesleft--;
   956 
   957     return 0;
   958 }
   959 
   960 /* Decodes the data of the IMA ADPCM block. Decoding will stop if a block is too
   961  * short, returning with none or partially decoded data. The partial data always
   962  * contains full sample frames (same sample count for each channel).
   963  * Incomplete sample frames are discarded.
   964  */
   965 static int
   966 IMA_ADPCM_DecodeBlockData(ADPCM_DecoderState *state)
   967 {
   968     size_t i;
   969     int retval = 0;
   970     const Uint32 channels = state->channels;
   971     const size_t subblockframesize = channels * 4;
   972     Uint64 bytesrequired;
   973     Uint32 c;
   974 
   975     size_t blockpos = state->block.pos;
   976     size_t blocksize = state->block.size;
   977     size_t blockleft = blocksize - blockpos;
   978 
   979     size_t outpos = state->output.pos;
   980 
   981     Sint64 blockframesleft = state->samplesperblock - 1;
   982     if (blockframesleft > state->framesleft) {
   983         blockframesleft = state->framesleft;
   984     }
   985 
   986     bytesrequired = (blockframesleft + 7) / 8 * subblockframesize;
   987     if (blockleft < bytesrequired) {
   988         /* Data truncated. Calculate how many samples we can get out if it. */
   989         const size_t guaranteedframes = blockleft / subblockframesize;
   990         const size_t remainingbytes = blockleft % subblockframesize;
   991         blockframesleft = guaranteedframes;
   992         if (remainingbytes > subblockframesize - 4) {
   993             blockframesleft += (remainingbytes % 4) * 2;
   994         }
   995         /* Signal the truncation. */
   996         retval = -1;
   997     }
   998 
   999     /* Each channel has their nibbles packed into 32-bit blocks. These blocks
  1000      * are interleaved and make up the data part of the ADPCM block. This loop
  1001      * decodes the samples as they come from the input data and puts them at
  1002      * the appropriate places in the output data.
  1003      */
  1004     while (blockframesleft > 0) {
  1005         const size_t subblocksamples = blockframesleft < 8 ? (size_t)blockframesleft : 8;
  1006 
  1007         for (c = 0; c < channels; c++) {
  1008             Uint8 nybble = 0;
  1009             /* Load previous sample which may come from the block header. */
  1010             Sint16 sample = state->output.data[outpos + c - channels];
  1011 
  1012             for (i = 0; i < subblocksamples; i++) {
  1013                 if (i & 1) {
  1014                     nybble >>= 4;
  1015                 } else {
  1016                     nybble = state->block.data[blockpos++];
  1017                 }
  1018 
  1019                 sample = IMA_ADPCM_ProcessNibble((Sint8 *)state->cstate + c, sample, nybble & 0x0f);
  1020                 state->output.data[outpos + c + i * channels] = sample;
  1021             }
  1022         }
  1023 
  1024         outpos += channels * subblocksamples;
  1025         state->framesleft -= subblocksamples;
  1026         blockframesleft -= subblocksamples;
  1027     }
  1028 
  1029     state->block.pos = blockpos;
  1030     state->output.pos = outpos;
  1031 
  1032     return retval;
  1033 }
  1034 
  1035 static int
  1036 IMA_ADPCM_Decode(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
  1037 {
  1038     int result;
  1039     size_t bytesleft, outputsize;
  1040     WaveChunk *chunk = &file->chunk;
  1041     ADPCM_DecoderState state;
  1042     Sint8 *cstate;
  1043 
  1044     if (chunk->size != chunk->length) {
  1045         /* Could not read everything. Recalculate number of sample frames. */
  1046         if (IMA_ADPCM_CalculateSampleFrames(file, chunk->size) < 0) {
  1047             return -1;
  1048         }
  1049     }
  1050 
  1051     /* Nothing to decode, nothing to return. */
  1052     if (file->sampleframes == 0) {
  1053         *audio_buf = NULL;
  1054         *audio_len = 0;
  1055         return 0;
  1056     }
  1057 
  1058     SDL_zero(state);
  1059     state.channels = file->format.channels;
  1060     state.blocksize = file->format.blockalign;
  1061     state.blockheadersize = (size_t)state.channels * 4;
  1062     state.samplesperblock = file->format.samplesperblock;
  1063     state.framesize = state.channels * sizeof(Sint16);
  1064     state.framestotal = file->sampleframes;
  1065     state.framesleft = state.framestotal;
  1066 
  1067     state.input.data = chunk->data;
  1068     state.input.size = chunk->size;
  1069     state.input.pos = 0;
  1070 
  1071     /* The output size in bytes. May get modified if data is truncated. */
  1072     outputsize = (size_t)state.framestotal;
  1073     if (SafeMult(&outputsize, state.framesize)) {
  1074         return SDL_OutOfMemory();
  1075     } else if (outputsize > SDL_MAX_UINT32 || state.framestotal > SIZE_MAX) {
  1076         return SDL_SetError("WAVE file too big");
  1077     }
  1078 
  1079     state.output.pos = 0;
  1080     state.output.size = outputsize / sizeof(Sint16);
  1081     state.output.data = (Sint16 *)SDL_malloc(outputsize);
  1082     if (state.output.data == NULL) {
  1083         return SDL_OutOfMemory();
  1084     }
  1085 
  1086     cstate = (Sint8 *)SDL_calloc(state.channels, sizeof(Sint8));
  1087     if (cstate == NULL) {
  1088         SDL_free(state.output.data);
  1089         return SDL_OutOfMemory();
  1090     }
  1091     state.cstate = cstate;
  1092 
  1093     /* Decode block by block. A truncated block will stop the decoding. */
  1094     bytesleft = state.input.size - state.input.pos;
  1095     while (state.framesleft > 0 && bytesleft >= state.blockheadersize) {
  1096         state.block.data = state.input.data + state.input.pos;
  1097         state.block.size = bytesleft < state.blocksize ? bytesleft : state.blocksize;
  1098         state.block.pos = 0;
  1099 
  1100         if (state.output.size - state.output.pos < (Uint64)state.framesleft * state.channels) {
  1101             /* Somehow didn't allocate enough space for the output. */
  1102             SDL_free(state.output.data);
  1103             SDL_free(cstate);
  1104             return SDL_SetError("Unexpected overflow in IMA ADPCM decoder");
  1105         }
  1106 
  1107         /* Initialize decoder with the values from the block header. */
  1108         result = IMA_ADPCM_DecodeBlockHeader(&state);
  1109         if (result == 0) {
  1110             /* Decode the block data. It stores the samples directly in the output. */
  1111             result = IMA_ADPCM_DecodeBlockData(&state);
  1112         }
  1113 
  1114         if (result == -1) {
  1115             /* Unexpected end. Stop decoding and return partial data if necessary. */
  1116             if (file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict) {
  1117                 SDL_free(state.output.data);
  1118                 SDL_free(cstate);
  1119                 return SDL_SetError("Truncated data chunk");
  1120             } else if (file->trunchint != TruncDropFrame) {
  1121                 state.output.pos -= state.output.pos % (state.samplesperblock * state.channels);
  1122             }
  1123             outputsize = state.output.pos * sizeof(Sint16); /* Can't overflow, is always smaller. */
  1124             break;
  1125         }
  1126 
  1127         state.input.pos += state.block.size;
  1128         bytesleft = state.input.size - state.input.pos;
  1129     }
  1130 
  1131     *audio_buf = (Uint8 *)state.output.data;
  1132     *audio_len = (Uint32)outputsize;
  1133 
  1134     SDL_free(cstate);
  1135 
  1136     return 0;
  1137 }
  1138 
  1139 static int
  1140 LAW_Init(WaveFile *file, size_t datalength)
  1141 {
  1142     WaveFormat *format = &file->format;
  1143 
  1144     /* Standards Update requires this to be 8. */
  1145     if (format->bitspersample != 8) {
  1146         return SDL_SetError("Invalid companded bits per sample of %u", (unsigned int)format->bitspersample);
  1147     }
  1148 
  1149     /* Not going to bother with weird padding. */
  1150     if (format->blockalign != format->channels) {
  1151         return SDL_SetError("Unsupported block alignment");
  1152     }
  1153 
  1154     if ((file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict)) {
  1155         if (format->blockalign > 1 && datalength % format->blockalign) {
  1156             return SDL_SetError("Truncated data chunk in WAVE file");
  1157         }
  1158     }
  1159 
  1160     file->sampleframes = WaveAdjustToFactValue(file, datalength / format->blockalign);
  1161     if (file->sampleframes < 0) {
  1162         return -1;
  1163     }
  1164 
  1165     return 0;
  1166 }
  1167 
  1168 static int
  1169 LAW_Decode(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
  1170 {
  1171 #ifdef SDL_WAVE_LAW_LUT
  1172     const Sint16 alaw_lut[256] = {
  1173         -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736, -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784, -2752,
  1174         -2624, -3008, -2880, -2240, -2112, -2496, -2368, -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392, -22016,
  1175         -20992, -24064, -23040, -17920, -16896, -19968, -18944, -30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136, -11008,
  1176         -10496, -12032, -11520, -8960, -8448, -9984, -9472, -15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568, -344,
  1177         -328, -376, -360, -280, -264, -312, -296, -472, -456, -504, -488, -408, -392, -440, -424, -88,
  1178         -72, -120, -104, -24, -8, -56, -40, -216, -200, -248, -232, -152, -136, -184, -168, -1376,
  1179         -1312, -1504, -1440, -1120, -1056, -1248, -1184, -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696, -688,
  1180         -656, -752, -720, -560, -528, -624, -592, -944, -912, -1008, -976, -816, -784, -880, -848, 5504,
  1181         5248, 6016, 5760, 4480, 4224, 4992, 4736, 7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784, 2752,
  1182         2624, 3008, 2880, 2240, 2112, 2496, 2368, 3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392, 22016,
  1183         20992, 24064, 23040, 17920, 16896, 19968, 18944, 30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136, 11008,
  1184         10496, 12032, 11520, 8960, 8448, 9984, 9472, 15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568, 344,
  1185         328, 376, 360, 280, 264, 312, 296, 472, 456, 504, 488, 408, 392, 440, 424, 88,
  1186         72, 120, 104, 24, 8, 56, 40, 216, 200, 248, 232, 152, 136, 184, 168, 1376,
  1187         1312, 1504, 1440, 1120, 1056, 1248, 1184, 1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696, 688,
  1188         656, 752, 720, 560, 528, 624, 592, 944, 912, 1008, 976, 816, 784, 880, 848
  1189     };
  1190     const Sint16 mulaw_lut[256] = {
  1191         -32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956, -23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764, -15996,
  1192         -15484, -14972, -14460, -13948, -13436, -12924, -12412, -11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316, -7932,
  1193         -7676, -7420, -7164, -6908, -6652, -6396, -6140, -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092, -3900,
  1194         -3772, -3644, -3516, -3388, -3260, -3132, -3004, -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980, -1884,
  1195         -1820, -1756, -1692, -1628, -1564, -1500, -1436, -1372, -1308, -1244, -1180, -1116, -1052, -988, -924, -876,
  1196         -844, -812, -780, -748, -716, -684, -652, -620, -588, -556, -524, -492, -460, -428, -396, -372,
  1197         -356, -340, -324, -308, -292, -276, -260, -244, -228, -212, -196, -180, -164, -148, -132, -120,
  1198         -112, -104, -96, -88, -80, -72, -64, -56, -48, -40, -32, -24, -16, -8, 0, 32124,
  1199         31100, 30076, 29052, 28028, 27004, 25980, 24956, 23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764, 15996,
  1200         15484, 14972, 14460, 13948, 13436, 12924, 12412, 11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316, 7932,
  1201         7676, 7420, 7164, 6908, 6652, 6396, 6140, 5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092, 3900,
  1202         3772, 3644, 3516, 3388, 3260, 3132, 3004, 2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980, 1884,
  1203         1820, 1756, 1692, 1628, 1564, 1500, 1436, 1372, 1308, 1244, 1180, 1116, 1052, 988, 924, 876,
  1204         844, 812, 780, 748, 716, 684, 652, 620, 588, 556, 524, 492, 460, 428, 396, 372,
  1205         356, 340, 324, 308, 292, 276, 260, 244, 228, 212, 196, 180, 164, 148, 132, 120,
  1206         112, 104, 96, 88, 80, 72, 64, 56, 48, 40, 32, 24, 16, 8, 0
  1207     };
  1208 #endif
  1209 
  1210     WaveFormat *format = &file->format;
  1211     WaveChunk *chunk = &file->chunk;
  1212     size_t i, sample_count, expanded_len;
  1213     Uint8 *src;
  1214     Sint16 *dst;
  1215 
  1216     if (chunk->length != chunk->size) {
  1217         file->sampleframes = WaveAdjustToFactValue(file, chunk->size / format->blockalign);
  1218         if (file->sampleframes < 0) {
  1219             return -1;
  1220         }
  1221     }
  1222 
  1223     /* Nothing to decode, nothing to return. */
  1224     if (file->sampleframes == 0) {
  1225         *audio_buf = NULL;
  1226         *audio_len = 0;
  1227         return 0;
  1228     }
  1229 
  1230     sample_count = (size_t)file->sampleframes;
  1231     if (SafeMult(&sample_count, format->channels)) {
  1232         return SDL_OutOfMemory();
  1233     }
  1234 
  1235     expanded_len = sample_count;
  1236     if (SafeMult(&expanded_len, sizeof(Sint16))) {
  1237         return SDL_OutOfMemory();
  1238     } else if (expanded_len > SDL_MAX_UINT32 || file->sampleframes > SIZE_MAX) {
  1239         return SDL_SetError("WAVE file too big");
  1240     }
  1241 
  1242     /* 1 to avoid allocating zero bytes, to keep static analysis happy. */
  1243     src = (Uint8 *)SDL_realloc(chunk->data, expanded_len ? expanded_len : 1);
  1244     if (src == NULL) {
  1245         return SDL_OutOfMemory();
  1246     }
  1247     chunk->data = NULL;
  1248     chunk->size = 0;
  1249 
  1250     dst = (Sint16 *)src;
  1251 
  1252     /* Work backwards, since we're expanding in-place. SDL_AudioSpec.format will
  1253      * inform the caller about the byte order.
  1254      */
  1255     i = sample_count;
  1256     switch (file->format.encoding) {
  1257 #ifdef SDL_WAVE_LAW_LUT
  1258     case ALAW_CODE:
  1259         while (i--) {
  1260             dst[i] = alaw_lut[src[i]];
  1261         }
  1262         break;
  1263     case MULAW_CODE:
  1264         while (i--) {
  1265             dst[i] = mulaw_lut[src[i]];
  1266         }
  1267         break;
  1268 #else
  1269     case ALAW_CODE:
  1270         while (i--) {
  1271             Uint8 nibble = src[i];
  1272             Uint8 exponent = (nibble & 0x7f) ^ 0x55;
  1273             Sint16 mantissa = exponent & 0xf;
  1274 
  1275             exponent >>= 4;
  1276             if (exponent > 0) {
  1277                 mantissa |= 0x10;
  1278             }
  1279             mantissa = (mantissa << 4) | 0x8;
  1280             if (exponent > 1) {
  1281                 mantissa <<= exponent - 1;
  1282             }
  1283 
  1284             dst[i] = nibble & 0x80 ? mantissa : -mantissa;
  1285         }
  1286         break;
  1287     case MULAW_CODE:
  1288         while (i--) {
  1289             Uint8 nibble = ~src[i];
  1290             Sint16 mantissa = nibble & 0xf;
  1291             Uint8 exponent = (nibble >> 4) & 0x7;
  1292             Sint16 step = 4 << (exponent + 1);
  1293 
  1294             mantissa = (0x80 << exponent) + step * mantissa + step / 2 - 132;
  1295 
  1296             dst[i] = nibble & 0x80 ? -mantissa : mantissa;
  1297         }
  1298         break;
  1299 #endif
  1300     default:
  1301         SDL_free(src);
  1302         return SDL_SetError("Unknown companded encoding");
  1303     }
  1304 
  1305     *audio_buf = src;
  1306     *audio_len = (Uint32)expanded_len;
  1307 
  1308     return 0;
  1309 }
  1310 
  1311 static int
  1312 PCM_Init(WaveFile *file, size_t datalength)
  1313 {
  1314     WaveFormat *format = &file->format;
  1315 
  1316     if (format->encoding == PCM_CODE) {
  1317         switch (format->bitspersample) {
  1318         case 8:
  1319         case 16:
  1320         case 24:
  1321         case 32:
  1322             /* These are supported. */
  1323             break;
  1324         default:
  1325             return SDL_SetError("%u-bit PCM format not supported", (unsigned int)format->bitspersample);
  1326         }
  1327     } else if (format->encoding == IEEE_FLOAT_CODE) {
  1328         if (format->bitspersample != 32) {
  1329             return SDL_SetError("%u-bit IEEE floating-point format not supported", (unsigned int)format->bitspersample);
  1330         }
  1331     }
  1332 
  1333     /* It wouldn't be that hard to support more exotic block sizes, but
  1334      * the most common formats should do for now.
  1335      */
  1336     /* Make sure we're a multiple of the blockalign, at least. */
  1337     if ((format->channels * format->bitspersample) % (format->blockalign * 8)) {
  1338         return SDL_SetError("Unsupported block alignment");
  1339     }
  1340 
  1341     if ((file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict)) {
  1342         if (format->blockalign > 1 && datalength % format->blockalign) {
  1343             return SDL_SetError("Truncated data chunk in WAVE file");
  1344         }
  1345     }
  1346 
  1347     file->sampleframes = WaveAdjustToFactValue(file, datalength / format->blockalign);
  1348     if (file->sampleframes < 0) {
  1349         return -1;
  1350     }
  1351 
  1352     return 0;
  1353 }
  1354 
  1355 static int
  1356 PCM_ConvertSint24ToSint32(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
  1357 {
  1358     WaveFormat *format = &file->format;
  1359     WaveChunk *chunk = &file->chunk;
  1360     size_t i, expanded_len, sample_count;
  1361     Uint8 *ptr;
  1362 
  1363     sample_count = (size_t)file->sampleframes;
  1364     if (SafeMult(&sample_count, format->channels)) {
  1365         return SDL_OutOfMemory();
  1366     }
  1367 
  1368     expanded_len = sample_count;
  1369     if (SafeMult(&expanded_len, sizeof(Sint32))) {
  1370         return SDL_OutOfMemory();
  1371     } else if (expanded_len > SDL_MAX_UINT32 || file->sampleframes > SIZE_MAX) {
  1372         return SDL_SetError("WAVE file too big");
  1373     }
  1374 
  1375     /* 1 to avoid allocating zero bytes, to keep static analysis happy. */
  1376     ptr = (Uint8 *)SDL_realloc(chunk->data, expanded_len ? expanded_len : 1);
  1377     if (ptr == NULL) {
  1378         return SDL_OutOfMemory();
  1379     }
  1380 
  1381     /* This pointer is now invalid. */
  1382     chunk->data = NULL;
  1383     chunk->size = 0;
  1384 
  1385     *audio_buf = ptr;
  1386     *audio_len = (Uint32)expanded_len;
  1387 
  1388     /* work from end to start, since we're expanding in-place. */
  1389     for (i = sample_count; i > 0; i--) {
  1390         const size_t o = i - 1;
  1391         uint8_t b[4];
  1392 
  1393         b[0] = 0;
  1394         b[1] = ptr[o * 3];
  1395         b[2] = ptr[o * 3 + 1];
  1396         b[3] = ptr[o * 3 + 2];
  1397 
  1398         ptr[o * 4 + 0] = b[0];
  1399         ptr[o * 4 + 1] = b[1];
  1400         ptr[o * 4 + 2] = b[2];
  1401         ptr[o * 4 + 3] = b[3];
  1402     }
  1403 
  1404     return 0;
  1405 }
  1406 
  1407 static int
  1408 PCM_Decode(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
  1409 {
  1410     WaveFormat *format = &file->format;
  1411     WaveChunk *chunk = &file->chunk;
  1412     size_t outputsize;
  1413 
  1414     if (chunk->length != chunk->size) {
  1415         file->sampleframes = WaveAdjustToFactValue(file, chunk->size / format->blockalign);
  1416         if (file->sampleframes < 0) {
  1417             return -1;
  1418         }
  1419     }
  1420 
  1421     /* Nothing to decode, nothing to return. */
  1422     if (file->sampleframes == 0) {
  1423         *audio_buf = NULL;
  1424         *audio_len = 0;
  1425         return 0;
  1426     }
  1427 
  1428     /* 24-bit samples get shifted to 32 bits. */
  1429     if (format->encoding == PCM_CODE && format->bitspersample == 24) {
  1430         return PCM_ConvertSint24ToSint32(file, audio_buf, audio_len);
  1431     }
  1432 
  1433     outputsize = (size_t)file->sampleframes;
  1434     if (SafeMult(&outputsize, format->blockalign)) {
  1435         return SDL_OutOfMemory();
  1436     } else if (outputsize > SDL_MAX_UINT32 || file->sampleframes > SIZE_MAX) {
  1437         return SDL_SetError("WAVE file too big");
  1438     }
  1439 
  1440     *audio_buf = chunk->data;
  1441     *audio_len = (Uint32)outputsize;
  1442 
  1443     /* This pointer is going to be returned to the caller. Prevent free in cleanup. */
  1444     chunk->data = NULL;
  1445     chunk->size = 0;
  1446 
  1447     return 0;
  1448 }
  1449 
  1450 static WaveRiffSizeHint
  1451 WaveGetRiffSizeHint()
  1452 {
  1453     const char *hint = SDL_GetHint(SDL_HINT_WAVE_RIFF_CHUNK_SIZE);
  1454 
  1455     if (hint != NULL) {
  1456         if (SDL_strcmp(hint, "force") == 0) {
  1457             return RiffSizeForce;
  1458         } else if (SDL_strcmp(hint, "ignore") == 0) {
  1459             return RiffSizeIgnore;
  1460         } else if (SDL_strcmp(hint, "ignorezero") == 0) {
  1461             return RiffSizeIgnoreZero;
  1462         } else if (SDL_strcmp(hint, "maximum") == 0) {
  1463             return RiffSizeMaximum;
  1464         }
  1465     }
  1466 
  1467     return RiffSizeNoHint;
  1468 }
  1469 
  1470 static WaveTruncationHint
  1471 WaveGetTruncationHint()
  1472 {
  1473     const char *hint = SDL_GetHint(SDL_HINT_WAVE_TRUNCATION);
  1474 
  1475     if (hint != NULL) {
  1476         if (SDL_strcmp(hint, "verystrict") == 0) {
  1477             return TruncVeryStrict;
  1478         } else if (SDL_strcmp(hint, "strict") == 0) {
  1479             return TruncStrict;
  1480         } else if (SDL_strcmp(hint, "dropframe") == 0) {
  1481             return TruncDropFrame;
  1482         } else if (SDL_strcmp(hint, "dropblock") == 0) {
  1483             return TruncDropBlock;
  1484         }
  1485     }
  1486 
  1487     return TruncNoHint;
  1488 }
  1489 
  1490 static WaveFactChunkHint
  1491 WaveGetFactChunkHint()
  1492 {
  1493     const char *hint = SDL_GetHint(SDL_HINT_WAVE_FACT_CHUNK);
  1494 
  1495     if (hint != NULL) {
  1496         if (SDL_strcmp(hint, "truncate") == 0) {
  1497             return FactTruncate;
  1498         } else if (SDL_strcmp(hint, "strict") == 0) {
  1499             return FactStrict;
  1500         } else if (SDL_strcmp(hint, "ignorezero") == 0) {
  1501             return FactIgnoreZero;
  1502         } else if (SDL_strcmp(hint, "ignore") == 0) {
  1503             return FactIgnore;
  1504         }
  1505     }
  1506 
  1507     return FactNoHint;
  1508 }
  1509 
  1510 static void
  1511 WaveFreeChunkData(WaveChunk *chunk)
  1512 {
  1513     if (chunk->data != NULL) {
  1514         SDL_free(chunk->data);
  1515         chunk->data = NULL;
  1516     }
  1517     chunk->size = 0;
  1518 }
  1519 
  1520 static int
  1521 WaveNextChunk(SDL_RWops *src, WaveChunk *chunk)
  1522 {
  1523     Uint32 chunkheader[2];
  1524     Sint64 nextposition = chunk->position + chunk->length;
  1525 
  1526     /* Data is no longer valid after this function returns. */
  1527     WaveFreeChunkData(chunk);
  1528 
  1529     /* Error on overflows. */
  1530     if (SDL_MAX_SINT64 - chunk->length < chunk->position || SDL_MAX_SINT64 - 8 < nextposition) {
  1531         return -1;
  1532     }
  1533 
  1534     /* RIFF chunks have a 2-byte alignment. Skip padding byte. */
  1535     if (chunk->length & 1) {
  1536         nextposition++;
  1537     }
  1538 
  1539     if (SDL_RWseek(src, nextposition, RW_SEEK_SET) != nextposition) {
  1540         /* Not sure how we ended up here. Just abort. */
  1541         return -2;
  1542     } else if (SDL_RWread(src, chunkheader, 4, 2) != 2) {
  1543         return -1;
  1544     }
  1545 
  1546     chunk->fourcc = SDL_SwapLE32(chunkheader[0]);
  1547     chunk->length = SDL_SwapLE32(chunkheader[1]);
  1548     chunk->position = nextposition + 8;
  1549 
  1550     return 0;
  1551 }
  1552 
  1553 static int
  1554 WaveReadPartialChunkData(SDL_RWops *src, WaveChunk *chunk, size_t length)
  1555 {
  1556     WaveFreeChunkData(chunk);
  1557 
  1558     if (length > chunk->length) {
  1559         length = chunk->length;
  1560     }
  1561 
  1562     if (length > 0) {
  1563         chunk->data = (Uint8 *) SDL_malloc(length);
  1564         if (chunk->data == NULL) {
  1565             return SDL_OutOfMemory();
  1566         }
  1567 
  1568         if (SDL_RWseek(src, chunk->position, RW_SEEK_SET) != chunk->position) {
  1569             /* Not sure how we ended up here. Just abort. */
  1570             return -2;
  1571         }
  1572 
  1573         chunk->size = SDL_RWread(src, chunk->data, 1, length);
  1574         if (chunk->size != length) {
  1575             /* Expected to be handled by the caller. */
  1576         }
  1577     }
  1578 
  1579     return 0;
  1580 }
  1581 
  1582 static int
  1583 WaveReadChunkData(SDL_RWops *src, WaveChunk *chunk)
  1584 {
  1585     return WaveReadPartialChunkData(src, chunk, chunk->length);
  1586 }
  1587 
  1588 typedef struct WaveExtensibleGUID {
  1589     Uint16 encoding;
  1590     Uint8 guid[16];
  1591 } WaveExtensibleGUID;
  1592 
  1593 /* Some of the GUIDs that are used by WAVEFORMATEXTENSIBLE. */
  1594 #define WAVE_FORMATTAG_GUID(tag) {(tag) & 0xff, (tag) >> 8, 0, 0, 0, 0, 16, 0, 128, 0, 0, 170, 0, 56, 155, 113}
  1595 static WaveExtensibleGUID extensible_guids[] = {
  1596     {PCM_CODE,        WAVE_FORMATTAG_GUID(PCM_CODE)},
  1597     {MS_ADPCM_CODE,   WAVE_FORMATTAG_GUID(MS_ADPCM_CODE)},
  1598     {IEEE_FLOAT_CODE, WAVE_FORMATTAG_GUID(IEEE_FLOAT_CODE)},
  1599     {ALAW_CODE,       WAVE_FORMATTAG_GUID(ALAW_CODE)},
  1600     {MULAW_CODE,      WAVE_FORMATTAG_GUID(MULAW_CODE)},
  1601     {IMA_ADPCM_CODE,  WAVE_FORMATTAG_GUID(IMA_ADPCM_CODE)}
  1602 };
  1603 
  1604 static Uint16
  1605 WaveGetFormatGUIDEncoding(WaveFormat *format)
  1606 {
  1607     size_t i;
  1608     for (i = 0; i < SDL_arraysize(extensible_guids); i++) {
  1609         if (SDL_memcmp(format->subformat, extensible_guids[i].guid, 16) == 0) {
  1610             return extensible_guids[i].encoding;
  1611         }
  1612     }
  1613     return UNKNOWN_CODE;
  1614 }
  1615 
  1616 static int
  1617 WaveReadFormat(WaveFile *file)
  1618 {
  1619     WaveChunk *chunk = &file->chunk;
  1620     WaveFormat *format = &file->format;
  1621     SDL_RWops *fmtsrc;
  1622     size_t fmtlen = chunk->size;
  1623 
  1624     if (fmtlen > SDL_MAX_SINT32) {
  1625         /* Limit given by SDL_RWFromConstMem. */
  1626         return SDL_SetError("Data of WAVE fmt chunk too big");
  1627     }
  1628     fmtsrc = SDL_RWFromConstMem(chunk->data, (int)chunk->size);
  1629     if (fmtsrc == NULL) {
  1630         return SDL_OutOfMemory();
  1631     }
  1632 
  1633     format->formattag = SDL_ReadLE16(fmtsrc);
  1634     format->encoding = format->formattag;
  1635     format->channels = SDL_ReadLE16(fmtsrc);
  1636     format->frequency = SDL_ReadLE32(fmtsrc);
  1637     format->byterate = SDL_ReadLE32(fmtsrc);
  1638     format->blockalign = SDL_ReadLE16(fmtsrc);
  1639 
  1640     /* This is PCM specific in the first version of the specification. */
  1641     if (fmtlen >= 16) {
  1642         format->bitspersample = SDL_ReadLE16(fmtsrc);
  1643     } else if (format->encoding == PCM_CODE) {
  1644         SDL_RWclose(fmtsrc);
  1645         return SDL_SetError("Missing wBitsPerSample field in WAVE fmt chunk");
  1646     }
  1647 
  1648     /* The earlier versions also don't have this field. */
  1649     if (fmtlen >= 18) {
  1650         format->extsize = SDL_ReadLE16(fmtsrc);
  1651     }
  1652 
  1653     if (format->formattag == EXTENSIBLE_CODE) {
  1654         /* note that this ignores channel masks, smaller valid bit counts
  1655          * inside a larger container, and most subtypes. This is just enough
  1656          * to get things that didn't really _need_ WAVE_FORMAT_EXTENSIBLE
  1657          * to be useful working when they use this format flag.
  1658          */
  1659 
  1660         /* Extensible header must be at least 22 bytes. */
  1661         if (fmtlen < 40 || format->extsize < 22) {
  1662             SDL_RWclose(fmtsrc);
  1663             return SDL_SetError("Extensible WAVE header too small");
  1664         }
  1665 
  1666         format->validsamplebits = SDL_ReadLE16(fmtsrc);
  1667         format->samplesperblock = format->validsamplebits;
  1668         format->channelmask = SDL_ReadLE32(fmtsrc);
  1669         SDL_RWread(fmtsrc, format->subformat, 1, 16);
  1670         format->encoding = WaveGetFormatGUIDEncoding(format);
  1671     }
  1672 
  1673     SDL_RWclose(fmtsrc);
  1674 
  1675     return 0;
  1676 }
  1677 
  1678 static int
  1679 WaveCheckFormat(WaveFile *file, size_t datalength)
  1680 {
  1681     WaveFormat *format = &file->format;
  1682 
  1683     /* Check for some obvious issues. */
  1684 
  1685     if (format->channels == 0) {
  1686         return SDL_SetError("Invalid number of channels");
  1687     } else if (format->channels > 255) {
  1688         /* Limit given by SDL_AudioSpec.channels. */
  1689         return SDL_SetError("Number of channels exceeds limit of 255");
  1690     }
  1691 
  1692     if (format->frequency == 0) {
  1693         return SDL_SetError("Invalid sample rate");
  1694     } else if (format->frequency > INT_MAX) {
  1695         /* Limit given by SDL_AudioSpec.freq. */
  1696         return SDL_SetError("Sample rate exceeds limit of %d", INT_MAX);
  1697     }
  1698 
  1699     /* Reject invalid fact chunks in strict mode. */
  1700     if (file->facthint == FactStrict && file->fact.status == -1) {
  1701         return SDL_SetError("Invalid fact chunk in WAVE file");
  1702     }
  1703 
  1704     /* Check for issues common to all encodings. Some unsupported formats set
  1705      * the bits per sample to zero. These fall through to the 'unsupported
  1706      * format' error.
  1707      */
  1708     switch (format->encoding) {
  1709     case IEEE_FLOAT_CODE:
  1710     case ALAW_CODE:
  1711     case MULAW_CODE:
  1712     case MS_ADPCM_CODE:
  1713     case IMA_ADPCM_CODE:
  1714         /* These formats require a fact chunk. */
  1715         if (file->facthint == FactStrict && file->fact.status <= 0) {
  1716             return SDL_SetError("Missing fact chunk in WAVE file");
  1717         }
  1718         /* fallthrough */
  1719     case PCM_CODE:
  1720         /* All supported formats require a non-zero bit depth. */
  1721         if (file->chunk.size < 16) {
  1722             return SDL_SetError("Missing wBitsPerSample field in WAVE fmt chunk");
  1723         } else if (format->bitspersample == 0) {
  1724             return SDL_SetError("Invalid bits per sample");
  1725         }
  1726 
  1727         /* All supported formats must have a proper block size. */
  1728         if (format->blockalign == 0) {
  1729             return SDL_SetError("Invalid block alignment");
  1730         }
  1731 
  1732         /* If the fact chunk is valid and the appropriate hint is set, the
  1733          * decoders will use the number of sample frames from the fact chunk.
  1734          */
  1735         if (file->fact.status == 1) {
  1736             WaveFactChunkHint hint = file->facthint;
  1737             Uint32 samples = file->fact.samplelength;
  1738             if (hint == FactTruncate || hint == FactStrict || (hint == FactIgnoreZero && samples > 0)) {
  1739                 file->fact.status = 2;
  1740             }
  1741         }
  1742     }
  1743 
  1744     /* Check the format for encoding specific issues and initialize decoders. */
  1745     switch (format->encoding) {
  1746     case PCM_CODE:
  1747     case IEEE_FLOAT_CODE:
  1748         if (PCM_Init(file, datalength) < 0) {
  1749             return -1;
  1750         }
  1751         break;
  1752     case ALAW_CODE:
  1753     case MULAW_CODE:
  1754         if (LAW_Init(file, datalength) < 0) {
  1755             return -1;
  1756         }
  1757         break;
  1758     case MS_ADPCM_CODE:
  1759         if (MS_ADPCM_Init(file, datalength) < 0) {
  1760             return -1;
  1761         }
  1762         break;
  1763     case IMA_ADPCM_CODE:
  1764         if (IMA_ADPCM_Init(file, datalength) < 0) {
  1765             return -1;
  1766         }
  1767         break;
  1768     case MPEG_CODE:
  1769     case MPEGLAYER3_CODE:
  1770         return SDL_SetError("MPEG formats not supported");
  1771     default:
  1772         if (format->formattag == EXTENSIBLE_CODE) {
  1773             const char *errstr = "Unknown WAVE format GUID: %08x-%04x-%04x-%02x%02x%02x%02x%02x%02x%02x%02x";
  1774             const Uint8 *g = format->subformat;
  1775             const Uint32 g1 = g[0] | ((Uint32)g[1] << 8) | ((Uint32)g[2] << 16) | ((Uint32)g[3] << 24);
  1776             const Uint32 g2 = g[4] | ((Uint32)g[5] << 8);
  1777             const Uint32 g3 = g[6] | ((Uint32)g[7] << 8);
  1778             return SDL_SetError(errstr, g1, g2, g3, g[8], g[9], g[10], g[11], g[12], g[13], g[14], g[15]);
  1779         }
  1780         return SDL_SetError("Unknown WAVE format tag: 0x%04x", (unsigned int)format->encoding);
  1781     }
  1782 
  1783     return 0;
  1784 }
  1785 
  1786 static int
  1787 WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
  1788 {
  1789     int result;
  1790     Uint32 chunkcount = 0;
  1791     Uint32 chunkcountlimit = 10000;
  1792     char *envchunkcountlimit;
  1793     Sint64 RIFFstart, RIFFend, lastchunkpos;
  1794     SDL_bool RIFFlengthknown = SDL_FALSE;
  1795     WaveFormat *format = &file->format;
  1796     WaveChunk *chunk = &file->chunk;
  1797     WaveChunk RIFFchunk;
  1798     WaveChunk fmtchunk;
  1799     WaveChunk datachunk;
  1800 
  1801     SDL_zero(RIFFchunk);
  1802     SDL_zero(fmtchunk);
  1803     SDL_zero(datachunk);
  1804 
  1805     envchunkcountlimit = SDL_getenv("SDL_WAVE_CHUNK_LIMIT");
  1806     if (envchunkcountlimit != NULL) {
  1807         unsigned int count;
  1808         if (SDL_sscanf(envchunkcountlimit, "%u", &count) == 1) {
  1809             chunkcountlimit = count <= SDL_MAX_UINT32 ? count : SDL_MAX_UINT32;
  1810         }
  1811     }
  1812 
  1813     RIFFstart = SDL_RWtell(src);
  1814     if (RIFFstart < 0) {
  1815         return SDL_SetError("Could not seek in file");
  1816     }
  1817 
  1818     RIFFchunk.position = RIFFstart;
  1819     if (WaveNextChunk(src, &RIFFchunk) < 0) {
  1820         return SDL_SetError("Could not read RIFF header");
  1821     }
  1822 
  1823     /* Check main WAVE file identifiers. */
  1824     if (RIFFchunk.fourcc == RIFF) {
  1825         Uint32 formtype;
  1826         /* Read the form type. "WAVE" expected. */
  1827         if (SDL_RWread(src, &formtype, sizeof(Uint32), 1) != 1) {
  1828             return SDL_SetError("Could not read RIFF form type");
  1829         } else if (SDL_SwapLE32(formtype) != WAVE) {
  1830             return SDL_SetError("RIFF form type is not WAVE (not a Waveform file)");
  1831         }
  1832     } else if (RIFFchunk.fourcc == WAVE) {
  1833         /* RIFF chunk missing or skipped. Length unknown. */
  1834         RIFFchunk.position = 0;
  1835         RIFFchunk.length = 0;
  1836     } else {
  1837         return SDL_SetError("Could not find RIFF or WAVE identifiers (not a Waveform file)");
  1838     }
  1839 
  1840     /* The 4-byte form type is immediately followed by the first chunk.*/
  1841     chunk->position = RIFFchunk.position + 4;
  1842 
  1843     /* Use the RIFF chunk size to limit the search for the chunks. This is not
  1844      * always reliable and the hint can be used to tune the behavior. By
  1845      * default, it will never search past 4 GiB.
  1846      */
  1847     switch (file->riffhint) {
  1848     case RiffSizeIgnore:
  1849         RIFFend = RIFFchunk.position + SDL_MAX_UINT32;
  1850         break;
  1851     default:
  1852     case RiffSizeIgnoreZero:
  1853         if (RIFFchunk.length == 0) {
  1854             RIFFend = RIFFchunk.position + SDL_MAX_UINT32;
  1855             break;
  1856         }
  1857         /* fallthrough */
  1858     case RiffSizeForce:
  1859         RIFFend = RIFFchunk.position + RIFFchunk.length;
  1860         RIFFlengthknown = SDL_TRUE;
  1861         break;
  1862     case RiffSizeMaximum:
  1863         RIFFend = SDL_MAX_SINT64;
  1864         break;
  1865     }
  1866 
  1867     /* Step through all chunks and save information on the fmt, data, and fact
  1868      * chunks. Ignore the chunks we don't know as per specification. This
  1869      * currently also ignores cue, list, and slnt chunks.
  1870      */
  1871     while ((Uint64)RIFFend > (Uint64)chunk->position + chunk->length + (chunk->length & 1)) {
  1872         /* Abort after too many chunks or else corrupt files may waste time. */
  1873         if (chunkcount++ >= chunkcountlimit) {
  1874             return SDL_SetError("Chunk count in WAVE file exceeds limit of %u", chunkcountlimit);
  1875         }
  1876 
  1877         result = WaveNextChunk(src, chunk);
  1878         if (result == -1) {
  1879             /* Unexpected EOF. Corrupt file or I/O issues. */
  1880             if (file->trunchint == TruncVeryStrict) {
  1881                 return SDL_SetError("Unexpected end of WAVE file");
  1882             }
  1883             /* Let the checks after this loop sort this issue out. */
  1884             break;
  1885         } else if (result == -2) {
  1886             return SDL_SetError("Could not seek to WAVE chunk header");
  1887         }
  1888 
  1889         if (chunk->fourcc == FMT) {
  1890             if (fmtchunk.fourcc == FMT) {
  1891                 /* Multiple fmt chunks. Ignore or error? */
  1892             } else {
  1893                 /* The fmt chunk must occur before the data chunk. */
  1894                 if (datachunk.fourcc == DATA) {
  1895                     return SDL_SetError("fmt chunk after data chunk in WAVE file");
  1896                 }
  1897                 fmtchunk = *chunk;
  1898             }
  1899         } else if (chunk->fourcc == DATA) {
  1900             /* Only use the first data chunk. Handling the wavl list madness
  1901              * may require a different approach.
  1902              */
  1903             if (datachunk.fourcc != DATA) {
  1904                 datachunk = *chunk;
  1905             }
  1906         } else if (chunk->fourcc == FACT) {
  1907             /* The fact chunk data must be at least 4 bytes for the
  1908              * dwSampleLength field. Ignore all fact chunks after the first one.
  1909              */
  1910             if (file->fact.status == 0) {
  1911                 if (chunk->length < 4) {
  1912                     file->fact.status = -1;
  1913                 } else {
  1914                     /* Let's use src directly, it's just too convenient. */
  1915                     Sint64 position = SDL_RWseek(src, chunk->position, RW_SEEK_SET);
  1916                     Uint32 samplelength;
  1917                     if (position == chunk->position && SDL_RWread(src, &samplelength, sizeof(Uint32), 1) == 1) {
  1918                         file->fact.status = 1;
  1919                         file->fact.samplelength = SDL_SwapLE32(samplelength);
  1920                     } else {
  1921                         file->fact.status = -1;
  1922                     }
  1923                 }
  1924             }
  1925         }
  1926 
  1927         /* Go through all chunks in verystrict mode or stop the search early if
  1928          * all required chunks were found.
  1929          */
  1930         if (file->trunchint == TruncVeryStrict) {
  1931             if ((Uint64)RIFFend < (Uint64)chunk->position + chunk->length) {
  1932                 return SDL_SetError("RIFF size truncates chunk");
  1933             }
  1934         } else if (fmtchunk.fourcc == FMT && datachunk.fourcc == DATA) {
  1935             if (file->fact.status == 1 || file->facthint == FactIgnore || file->facthint == FactNoHint) {
  1936                 break;
  1937             }
  1938         }
  1939     }
  1940 
  1941     /* Save the position after the last chunk. This position will be used if the
  1942      * RIFF length is unknown.
  1943      */
  1944     lastchunkpos = chunk->position + chunk->length;
  1945 
  1946     /* The fmt chunk is mandatory. */
  1947     if (fmtchunk.fourcc != FMT) {
  1948         return SDL_SetError("Missing fmt chunk in WAVE file");
  1949     }
  1950     /* A data chunk must be present. */
  1951     if (datachunk.fourcc != DATA) {
  1952         return SDL_SetError("Missing data chunk in WAVE file");
  1953     }
  1954     /* Check if the last chunk has all of its data in verystrict mode. */
  1955     if (file->trunchint == TruncVeryStrict) {
  1956         /* data chunk is handled later. */
  1957         if (chunk->fourcc != DATA && chunk->length > 0) {
  1958             Uint8 tmp;
  1959             Uint64 position = (Uint64)chunk->position + chunk->length - 1;
  1960             if (position > SDL_MAX_SINT64 || SDL_RWseek(src, (Sint64)position, RW_SEEK_SET) != (Sint64)position) {
  1961                 return SDL_SetError("Could not seek to WAVE chunk data");
  1962             } else if (SDL_RWread(src, &tmp, 1, 1) != 1) {
  1963                 return SDL_SetError("RIFF size truncates chunk");
  1964             }
  1965         }
  1966     }
  1967 
  1968     /* Process fmt chunk. */
  1969     *chunk = fmtchunk;
  1970 
  1971     /* No need to read more than 1046 bytes of the fmt chunk data with the
  1972      * formats that are currently supported. (1046 because of MS ADPCM coefficients)
  1973      */
  1974     if (WaveReadPartialChunkData(src, chunk, 1046) < 0) {
  1975         return SDL_SetError("Could not read data of WAVE fmt chunk");
  1976     }
  1977 
  1978     /* The fmt chunk data must be at least 14 bytes to include all common fields.
  1979      * It usually is 16 and larger depending on the header and encoding.
  1980      */
  1981     if (chunk->length < 14) {
  1982         return SDL_SetError("Invalid WAVE fmt chunk length (too small)");
  1983     } else if (chunk->size < 14) {
  1984         return SDL_SetError("Could not read data of WAVE fmt chunk");
  1985     } else if (WaveReadFormat(file) < 0) {
  1986         return -1;
  1987     } else if (WaveCheckFormat(file, (size_t)datachunk.length) < 0) {
  1988         return -1;
  1989     }
  1990 
  1991 #ifdef SDL_WAVE_DEBUG_LOG_FORMAT
  1992     WaveDebugLogFormat(file);
  1993 #endif
  1994 #ifdef SDL_WAVE_DEBUG_DUMP_FORMAT
  1995     WaveDebugDumpFormat(file, RIFFchunk.length, fmtchunk.length, datachunk.length);
  1996 #endif
  1997 
  1998     WaveFreeChunkData(chunk);
  1999 
  2000     /* Process data chunk. */
  2001     *chunk = datachunk;
  2002 
  2003     if (chunk->length > 0) {
  2004         result = WaveReadChunkData(src, chunk);
  2005         if (result == -1) {
  2006             return -1;
  2007         } else if (result == -2) {
  2008             return SDL_SetError("Could not seek data of WAVE data chunk");
  2009         }
  2010     }
  2011 
  2012     if (chunk->length != chunk->size) {
  2013         /* I/O issues or corrupt file. */
  2014         if (file->trunchint == TruncVeryStrict || file->trunchint == TruncStrict) {
  2015             return SDL_SetError("Could not read data of WAVE data chunk");
  2016         }
  2017         /* The decoders handle this truncation. */
  2018     }
  2019 
  2020     /* Decode or convert the data if necessary. */
  2021     switch (format->encoding) {
  2022     case PCM_CODE:
  2023     case IEEE_FLOAT_CODE:
  2024         if (PCM_Decode(file, audio_buf, audio_len) < 0) {
  2025             return -1;
  2026         }
  2027         break;
  2028     case ALAW_CODE:
  2029     case MULAW_CODE:
  2030         if (LAW_Decode(file, audio_buf, audio_len) < 0) {
  2031             return -1;
  2032         }
  2033         break;
  2034     case MS_ADPCM_CODE:
  2035         if (MS_ADPCM_Decode(file, audio_buf, audio_len) < 0) {
  2036             return -1;
  2037         }
  2038         break;
  2039     case IMA_ADPCM_CODE:
  2040         if (IMA_ADPCM_Decode(file, audio_buf, audio_len) < 0) {
  2041             return -1;
  2042         }
  2043         break;
  2044     }
  2045 
  2046     /* Setting up the SDL_AudioSpec. All unsupported formats were filtered out
  2047      * by checks earlier in this function.
  2048      */
  2049     SDL_zerop(spec);
  2050     spec->freq = format->frequency;
  2051     spec->channels = (Uint8)format->channels;
  2052     spec->samples = 4096;       /* Good default buffer size */
  2053 
  2054     switch (format->encoding) {
  2055     case MS_ADPCM_CODE:
  2056     case IMA_ADPCM_CODE:
  2057     case ALAW_CODE:
  2058     case MULAW_CODE:
  2059         /* These can be easily stored in the byte order of the system. */
  2060         spec->format = AUDIO_S16SYS;
  2061         break;
  2062     case IEEE_FLOAT_CODE:
  2063         spec->format = AUDIO_F32LSB;
  2064         break;
  2065     case PCM_CODE:
  2066         switch (format->bitspersample) {
  2067         case 8:
  2068             spec->format = AUDIO_U8;
  2069             break;
  2070         case 16:
  2071             spec->format = AUDIO_S16LSB;
  2072             break;
  2073         case 24: /* Has been shifted to 32 bits. */
  2074         case 32:
  2075             spec->format = AUDIO_S32LSB;
  2076             break;
  2077         default:
  2078             /* Just in case something unexpected happened in the checks. */
  2079             return SDL_SetError("Unexpected %u-bit PCM data format", (unsigned int)format->bitspersample);
  2080         }
  2081         break;
  2082     }
  2083 
  2084     spec->silence = SDL_SilenceValueForFormat(spec->format);
  2085 
  2086     /* Report the end position back to the cleanup code. */
  2087     if (RIFFlengthknown) {
  2088         chunk->position = RIFFend;
  2089     } else {
  2090         chunk->position = lastchunkpos;
  2091     }
  2092 
  2093     return 0;
  2094 }
  2095 
  2096 SDL_AudioSpec *
  2097 SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
  2098 {
  2099     int result;
  2100     WaveFile file;
  2101 
  2102     SDL_zero(file);
  2103 
  2104     /* Make sure we are passed a valid data source */
  2105     if (src == NULL) {
  2106         /* Error may come from RWops. */
  2107         return NULL;
  2108     } else if (spec == NULL) {
  2109         SDL_InvalidParamError("spec");
  2110         return NULL;
  2111     } else if (audio_buf == NULL) {
  2112         SDL_InvalidParamError("audio_buf");
  2113         return NULL;
  2114     } else if (audio_len == NULL) {
  2115         SDL_InvalidParamError("audio_len");
  2116         return NULL;
  2117     }
  2118 
  2119     *audio_buf = NULL;
  2120     *audio_len = 0;
  2121 
  2122     file.riffhint = WaveGetRiffSizeHint();
  2123     file.trunchint = WaveGetTruncationHint();
  2124     file.facthint = WaveGetFactChunkHint();
  2125 
  2126     result = WaveLoad(src, &file, spec, audio_buf, audio_len);
  2127     if (result < 0) {
  2128         SDL_free(*audio_buf);
  2129         spec = NULL;
  2130         audio_buf = NULL;
  2131         audio_len = 0;
  2132     }
  2133 
  2134     /* Cleanup */
  2135     if (freesrc) {
  2136         SDL_RWclose(src);
  2137     } else {
  2138         SDL_RWseek(src, file.chunk.position, RW_SEEK_SET);
  2139     }
  2140     WaveFreeChunkData(&file.chunk);
  2141     SDL_free(file.decoderdata);
  2142 
  2143     return spec;
  2144 }
  2145 
  2146 /* Since the WAV memory is allocated in the shared library, it must also
  2147    be freed here.  (Necessary under Win32, VC++)
  2148  */
  2149 void
  2150 SDL_FreeWAV(Uint8 *audio_buf)
  2151 {
  2152     SDL_free(audio_buf);
  2153 }
  2154 
  2155 /* vi: set ts=4 sw=4 expandtab: */