music_mad.c
author Sam Lantinga <slouken@libsdl.org>
Wed, 07 Nov 2018 07:47:50 -0800
changeset 924 9be60a9582a6
parent 891 c39a11fa853e
child 926 d6c9518fb5ee
permissions -rw-r--r--
The Debian maintainers aren't using these rules, so enable dynamic loading of shared libraries by default for the Steam Linux Runtime
     1 /*
     2   SDL_mixer:  An audio mixer library based on the SDL library
     3   Copyright (C) 1997-2018 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 
    22 #ifdef MUSIC_MP3_MAD
    23 
    24 #include "music_mad.h"
    25 
    26 #include "mad.h"
    27 
    28 
    29 /* NOTE: The dithering functions are GPL, which should be fine if your
    30          application is GPL (which would need to be true if you enabled
    31          libmad support in SDL_mixer). If you're using libmad under the
    32          commercial license, you need to disable this code.
    33 */
    34 /************************ dithering functions ***************************/
    35 
    36 #ifdef MUSIC_MP3_MAD_GPL_DITHERING
    37 
    38 /* All dithering done here is taken from the GPL'ed xmms-mad plugin. */
    39 
    40 /* Copyright (C) 1997 Makoto Matsumoto and Takuji Nishimura.       */
    41 /* Any feedback is very welcome. For any question, comments,       */
    42 /* see http://www.math.keio.ac.jp/matumoto/emt.html or email       */
    43 /* matumoto@math.keio.ac.jp                                        */
    44 
    45 /* Period parameters */
    46 #define MP3_DITH_N 624
    47 #define MP3_DITH_M 397
    48 #define MATRIX_A 0x9908b0df   /* constant vector a */
    49 #define UPPER_MASK 0x80000000 /* most significant w-r bits */
    50 #define LOWER_MASK 0x7fffffff /* least significant r bits */
    51 
    52 /* Tempering parameters */
    53 #define TEMPERING_MASK_B 0x9d2c5680
    54 #define TEMPERING_MASK_C 0xefc60000
    55 #define TEMPERING_SHIFT_U(y)  (y >> 11)
    56 #define TEMPERING_SHIFT_S(y)  (y << 7)
    57 #define TEMPERING_SHIFT_T(y)  (y << 15)
    58 #define TEMPERING_SHIFT_L(y)  (y >> 18)
    59 
    60 static unsigned long mt[MP3_DITH_N]; /* the array for the state vector  */
    61 static int mti=MP3_DITH_N+1; /* mti==MP3_DITH_N+1 means mt[MP3_DITH_N] is not initialized */
    62 
    63 /* initializing the array with a NONZERO seed */
    64 static void sgenrand(unsigned long seed)
    65 {
    66     /* setting initial seeds to mt[MP3_DITH_N] using         */
    67     /* the generator Line 25 of Table 1 in          */
    68     /* [KNUTH 1981, The Art of Computer Programming */
    69     /*    Vol. 2 (2nd Ed.), pp102]                  */
    70     mt[0]= seed & 0xffffffff;
    71     for (mti=1; mti<MP3_DITH_N; mti++)
    72         mt[mti] = (69069 * mt[mti-1]) & 0xffffffff;
    73 }
    74 
    75 static unsigned long genrand(void)
    76 {
    77     unsigned long y;
    78     static unsigned long mag01[2]={0x0, MATRIX_A};
    79     /* mag01[x] = x * MATRIX_A  for x=0,1 */
    80 
    81     if (mti >= MP3_DITH_N) { /* generate MP3_DITH_N words at one time */
    82         int kk;
    83 
    84         if (mti == MP3_DITH_N+1)   /* if sgenrand() has not been called, */
    85             sgenrand(4357); /* a default initial seed is used   */
    86 
    87         for (kk=0;kk<MP3_DITH_N-MP3_DITH_M;kk++) {
    88             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
    89             mt[kk] = mt[kk+MP3_DITH_M] ^ (y >> 1) ^ mag01[y & 0x1];
    90         }
    91         for (;kk<MP3_DITH_N-1;kk++) {
    92             y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
    93             mt[kk] = mt[kk+(MP3_DITH_M-MP3_DITH_N)] ^ (y >> 1) ^ mag01[y & 0x1];
    94         }
    95         y = (mt[MP3_DITH_N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
    96         mt[MP3_DITH_N-1] = mt[MP3_DITH_M-1] ^ (y >> 1) ^ mag01[y & 0x1];
    97 
    98         mti = 0;
    99     }
   100 
   101     y = mt[mti++];
   102     y ^= TEMPERING_SHIFT_U(y);
   103     y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
   104     y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
   105     y ^= TEMPERING_SHIFT_L(y);
   106 
   107     return y;
   108 }
   109 
   110 static long triangular_dither_noise(int nbits) {
   111     /* parameter nbits : the peak-to-peak amplitude desired (in bits)
   112      *  use with nbits set to    2 + nber of bits to be trimmed.
   113      * (because triangular is made from two uniformly distributed processes,
   114      * it starts at 2 bits peak-to-peak amplitude)
   115      * see The Theory of Dithered Quantization by Robert Alexander Wannamaker
   116      * for complete proof of why that's optimal
   117      */
   118     long v = (genrand()/2 - genrand()/2); /* in ]-2^31, 2^31[ */
   119     long P = 1 << (32 - nbits); /* the power of 2 */
   120     v /= P;
   121     /* now v in ]-2^(nbits-1), 2^(nbits-1) [ */
   122 
   123     return v;
   124 }
   125 
   126 #endif /* MUSIC_MP3_MAD_GPL_DITHERING */
   127 
   128 
   129 #define MAD_INPUT_BUFFER_SIZE   (5*8192)
   130 
   131 enum {
   132     MS_input_eof      = 0x0001,
   133     MS_input_error    = 0x0001,
   134     MS_decode_error   = 0x0002,
   135     MS_error_flags    = 0x000f,
   136 };
   137 
   138 typedef struct {
   139     int play_count;
   140     SDL_RWops *src;
   141     int freesrc;
   142     struct mad_stream stream;
   143     struct mad_frame frame;
   144     struct mad_synth synth;
   145     mad_timer_t next_frame_start;
   146     int volume;
   147     int status;
   148     SDL_AudioStream *audiostream;
   149 
   150     unsigned char input_buffer[MAD_INPUT_BUFFER_SIZE + MAD_BUFFER_GUARD];
   151 } MAD_Music;
   152 
   153 
   154 static int MAD_Seek(void *context, double position);
   155 
   156 static void *MAD_CreateFromRW(SDL_RWops *src, int freesrc)
   157 {
   158     MAD_Music *music;
   159 
   160     music = (MAD_Music *)SDL_calloc(1, sizeof(MAD_Music));
   161     if (!music) {
   162         SDL_OutOfMemory();
   163         return NULL;
   164     }
   165     music->src = src;
   166     music->volume = MIX_MAX_VOLUME;
   167 
   168     mad_stream_init(&music->stream);
   169     mad_frame_init(&music->frame);
   170     mad_synth_init(&music->synth);
   171     mad_timer_reset(&music->next_frame_start);
   172 
   173     music->freesrc = freesrc;
   174     return music;
   175 }
   176 
   177 static void MAD_SetVolume(void *context, int volume)
   178 {
   179     MAD_Music *music = (MAD_Music *)context;
   180     music->volume = volume;
   181 }
   182 
   183 /* Starts the playback. */
   184 static int MAD_Play(void *context, int play_count)
   185 {
   186     MAD_Music *music = (MAD_Music *)context;
   187     music->play_count = play_count;
   188     return MAD_Seek(music, 0.0);
   189 }
   190 
   191 
   192 /*************************** TAG HANDLING: ******************************/
   193 
   194 static SDL_INLINE SDL_bool is_id3v1(const Uint8 *data, size_t length)
   195 {
   196     /* http://id3.org/ID3v1 :  3 bytes "TAG" identifier and 125 bytes tag data */
   197     if (length < 3 || SDL_memcmp(data,"TAG",3) != 0) {
   198         return SDL_FALSE;
   199     }
   200     return SDL_TRUE;
   201 }
   202 static SDL_INLINE SDL_bool is_id3v2(const Uint8 *data, size_t length)
   203 {
   204     /* ID3v2 header is 10 bytes:  http://id3.org/id3v2.4.0-structure */
   205     /* bytes 0-2: "ID3" identifier */
   206     if (length < 10 || SDL_memcmp(data,"ID3",3) != 0) {
   207         return SDL_FALSE;
   208     }
   209     /* bytes 3-4: version num (major,revision), each byte always less than 0xff. */
   210     if (data[3] == 0xff || data[4] == 0xff) {
   211         return SDL_FALSE;
   212     }
   213     /* bytes 6-9 are the ID3v2 tag size: a 32 bit 'synchsafe' integer, i.e. the
   214      * highest bit 7 in each byte zeroed.  i.e.: 7 bit information in each byte ->
   215      * effectively a 28 bit value.  */
   216     if (data[6] >= 0x80 || data[7] >= 0x80 || data[8] >= 0x80 || data[9] >= 0x80) {
   217         return SDL_FALSE;
   218     }
   219     return SDL_TRUE;
   220 }
   221 static SDL_INLINE SDL_bool is_apetag(const Uint8 *data, size_t length)
   222 {
   223    /* http://wiki.hydrogenaud.io/index.php?title=APEv2_specification
   224     * APEv2 header is 32 bytes: bytes 0-7 ident, bytes 8-11 version,
   225     * bytes 12-17 size.  bytes 24-31 are reserved: must be all zeroes.
   226     * APEv1 has no header, so no luck.  */
   227     Uint32 v;
   228 
   229     if (length < 32 || SDL_memcmp(data,"APETAGEX",8) != 0) {
   230         return SDL_FALSE;
   231     }
   232     v = (data[11]<<24) | (data[10]<<16) | (data[9]<<8) | data[8]; /* version */
   233     if (v != 2000U) {
   234         return SDL_FALSE;
   235     }
   236     v = 0; /* reserved bits : */
   237     if (SDL_memcmp(&data[24],&v,4) != 0 || SDL_memcmp(&data[28],&v,4) != 0) {
   238         return SDL_FALSE;
   239     }
   240     return SDL_TRUE;
   241 }
   242 
   243 static size_t get_tagsize(const Uint8 *data, size_t length)
   244 {
   245     size_t size;
   246 
   247     if (is_id3v1(data, length)) {
   248         return 128; /* fixed length */
   249     }
   250     if (is_id3v2(data, length)) {
   251         /* size is a 'synchsafe' integer (see above) */
   252         size = (data[6]<<21) + (data[7]<<14) + (data[8]<<7) + data[9];
   253         size += 10; /* header size */
   254         /* ID3v2 header[5] is flags (bits 4-7 only, 0-3 are zero).
   255          * bit 4 set: footer is present (a copy of the header but
   256          * with "3DI" as ident.)  */
   257         if (data[5] & 0x10) {
   258             size += 10; /* footer size */
   259         }
   260         /* optional padding (always zeroes) */
   261         while (size < length && data[size] == 0) {
   262             ++size;
   263         }
   264         return size;
   265     }
   266     if (is_apetag(data, length)) {
   267         size = (data[15]<<24) | (data[14]<<16) | (data[13]<<8) | data[12];
   268         size += 32; /* header size */
   269         return size;
   270     }
   271     return 0;
   272 }
   273 
   274 static int consume_tag(struct mad_stream *stream)
   275 {
   276     /* FIXME: what if the buffer doesn't have the full tag ??? */
   277     size_t remaining = stream->bufend - stream->next_frame;
   278     size_t tagsize = get_tagsize(stream->this_frame, remaining);
   279     if (tagsize != 0) {
   280         mad_stream_skip(stream, tagsize);
   281         return 0;
   282     }
   283     return -1;
   284 }
   285 
   286 /* Reads the next frame from the file.
   287    Returns true on success or false on failure.
   288  */
   289 static SDL_bool read_next_frame(MAD_Music *music)
   290 {
   291     if (music->stream.buffer == NULL ||
   292         music->stream.error == MAD_ERROR_BUFLEN) {
   293         size_t read_size;
   294         size_t remaining;
   295         unsigned char *read_start;
   296 
   297         /* There might be some bytes in the buffer left over from last
   298            time.    If so, move them down and read more bytes following
   299            them. */
   300         if (music->stream.next_frame != NULL) {
   301             remaining = music->stream.bufend - music->stream.next_frame;
   302             memmove(music->input_buffer, music->stream.next_frame, remaining);
   303             read_start = music->input_buffer + remaining;
   304             read_size = MAD_INPUT_BUFFER_SIZE - remaining;
   305 
   306         } else {
   307             read_size = MAD_INPUT_BUFFER_SIZE;
   308             read_start = music->input_buffer;
   309             remaining = 0;
   310         }
   311 
   312         /* Now read additional bytes from the input file. */
   313         read_size = SDL_RWread(music->src, read_start, 1, read_size);
   314 
   315         if (read_size == 0) {
   316             if ((music->status & (MS_input_eof | MS_input_error)) == 0) {
   317                 /* FIXME: how to detect error? */
   318                 music->status |= MS_input_eof;
   319 
   320                 /* At the end of the file, we must stuff MAD_BUFFER_GUARD
   321                    number of 0 bytes. */
   322                 SDL_memset(read_start + read_size, 0, MAD_BUFFER_GUARD);
   323                 read_size += MAD_BUFFER_GUARD;
   324             }
   325         }
   326 
   327         /* Now feed those bytes into the libmad stream. */
   328         mad_stream_buffer(&music->stream, music->input_buffer,
   329                                             read_size + remaining);
   330         music->stream.error = MAD_ERROR_NONE;
   331     }
   332 
   333     /* Now ask libmad to extract a frame from the data we just put in
   334        its buffer. */
   335     if (mad_frame_decode(&music->frame, &music->stream)) {
   336         if (MAD_RECOVERABLE(music->stream.error)) {
   337             consume_tag(&music->stream); /* consume any ID3 tags */
   338             mad_stream_sync(&music->stream); /* to frame seek mode */
   339             return SDL_FALSE;
   340 
   341         } else if (music->stream.error == MAD_ERROR_BUFLEN) {
   342             return SDL_FALSE;
   343 
   344         } else {
   345             Mix_SetError("mad_frame_decode() failed, corrupt stream?");
   346             music->status |= MS_decode_error;
   347             return SDL_FALSE;
   348         }
   349     }
   350 
   351     mad_timer_add(&music->next_frame_start, music->frame.header.duration);
   352 
   353     return SDL_TRUE;
   354 }
   355 
   356 /* Scale a MAD sample to 16 bits for output. */
   357 static Sint16 scale(mad_fixed_t sample)
   358 {
   359     const int n_bits_to_loose = MAD_F_FRACBITS + 1 - 16;
   360 
   361     /* round */
   362     sample += (1L << (n_bits_to_loose - 1));
   363 
   364 #ifdef MUSIC_MP3_MAD_GPL_DITHERING
   365     sample += triangular_dither_noise(n_bits_to_loose + 1);
   366 #endif
   367 
   368     /* clip */
   369     if (sample >= MAD_F_ONE)
   370         sample = MAD_F_ONE - 1;
   371     else if (sample < -MAD_F_ONE)
   372         sample = -MAD_F_ONE;
   373 
   374     /* quantize */
   375     return (Sint16)(sample >> n_bits_to_loose);
   376 }
   377 
   378 /* Once the frame has been read, copies its samples into the output buffer. */
   379 static SDL_bool decode_frame(MAD_Music *music)
   380 {
   381     struct mad_pcm *pcm;
   382     unsigned int i, nchannels, nsamples;
   383     mad_fixed_t const *left_ch, *right_ch;
   384     Sint16 *buffer, *dst;
   385     int result;
   386 
   387     mad_synth_frame(&music->synth, &music->frame);
   388     pcm = &music->synth.pcm;
   389 
   390     if (!music->audiostream) {
   391         music->audiostream = SDL_NewAudioStream(AUDIO_S16, pcm->channels, pcm->samplerate, music_spec.format, music_spec.channels, music_spec.freq);
   392         if (!music->audiostream) {
   393             return SDL_FALSE;
   394         }
   395     }
   396 
   397     nchannels = pcm->channels;
   398     nsamples = pcm->length;
   399     left_ch = pcm->samples[0];
   400     right_ch = pcm->samples[1];
   401     buffer = SDL_stack_alloc(Sint16, nsamples*nchannels);
   402     if (!buffer) {
   403         SDL_OutOfMemory();
   404         return SDL_FALSE;
   405     }
   406 
   407     dst = buffer;
   408     if (nchannels == 1) {
   409         for (i = nsamples; i--;) {
   410             *dst++ = scale(*left_ch++);
   411         }
   412     } else {
   413         for (i = nsamples; i--;) {
   414             *dst++ = scale(*left_ch++);
   415             *dst++ = scale(*right_ch++);
   416         }
   417     }
   418 
   419     result = SDL_AudioStreamPut(music->audiostream, buffer, (nsamples * nchannels * sizeof(Sint16)));
   420     SDL_stack_free(buffer);
   421 
   422     if (result < 0) {
   423         return SDL_FALSE;
   424     }
   425     return SDL_TRUE;
   426 }
   427 
   428 static int MAD_GetSome(void *context, void *data, int bytes, SDL_bool *done)
   429 {
   430     MAD_Music *music = (MAD_Music *)context;
   431     int filled;
   432 
   433     if (music->audiostream) {
   434         filled = SDL_AudioStreamGet(music->audiostream, data, bytes);
   435         if (filled != 0) {
   436             return filled;
   437         }
   438     }
   439 
   440     if (!music->play_count) {
   441         /* All done */
   442         *done = SDL_TRUE;
   443         return 0;
   444     }
   445 
   446     if (read_next_frame(music)) {
   447         if (!decode_frame(music)) {
   448             return -1;
   449         }
   450     } else if (music->status & MS_input_eof) {
   451         int play_count = -1;
   452         if (music->play_count > 0) {
   453             play_count = (music->play_count - 1);
   454         }
   455         if (MAD_Play(music, play_count) < 0) {
   456             return -1;
   457         }
   458     } else if (music->status & MS_decode_error) {
   459         return -1;
   460     }
   461     return 0;
   462 }
   463 static int MAD_GetAudio(void *context, void *data, int bytes)
   464 {
   465     MAD_Music *music = (MAD_Music *)context;
   466     return music_pcm_getaudio(context, data, bytes, music->volume, MAD_GetSome);
   467 }
   468 
   469 static int MAD_Seek(void *context, double position)
   470 {
   471     MAD_Music *music = (MAD_Music *)context;
   472     mad_timer_t target;
   473     int int_part;
   474 
   475     int_part = (int)position;
   476     mad_timer_set(&target, int_part, (int)((position - int_part) * 1000000), 1000000);
   477 
   478     if (mad_timer_compare(music->next_frame_start, target) > 0) {
   479         /* In order to seek backwards in a VBR file, we have to rewind and
   480            start again from the beginning.    This isn't necessary if the
   481            file happens to be CBR, of course; in that case we could seek
   482            directly to the frame we want.    But I leave that little
   483            optimization for the future developer who discovers she really
   484            needs it. */
   485         mad_timer_reset(&music->next_frame_start);
   486         music->status &= ~MS_error_flags;
   487 
   488         SDL_RWseek(music->src, 0, RW_SEEK_SET);
   489     }
   490 
   491     /* Now we have to skip frames until we come to the right one.
   492        Again, only truly necessary if the file is VBR. */
   493     while (mad_timer_compare(music->next_frame_start, target) < 0) {
   494         if (!read_next_frame(music)) {
   495             if ((music->status & MS_error_flags) != 0) {
   496                 /* Couldn't read a frame; either an error condition or
   497                      end-of-file.    Stop. */
   498                 return Mix_SetError("Seek position out of range");
   499             }
   500         }
   501     }
   502 
   503     /* Here we are, at the beginning of the frame that contains the
   504        target time.    Ehh, I say that's close enough.    If we wanted to,
   505        we could get more precise by decoding the frame now and counting
   506        the appropriate number of samples out of it. */
   507     return 0;
   508 }
   509 
   510 static void MAD_Delete(void *context)
   511 {
   512     MAD_Music *music = (MAD_Music *)context;
   513 
   514     mad_stream_finish(&music->stream);
   515     mad_frame_finish(&music->frame);
   516     mad_synth_finish(&music->synth);
   517 
   518     if (music->audiostream) {
   519         SDL_FreeAudioStream(music->audiostream);
   520     }
   521     if (music->freesrc) {
   522         SDL_RWclose(music->src);
   523     }
   524     SDL_free(music);
   525 }
   526 
   527 Mix_MusicInterface Mix_MusicInterface_MAD =
   528 {
   529     "MAD",
   530     MIX_MUSIC_MAD,
   531     MUS_MP3,
   532     SDL_FALSE,
   533     SDL_FALSE,
   534 
   535     NULL,   /* Load */
   536     NULL,   /* Open */
   537     MAD_CreateFromRW,
   538     NULL,   /* CreateFromFile */
   539     MAD_SetVolume,
   540     MAD_Play,
   541     NULL,   /* IsPlaying */
   542     MAD_GetAudio,
   543     MAD_Seek,
   544     NULL,   /* Pause */
   545     NULL,   /* Resume */
   546     NULL,   /* Stop */
   547     MAD_Delete,
   548     NULL,   /* Close */
   549     NULL,   /* Unload */
   550 };
   551 
   552 #endif /* MUSIC_MP3_MAD */
   553 
   554 /* vi: set ts=4 sw=4 expandtab: */