Home | History | Annotate | Download | only in src
      1 
      2 /* -----------------------------------------------------------------------------------------------------------
      3 Software License for The Fraunhofer FDK AAC Codec Library for Android
      4 
      5  Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Frderung der angewandten Forschung e.V.
      6   All rights reserved.
      7 
      8  1.    INTRODUCTION
      9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
     10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
     11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
     12 
     13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
     14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
     15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
     16 of the MPEG specifications.
     17 
     18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
     19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
     20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
     21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
     22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
     23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
     24 
     25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
     26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
     27 applications information and documentation.
     28 
     29 2.    COPYRIGHT LICENSE
     30 
     31 Redistribution and use in source and binary forms, with or without modification, are permitted without
     32 payment of copyright license fees provided that you satisfy the following conditions:
     33 
     34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
     35 your modifications thereto in source code form.
     36 
     37 You must retain the complete text of this software license in the documentation and/or other materials
     38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
     39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
     40 modifications thereto to recipients of copies in binary form.
     41 
     42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
     43 prior written permission.
     44 
     45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
     46 software or your modifications thereto.
     47 
     48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
     49 and the date of any change. For modified versions of the FDK AAC Codec, the term
     50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
     51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
     52 
     53 3.    NO PATENT LICENSE
     54 
     55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
     56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
     57 respect to this software.
     58 
     59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
     60 by appropriate patent licenses.
     61 
     62 4.    DISCLAIMER
     63 
     64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
     65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
     66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
     67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
     68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
     69 or business interruption, however caused and on any theory of liability, whether in contract, strict
     70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
     71 advised of the possibility of such damage.
     72 
     73 5.    CONTACT INFORMATION
     74 
     75 Fraunhofer Institute for Integrated Circuits IIS
     76 Attention: Audio and Multimedia Departments - FDK AAC LL
     77 Am Wolfsmantel 33
     78 91058 Erlangen, Germany
     79 
     80 www.iis.fraunhofer.de/amm
     81 amm-info (at) iis.fraunhofer.de
     82 ----------------------------------------------------------------------------------------------------------- */
     83 
     84 /**************************  Fraunhofer IIS FDK SysLib  **********************
     85 
     86    Author(s):   Eric Allamanche
     87    Description: a rudimentary wav file interface
     88 
     89 ******************************************************************************/
     90 
     91 
     92 
     93 #include "wav_file.h"
     94 #include "genericStds.h"
     95 
     96 
     97 static INT_PCM ulaw2pcm (UCHAR ulawbyte);
     98 
     99 /*!
    100  *
    101  *  \brief Read header from a WAVEfile. Host endianess is handled accordingly.
    102  *  \wav->fp filepointer of type FILE*.
    103  *  \wavinfo SWavInfo struct where the decoded header info is stored into.
    104  *  \return 0 on success and non-zero on failure.
    105  *
    106  */
    107 INT WAV_InputOpen (HANDLE_WAV *pWav, const char *filename)
    108 {
    109     HANDLE_WAV wav = (HANDLE_WAV)FDKcalloc(1, sizeof(struct WAV));
    110     INT offset;
    111 
    112     if (wav == NULL) {
    113       FDKprintfErr("WAV_InputOpen(): Unable to allocate WAV struct.\n");
    114       goto error;
    115     }
    116 
    117     wav->fp = FDKfopen(filename, "rb");
    118     if (wav->fp == NULL) {
    119       FDKprintfErr("WAV_InputOpen(): Unable to open wav file. %s\n", filename);
    120       goto error;
    121     }
    122 
    123     /* read RIFF-chunk */
    124     if (FDKfread(&(wav->header.riffType), 1, 4, wav->fp) != 4) {
    125       FDKprintfErr("WAV_InputOpen(): couldn't read RIFF_ID\n");
    126       goto error;  /* bad error "couldn't read RIFF_ID" */
    127     }
    128     if (FDKstrncmp("RIFF", wav->header.riffType, 4)) {
    129       FDKprintfErr("WAV_InputOpen(): RIFF descriptor not found.\n") ;
    130       goto error;
    131     }
    132 
    133     /* Read RIFF size. Ignored. */
    134     FDKfread_EL(&(wav->header.riffSize), 4, 1, wav->fp);
    135 
    136     /* read WAVE-chunk */
    137     if (FDKfread(&wav->header.waveType, 1, 4, wav->fp) !=4) {
    138       FDKprintfErr("WAV_InputOpen(): couldn't read format\n");
    139       goto error;  /* bad error "couldn't read format" */
    140     }
    141     if (FDKstrncmp("WAVE", wav->header.waveType, 4)) {
    142       FDKprintfErr("WAV_InputOpen(): WAVE chunk ID not found.\n") ;
    143       goto error;
    144     }
    145 
    146     /* read format-chunk */
    147     if (FDKfread(&(wav->header.formatType), 1, 4, wav->fp) != 4) {
    148       FDKprintfErr("WAV_InputOpen(): couldn't read format_ID\n");
    149       goto error;  /* bad error "couldn't read format_ID" */
    150     }
    151     if (FDKstrncmp("fmt", wav->header.formatType, 3)) {
    152       FDKprintfErr("WAV_InputOpen(): fmt chunk format not found.\n") ;
    153      goto error;
    154     }
    155 
    156 
    157     FDKfread_EL(&wav->header.formatSize, 4, 1, wav->fp);   /* should be 16 for PCM-format (uncompressed) */
    158 
    159 
    160     /* read  info */
    161     FDKfread_EL(&(wav->header.compressionCode), 2, 1, wav->fp);
    162     FDKfread_EL(&(wav->header.numChannels), 2, 1, wav->fp);
    163     FDKfread_EL(&(wav->header.sampleRate), 4, 1, wav->fp);
    164     FDKfread_EL(&(wav->header.bytesPerSecond), 4, 1, wav->fp);
    165     FDKfread_EL(&(wav->header.blockAlign), 2, 1, wav->fp);
    166     FDKfread_EL(&(wav->header.bitsPerSample), 2, 1, wav->fp);
    167 
    168     offset = wav->header.formatSize - 16;
    169 
    170     /* Wave format extensible */
    171     if (wav->header.compressionCode == 0xFFFE) {
    172       static const UCHAR guidPCM[16] = {
    173           0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
    174           0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
    175       };
    176       USHORT extraFormatBytes, validBitsPerSample;
    177       UCHAR guid[16];
    178       INT i;
    179 
    180       /* read extra bytes */
    181       FDKfread_EL(&(extraFormatBytes), 2, 1, wav->fp);
    182       offset -= 2;
    183 
    184       if (extraFormatBytes >= 22) {
    185         FDKfread_EL(&(validBitsPerSample), 2, 1, wav->fp);
    186         FDKfread_EL(&(wav->channelMask), 4, 1, wav->fp);
    187         FDKfread_EL(&(guid), 16, 1, wav->fp);
    188 
    189         /* check for PCM GUID */
    190         for (i = 0; i < 16; i++) if (guid[i] != guidPCM[i]) break;
    191         if (i == 16) wav->header.compressionCode = 0x01;
    192 
    193         offset -= 22;
    194       }
    195     }
    196 
    197     /* Skip rest of fmt header if any. */
    198     for (;offset > 0; offset--) {
    199       FDKfread(&wav->header.formatSize, 1, 1, wav->fp);
    200     }
    201 
    202     do {
    203       /* Read data chunk ID */
    204       if (FDKfread(wav->header.dataType, 1, 4, wav->fp) != 4) {
    205         FDKprintfErr("WAV_InputOpen(): Unable to read data chunk ID.\n");
    206         FDKfree(wav);
    207         goto error;
    208       }
    209 
    210       /* Read chunk length. */
    211       FDKfread_EL(&offset, 4, 1, wav->fp);
    212 
    213       /* Check for data chunk signature. */
    214       if (FDKstrncmp("data", wav->header.dataType, 4) == 0) {
    215         wav->header.dataSize = offset;
    216         break;
    217       }
    218       /* Jump over non data chunk. */
    219       for (;offset > 0; offset--) {
    220         FDKfread(&(wav->header.dataSize), 1, 1, wav->fp);
    221       }
    222     } while (!FDKfeof(wav->fp));
    223 
    224     /* return success */
    225     *pWav = wav;
    226     return 0;
    227 
    228     /* Error path */
    229 error:
    230 
    231     if (wav) {
    232       if (wav->fp) {
    233         FDKfclose(wav->fp);
    234         wav->fp = NULL;
    235       }
    236       FDKfree(wav);
    237     }
    238 
    239     *pWav = NULL;
    240 
    241     return -1;
    242 }
    243 
    244 /*!
    245  *
    246  *  \brief Read samples from a WAVEfile. The samples are automatically reorder to the native
    247  *    host endianess and scaled to full scale of the INT_PCM type, from whatever bps the WAVEfile
    248  *    had specified in its haader data.
    249  *
    250  *  \wav HANDLE_WAV of the wav file.
    251  *  \buffer Pointer to store read data.
    252  *  \numSamples Desired number of samples to read.
    253  *  \nBits sample size in bits to be used for the buffer
    254  *
    255  *  \return Number of samples actually read.
    256  *
    257  */
    258 
    259 INT WAV_InputRead (HANDLE_WAV wav, void *buffer, UINT numSamples, int nBits)
    260 {
    261   UINT result = 0 ;
    262   UINT i;
    263   SCHAR *bptr = (SCHAR*)buffer;
    264   LONG  *lptr = (LONG*)buffer;
    265   SHORT *sptr = (SHORT*)buffer;
    266 
    267   switch (wav->header.compressionCode)
    268   {
    269     case 0x01:  /* PCM uncompressed */
    270       if (nBits == wav->header.bitsPerSample) {
    271         result = FDKfread_EL(buffer, wav->header.bitsPerSample >> 3, numSamples, wav->fp) ;
    272       } else {
    273         result = 0;
    274         for (i=0; i<numSamples; i++)
    275         {
    276           LONG tmp = 0;
    277           result += FDKfread_EL(&tmp, wav->header.bitsPerSample >> 3, 1, wav->fp) ;
    278 
    279           /* Move read bits to lower bits of LONG. */
    280           if ( !IS_LITTLE_ENDIAN() && wav->header.bitsPerSample != 24 && wav->header.bitsPerSample < 32) {
    281             tmp >>= (32-wav->header.bitsPerSample);
    282           }
    283 
    284           /* Full scale */
    285           if (wav->header.bitsPerSample > nBits)
    286             tmp >>= (wav->header.bitsPerSample-nBits);
    287           else
    288             tmp <<= (nBits-wav->header.bitsPerSample);
    289 
    290           if (nBits == 8)
    291             *bptr++ = (SCHAR) tmp;
    292           if (nBits == 16)
    293             *sptr++ = (SHORT) tmp;
    294           if (nBits == 32)
    295             *lptr++ = (LONG) tmp;
    296         }
    297       }
    298       break;
    299 
    300     case 0x07:  /* u-Law compression */
    301       for (i=0; i<numSamples; i++) {
    302         result += FDKfread(&(bptr[i<<1]), 1, 1, wav->fp) ;
    303         sptr[i] = ulaw2pcm(bptr[i<<1]) ;
    304       }
    305       break ;
    306 
    307     default:
    308       FDKprintf("WAV_InputRead(): unsupported data-compression!!") ;
    309       break ;
    310   }
    311   return result ;
    312 }
    313 
    314 void WAV_InputClose(HANDLE_WAV *pWav)
    315 {
    316   HANDLE_WAV wav = *pWav;
    317 
    318   if (wav != NULL) {
    319     if (wav->fp != NULL) {
    320        FDKfclose(wav->fp);
    321        wav->fp = NULL;
    322     }
    323     if (wav) {
    324        FDKfree(wav);
    325     }
    326   }
    327   *pWav = NULL;
    328 }
    329 
    330 /* conversion of u-law to linear coding */
    331 static INT_PCM ulaw2pcm (UCHAR ulawbyte)
    332 {
    333   static const INT exp_lut[8] = { 0, 132, 396, 924, 1980, 4092, 8316, 16764 } ;
    334   INT sign, exponent, mantissa, sample ;
    335 
    336   ulawbyte = (UCHAR)~ulawbyte ;
    337   sign = (ulawbyte & 0x80) ;
    338   exponent = (ulawbyte >> 4) & 0x07 ;
    339   mantissa = ulawbyte & 0x0F ;
    340 
    341   sample = exp_lut[exponent] + (mantissa << (exponent + 3)) ;
    342   if (sign != 0)
    343     sample = -sample ;
    344 
    345   return (INT_PCM)sample ;
    346 }
    347 
    348 /************** Writer ***********************/
    349 
    350 static UINT LittleEndian32(UINT v)
    351 {
    352     if (IS_LITTLE_ENDIAN())
    353         return v ;
    354     else
    355         return (v & 0x000000FF) << 24 | (v & 0x0000FF00) <<  8 | (v & 0x00FF0000) >>  8 | (v & 0xFF000000) >> 24;
    356 }
    357 
    358 static SHORT LittleEndian16(SHORT v)
    359 {
    360     if (IS_LITTLE_ENDIAN())
    361         return v;
    362     else
    363         return (SHORT)(((v << 8) & 0xFF00) | ((v >> 8) & 0x00FF));
    364 }
    365 
    366 static USHORT Unpack(USHORT v)
    367 {
    368     if (IS_LITTLE_ENDIAN())
    369       return v;
    370     else
    371       return (SHORT)(((v << 8) & 0xFF00) | ((v >> 8) & 0x00FF));
    372 }
    373 
    374 /**
    375  * WAV_OutputOpen
    376  * \brief Open WAV output/writer handle
    377  * \param pWav pointer to WAV handle to be returned
    378  * \param sampleRate desired samplerate of the resulting WAV file
    379  * \param numChannels desired number of audio channels of the resulting WAV file
    380  * \param bitsPerSample desired number of bits per audio sample of the resulting WAV file
    381  *
    382  * \return value:   0: ok
    383  *                 -1: error
    384  */
    385 INT WAV_OutputOpen(HANDLE_WAV *pWav, const char *outputFilename, INT sampleRate, INT numChannels, INT bitsPerSample)
    386 {
    387   HANDLE_WAV wav = (HANDLE_WAV)FDKcalloc(1, sizeof(struct WAV));
    388   UINT size = 0;
    389 
    390   if (wav == NULL) {
    391     FDKprintfErr("WAV_OutputOpen(): Unable to allocate WAV struct.\n");
    392     goto bail;
    393   }
    394 
    395   if (bitsPerSample != 16 && bitsPerSample != 24 && bitsPerSample != 32)
    396   {
    397       FDKprintfErr("WAV_OutputOpen(): Invalid argument (bitsPerSample).\n");
    398       goto bail;
    399   }
    400 
    401   wav->fp = FDKfopen(outputFilename, "wb");
    402   if (wav->fp == NULL)
    403   {
    404       FDKprintfErr("WAV_OutputOpen(): unable to create file %s\n", outputFilename);
    405       goto bail;
    406   }
    407 
    408   FDKstrcpy(wav->header.riffType, "RIFF");
    409   wav->header.riffSize = LittleEndian32(0x7fffffff);  /* in case fseek() doesn't work later in WAV_OutputClose() */
    410   FDKstrcpy(wav->header.waveType, "WAVE");
    411 
    412   FDKstrcpy(wav->header.formatType, "fmt ");
    413   wav->header.formatSize = LittleEndian32(16);
    414 
    415   wav->header.compressionCode = LittleEndian16(0x01);
    416   wav->header.bitsPerSample   = LittleEndian16((SHORT)bitsPerSample);
    417   wav->header.numChannels     = LittleEndian16((SHORT)numChannels);
    418   wav->header.blockAlign      = LittleEndian16((SHORT)(numChannels * (bitsPerSample >> 3)));
    419   wav->header.sampleRate      = LittleEndian32(sampleRate);
    420   wav->header.bytesPerSecond  = LittleEndian32(sampleRate * wav->header.blockAlign);
    421   FDKstrcpy(wav->header.dataType, "data");
    422   wav->header.dataSize        = LittleEndian32(0x7fffffff - 36);
    423 
    424 
    425   size = sizeof(WAV_HEADER);
    426   if (FDKfwrite(&wav->header, 1, size, wav->fp) != size)
    427   {
    428       FDKprintfErr("WAV_OutputOpen(): error writing to output file %s\n", outputFilename);
    429       goto bail;
    430   }
    431 
    432 
    433   wav->header.dataSize = wav->header.riffSize = 0;
    434 
    435   *pWav = wav;
    436 
    437   return 0;
    438 
    439 bail:
    440   if (wav) {
    441     if (wav->fp) {
    442       FDKfclose(wav->fp);
    443     }
    444     FDKfree(wav);
    445   }
    446 
    447   pWav = NULL;
    448 
    449   return -1;
    450 }
    451 
    452 
    453 /**
    454  * WAV_OutputWrite
    455  * \brief Write data to WAV file asociated to WAV handle
    456  *
    457  * \param wav handle of wave file
    458  * \param sampleBuffer pointer to audio samples, right justified integer values
    459  * \param nBufBits size in bits of each audio sample in sampleBuffer
    460  * \param nSigBits amount of significant bits of each nBufBits in sampleBuffer
    461  *
    462  * \return value:    0: ok
    463  *                  -1: error
    464  */
    465 INT WAV_OutputWrite(HANDLE_WAV wav, void *sampleBuffer, UINT numberOfSamples, int nBufBits, int nSigBits)
    466 {
    467     SCHAR *bptr = (SCHAR*)sampleBuffer;
    468     SHORT *sptr = (SHORT*)sampleBuffer;
    469     LONG  *lptr = (LONG*)sampleBuffer;
    470     LONG tmp;
    471 
    472     int bps = Unpack(wav->header.bitsPerSample);
    473     UINT i;
    474 
    475     /* Pack samples if required */
    476     if (bps == nBufBits && bps == nSigBits) {
    477       if (FDKfwrite_EL(sampleBuffer, (bps>>3), numberOfSamples, wav->fp) != numberOfSamples)
    478       {
    479         FDKprintfErr("WAV_OutputWrite(): error: unable to write to file %d\n", wav->fp);
    480         return -1;
    481       }
    482     } else  {
    483       for (i=0; i<numberOfSamples; i++)
    484       {
    485         int result;
    486         int shift;
    487 
    488         switch (nBufBits) {
    489           case 8:  tmp = *bptr++; break;
    490           case 16: tmp = *sptr++; break;
    491           case 32: tmp = *lptr++; break;
    492           default: return -1;
    493         }
    494         /* Adapt sample size */
    495         shift = (nBufBits-nSigBits)-(32-bps);
    496 
    497         /* Correct alignment difference between 32 bit data buffer "tmp" and 24 bits to be written. */
    498         if ( !IS_LITTLE_ENDIAN() && bps == 24) {
    499           shift += 8;
    500         }
    501 
    502         if (shift < 0)
    503           tmp >>= -shift;
    504         else
    505           tmp <<= shift;
    506 
    507         /* Write sample */
    508         result=FDKfwrite_EL(&tmp, bps>>3, 1, wav->fp);
    509         if (result <= 0) {
    510           FDKprintfErr("WAV_OutputWrite(): error: unable to write to file %d\n", wav->fp);
    511           return -1;
    512         }
    513       }
    514     }
    515 
    516     wav->header.dataSize += (numberOfSamples * (bps>>3));
    517     return 0;
    518 }
    519 
    520 
    521 /**
    522  * WAV_OutputClose
    523  * \brief Close WAV Output handle
    524  * \param pWav pointer to WAV handle. *pWav is set to NULL.
    525  */
    526 void WAV_OutputClose(HANDLE_WAV *pWav)
    527 {
    528   HANDLE_WAV wav = *pWav;
    529   UINT size = 0;
    530 
    531   if ( wav == NULL ) {
    532       return;
    533   }
    534 
    535   wav->header.dataSize = LittleEndian32(wav->header.dataSize);
    536   wav->header.riffSize = LittleEndian32(wav->header.dataSize + 36);
    537 
    538   if (wav->fp != NULL)
    539   {
    540     if (FDKfseek(wav->fp, 0, FDKSEEK_SET)) {
    541        FDKprintf("WAV_OutputClose(): fseek() failed.\n");
    542     }
    543 
    544   size = sizeof(WAV_HEADER);
    545     if (FDKfwrite(&wav->header.riffType, 1, size, wav->fp) != size)
    546     {
    547         FDKprintfErr("WAV_OutputClose(): unable to write header\n");
    548 	}
    549 
    550     if (FDKfclose(wav->fp))
    551     {
    552         FDKprintfErr("WAV_OutputClose(): unable to close wav file\n");
    553     }
    554     wav->fp = NULL;
    555   }
    556 
    557   FDKfree(wav);
    558   *pWav = NULL;
    559 }
    560 
    561