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 /*****************************  MPEG-4 AAC Encoder  **************************
     85 
     86    Author(s):
     87    Description:
     88 
     89 ******************************************************************************/
     90 
     91 #include "tpenc_latm.h"
     92 
     93 
     94 #include "genericStds.h"
     95 
     96 static const short celpFrameLengthTable[64] = {
     97  154, 170, 186, 147, 156, 165, 114, 120,
     98  186, 126, 132, 138, 142, 146, 154, 166,
     99  174, 182, 190, 198, 206, 210, 214, 110,
    100  114, 118, 120, 122, 218, 230, 242, 254,
    101  266, 278, 286, 294, 318, 342, 358, 374,
    102  390, 406, 422, 136, 142, 148, 154, 160,
    103  166, 170, 174, 186, 198, 206, 214, 222,
    104  230, 238, 216, 160, 280, 338, 0,   0
    105 };
    106 
    107 /*******
    108  write value to transport stream
    109  first two bits define the size of the value itself
    110  then the value itself, with a size of 0-3 bytes
    111 *******/
    112 static
    113 UINT transportEnc_LatmWriteValue(HANDLE_FDK_BITSTREAM hBs, int value)
    114 {
    115   UCHAR valueBytes = 4;
    116   unsigned int bitsWritten = 0;
    117   int i;
    118 
    119   if ( value < (1<<8) ) {
    120     valueBytes = 1;
    121   } else if ( value < (1<<16) ) {
    122     valueBytes = 2;
    123   } else if ( value < (1<<24) ) {
    124     valueBytes = 3;
    125   } else {
    126     valueBytes = 4;
    127   }
    128 
    129   FDKwriteBits(hBs, valueBytes-1, 2 ); /* size of value in Bytes */
    130   for (i=0; i<valueBytes; i++) {
    131     /* write most significant Byte first */
    132     FDKwriteBits(hBs, (UCHAR)(value>>((valueBytes-1-i)<<3)), 8);
    133   }
    134 
    135   bitsWritten = (valueBytes<<3)+2;
    136 
    137   return bitsWritten;
    138 }
    139 
    140 static
    141 UINT transportEnc_LatmCountFixBitDemandHeader ( HANDLE_LATM_STREAM hAss )
    142 {
    143   int bitDemand = 0;
    144   int insertSetupData = 0 ;
    145 
    146   /* only if start of new latm frame */
    147   if (hAss->subFrameCnt==0)
    148   {
    149     /* AudioSyncStream */
    150 
    151     if (hAss->tt == TT_MP4_LOAS) {
    152       bitDemand += 11 ;             /* syncword */
    153       bitDemand += 13 ;             /* audioMuxLengthBytes */
    154     }
    155 
    156     /* AudioMuxElement*/
    157 
    158     /* AudioMuxElement::Stream Mux Config */
    159     if (hAss->muxConfigPeriod > 0) {
    160       insertSetupData = (hAss->latmFrameCounter == 0);
    161     } else {
    162       insertSetupData = 0;
    163     }
    164 
    165     if (hAss->tt != TT_MP4_LATM_MCP0) {
    166       /* AudioMuxElement::useSameStreamMux Flag */
    167       bitDemand+=1;
    168 
    169       if( insertSetupData ) {
    170         bitDemand += hAss->streamMuxConfigBits;
    171       }
    172     }
    173 
    174     /* AudioMuxElement::otherDataBits */
    175     bitDemand += 8*hAss->otherDataLenBytes;
    176 
    177     /* AudioMuxElement::ByteAlign */
    178     if ( bitDemand % 8 ) {
    179        hAss->fillBits = 8 - (bitDemand % 8);
    180        bitDemand += hAss->fillBits ;
    181     } else {
    182       hAss->fillBits = 0;
    183     }
    184   }
    185 
    186   return bitDemand ;
    187 }
    188 
    189 static
    190 UINT transportEnc_LatmCountVarBitDemandHeader ( HANDLE_LATM_STREAM hAss , unsigned int streamDataLength )
    191 {
    192   int bitDemand = 0;
    193   int  prog, layer;
    194 
    195   /* Payload Length Info*/
    196   if( hAss->allStreamsSameTimeFraming ) {
    197     for( prog=0; prog<hAss->noProgram; prog++ ) {
    198       for( layer=0; layer<LATM_MAX_LAYERS; layer++ ) {
    199         LATM_LAYER_INFO *p_linfo = &(hAss->m_linfo[prog][layer]);
    200 
    201         if( p_linfo->streamID >= 0 ) {
    202           switch( p_linfo->frameLengthType ) {
    203           case 0:
    204             if ( streamDataLength > 0 ) {
    205               streamDataLength -= bitDemand ;
    206               while( streamDataLength >= (255<<3) ) {
    207                 bitDemand+=8;
    208                 streamDataLength -= (255<<3);
    209               }
    210               bitDemand += 8;
    211             }
    212             break;
    213 
    214           case 1:
    215           case 4:
    216           case 6:
    217             bitDemand += 2;
    218             break;
    219 
    220           default:
    221             return 0;
    222           }
    223         }
    224       }
    225     }
    226   } else {
    227     /* there are many possibilities to use this mechanism.  */
    228     switch( hAss->varMode ) {
    229     case LATMVAR_SIMPLE_SEQUENCE: {
    230       /* Use the sequence generated by the encoder */
    231       //int streamCntPosition = transportEnc_SetWritePointer( hAss->hAssemble, 0 );
    232       //int streamCntPosition = FDKgetValidBits( hAss->hAssemble );
    233       bitDemand+=4;
    234 
    235       hAss->varStreamCnt = 0;
    236       for( prog=0; prog<hAss->noProgram; prog++ ) {
    237         for( layer=0; layer<LATM_MAX_LAYERS; layer++ ) {
    238           LATM_LAYER_INFO *p_linfo = &(hAss->m_linfo[prog][layer]);
    239 
    240           if( p_linfo->streamID >= 0 ) {
    241 
    242             bitDemand+=4; /* streamID */
    243             switch( p_linfo->frameLengthType ) {
    244             case 0:
    245               streamDataLength -= bitDemand ;
    246               while( streamDataLength >= (255<<3) ) {
    247                 bitDemand+=8;
    248                 streamDataLength -= (255<<3);
    249               }
    250 
    251               bitDemand += 8;
    252               break;
    253               /*bitDemand += 1; endFlag
    254               break;*/
    255 
    256             case 1:
    257             case 4:
    258             case 6:
    259 
    260               break;
    261 
    262             default:
    263               return  0;
    264             }
    265             hAss->varStreamCnt++;
    266           }
    267         }
    268       }
    269       bitDemand+=4;
    270       //transportEnc_UpdateBitstreamField( hAss->hAssemble, streamCntPosition, hAss->varStreamCnt-1, 4 );
    271       //UINT pos = streamCntPosition-FDKgetValidBits(hAss->hAssemble);
    272       //FDKpushBack( hAss->hAssemble,  pos);
    273       //FDKwriteBits( hAss->hAssemble, hAss->varStreamCnt-1, 4);
    274       //FDKpushFor( hAss->hAssemble, pos-4);
    275     }
    276     break;
    277 
    278     default:
    279       return  0;
    280     }
    281   }
    282 
    283   return bitDemand ;
    284 }
    285 
    286 TRANSPORTENC_ERROR
    287 CreateStreamMuxConfig(
    288                       HANDLE_LATM_STREAM hAss,
    289                       HANDLE_FDK_BITSTREAM hBs,
    290                       int bufferFullness,
    291                       CSTpCallBacks *cb
    292                      )
    293 {
    294   INT streamIDcnt, tmp;
    295   int layer, prog;
    296 
    297   USHORT coreFrameOffset=0;
    298 
    299   hAss->audioMuxVersionA    = 0; /* for future extensions */
    300   hAss->streamMuxConfigBits = 0;
    301 
    302   FDKwriteBits( hBs, hAss->audioMuxVersion, 1 );                   /* audioMuxVersion */
    303   hAss->streamMuxConfigBits += 1;
    304 
    305   if ( hAss->audioMuxVersion == 1 ) {
    306     FDKwriteBits( hBs, hAss->audioMuxVersionA, 1 );                /* audioMuxVersionA */
    307     hAss->streamMuxConfigBits+=1;
    308   }
    309 
    310   if ( hAss->audioMuxVersionA == 0 )
    311   {
    312     if ( hAss->audioMuxVersion == 1 ) {
    313       hAss->streamMuxConfigBits+= transportEnc_LatmWriteValue( hBs, hAss->taraBufferFullness );/* taraBufferFullness */
    314     }
    315     FDKwriteBits( hBs, hAss->allStreamsSameTimeFraming ? 1:0, 1 ); /* allStreamsSameTimeFraming */
    316     FDKwriteBits( hBs, hAss->noSubframes-1, 6 );                   /* Number of Subframes */
    317     FDKwriteBits( hBs, hAss->noProgram-1, 4 );                     /* Number of Programs */
    318 
    319     hAss->streamMuxConfigBits+=11;
    320 
    321     streamIDcnt = 0;
    322     for( prog=0; prog<hAss->noProgram; prog++ ) {
    323       int transLayer = 0;
    324 
    325       FDKwriteBits( hBs, hAss->noLayer[prog]-1, 3 );
    326       hAss->streamMuxConfigBits+=3;
    327 
    328       for( layer=0; layer<LATM_MAX_LAYERS; layer++ ) {
    329         LATM_LAYER_INFO   *p_linfo = &(hAss->m_linfo[prog][layer]);
    330         CODER_CONFIG *p_lci   = hAss->config[prog][layer];
    331 
    332         p_linfo->streamID = -1;
    333 
    334         if( hAss->config[prog][layer] != NULL ) {
    335           int useSameConfig = 0;
    336 
    337           if( transLayer > 0 ) {
    338             FDKwriteBits( hBs, useSameConfig ? 1 : 0, 1 );
    339             hAss->streamMuxConfigBits+=1;
    340           }
    341           if( (useSameConfig == 0) || (transLayer==0) ) {
    342             UINT bits;
    343 
    344             if ( hAss->audioMuxVersion == 1 ) {
    345               FDKpushFor(hBs, 2); /* align to ASC, even if we do not know the length of the "ascLen" field yet */
    346             }
    347 
    348             bits = FDKgetValidBits( hBs );
    349 
    350             transportEnc_writeASC(
    351                     hBs,
    352                     hAss->config[prog][layer],
    353                     cb
    354                     );
    355 
    356             bits = FDKgetValidBits( hBs ) - bits;
    357 
    358             if ( hAss->audioMuxVersion == 1 ) {
    359               FDKpushBack(hBs, bits+2);
    360               hAss->streamMuxConfigBits += transportEnc_LatmWriteValue( hBs, bits );
    361               transportEnc_writeASC(
    362                       hBs,
    363                       hAss->config[prog][layer],
    364                       cb
    365                       );
    366             }
    367 
    368             hAss->streamMuxConfigBits += bits; /* add asc length to smc summary */
    369           }
    370           transLayer++;
    371 
    372           if( !hAss->allStreamsSameTimeFraming ) {
    373             if( streamIDcnt >= LATM_MAX_STREAM_ID )
    374               return TRANSPORTENC_INVALID_CONFIG;
    375           }
    376           p_linfo->streamID = streamIDcnt++;
    377 
    378           switch( p_lci->aot ) {
    379           case AOT_AAC_MAIN      :
    380           case AOT_AAC_LC        :
    381           case AOT_AAC_SSR       :
    382           case AOT_AAC_LTP       :
    383           case AOT_AAC_SCAL      :
    384           case AOT_ER_AAC_LD     :
    385           case AOT_ER_AAC_ELD    :
    386           case AOT_USAC:
    387           case AOT_RSVD50:
    388             p_linfo->frameLengthType = 0;
    389 
    390             FDKwriteBits( hBs, p_linfo->frameLengthType, 3 );                        /* frameLengthType */
    391             FDKwriteBits( hBs, bufferFullness, 8 );                           /* bufferFullness */
    392             hAss->streamMuxConfigBits+=11;
    393 
    394             if ( !hAss->allStreamsSameTimeFraming ) {
    395               CODER_CONFIG *p_lci_prev = hAss->config[prog][layer-1];
    396               if ( ((p_lci->aot == AOT_AAC_SCAL) || (p_lci->aot == AOT_ER_AAC_SCAL)) &&
    397                    ((p_lci_prev->aot == AOT_CELP) || (p_lci_prev->aot == AOT_ER_CELP)) ) {
    398                 FDKwriteBits( hBs, coreFrameOffset, 6 );                      /* coreFrameOffset */
    399                 hAss->streamMuxConfigBits+=6;
    400               }
    401             }
    402             break;
    403 
    404           case AOT_TWIN_VQ:
    405             p_linfo->frameLengthType = 1;
    406             tmp = ( (p_lci->bitsFrame+7) >> 3 ) - 20;                            /* transmission frame length in bytes */
    407             if( (tmp < 0) ) {
    408               return TRANSPORTENC_INVALID_TRANSMISSION_FRAME_LENGTH;
    409             }
    410             FDKwriteBits( hBs, p_linfo->frameLengthType, 3 );          /* frameLengthType */
    411             FDKwriteBits( hBs, tmp, 9 );
    412             hAss->streamMuxConfigBits+=12;
    413 
    414             p_linfo->frameLengthBits = (tmp+20) << 3;
    415             break;
    416 
    417           case AOT_CELP:
    418             p_linfo->frameLengthType = 4;
    419             FDKwriteBits( hBs, p_linfo->frameLengthType, 3 );          /* frameLengthType */
    420             hAss->streamMuxConfigBits+=3;
    421             {
    422               int i;
    423               for( i=0; i<62; i++ ) {
    424                 if( celpFrameLengthTable[i] == p_lci->bitsFrame )
    425                   break;
    426               }
    427               if( i>=62 ) {
    428                 return TRANSPORTENC_INVALID_CELP_FRAME_LENGTH;
    429               }
    430 
    431               FDKwriteBits( hBs, i, 6 );                                /* CELPframeLengthTabelIndex */
    432               hAss->streamMuxConfigBits+=6;
    433             }
    434             p_linfo->frameLengthBits = p_lci->bitsFrame;
    435             break;
    436 
    437           case AOT_HVXC:
    438             p_linfo->frameLengthType = 6;
    439             FDKwriteBits( hBs, p_linfo->frameLengthType, 3 );          /* frameLengthType */
    440             hAss->streamMuxConfigBits+=3;
    441             {
    442               int i;
    443 
    444               if( p_lci->bitsFrame == 40 ) {
    445                 i = 0;
    446               } else if( p_lci->bitsFrame == 80 ) {
    447                 i = 1;
    448               } else {
    449                 return TRANSPORTENC_INVALID_FRAME_BITS;
    450               }
    451               FDKwriteBits( hBs, i, 1 );                                /* HVXCframeLengthTableIndex */
    452               hAss->streamMuxConfigBits+=1;
    453             }
    454             p_linfo->frameLengthBits = p_lci->bitsFrame;
    455             break;
    456 
    457           case AOT_NULL_OBJECT:
    458           default:
    459             return TRANSPORTENC_INVALID_AOT;
    460           }
    461         }
    462       }
    463     }
    464 
    465     FDKwriteBits( hBs, (hAss->otherDataLenBytes>0) ? 1:0, 1 );      /* otherDataPresent */
    466     hAss->streamMuxConfigBits+=1;
    467 
    468     if( hAss->otherDataLenBytes > 0 ) {
    469 
    470       INT otherDataLenTmp = hAss->otherDataLenBytes;
    471       INT escCnt = 0;
    472       INT otherDataLenEsc = 1;
    473 
    474       while(otherDataLenTmp) {
    475         otherDataLenTmp >>= 8;
    476         escCnt ++;
    477       }
    478 
    479       do {
    480         otherDataLenTmp = (hAss->otherDataLenBytes>>(escCnt*8)) & 0xFF;
    481         escCnt--;
    482         otherDataLenEsc = escCnt>0;
    483 
    484         FDKwriteBits( hBs, otherDataLenEsc, 1 );
    485         FDKwriteBits( hBs, otherDataLenTmp, 8 );
    486         hAss->streamMuxConfigBits+=9;
    487       } while(otherDataLenEsc);
    488     }
    489 
    490     {
    491       USHORT crcCheckPresent=0;
    492       USHORT crcCheckSum=0;
    493 
    494       FDKwriteBits( hBs, crcCheckPresent, 1 );               /* crcCheckPresent */
    495       hAss->streamMuxConfigBits+=1;
    496       if ( crcCheckPresent ){
    497         FDKwriteBits( hBs, crcCheckSum, 8 );                 /* crcCheckSum */
    498         hAss->streamMuxConfigBits+=8;
    499       }
    500     }
    501 
    502   } else {  /* if ( audioMuxVersionA == 0 ) */
    503 
    504     /* for future extensions */
    505 
    506   }
    507 
    508   return TRANSPORTENC_OK;
    509 }
    510 
    511 
    512 static TRANSPORTENC_ERROR
    513 WriteAuPayloadLengthInfo( HANDLE_FDK_BITSTREAM hBitStream, int AuLengthBits )
    514 {
    515   int restBytes;
    516 
    517   if( AuLengthBits % 8 )
    518     return TRANSPORTENC_INVALID_AU_LENGTH;
    519 
    520   while( AuLengthBits >= 255*8 ) {
    521     FDKwriteBits( hBitStream, 255, 8 );  /* 255 shows incomplete AU */
    522     AuLengthBits -= (255*8);
    523   }
    524 
    525   restBytes = (AuLengthBits) >> 3;
    526   FDKwriteBits( hBitStream, restBytes, 8 );
    527 
    528   return TRANSPORTENC_OK;
    529 }
    530 
    531 static
    532 TRANSPORTENC_ERROR transportEnc_LatmSetNrOfSubframes( HANDLE_LATM_STREAM hAss,
    533                                                       INT noSubframes_next)    /* nr of access units / payloads within a latm frame */
    534 {
    535   /* sanity chk */
    536   if (noSubframes_next < 1 || noSubframes_next > MAX_NR_OF_SUBFRAMES) {
    537     return TRANSPORTENC_LATM_INVALID_NR_OF_SUBFRAMES;
    538   }
    539 
    540   hAss->noSubframes_next = noSubframes_next;
    541 
    542   /* if at start then we can take over the value immediately, otherwise we have to wait for the next SMC */
    543   if ( (hAss->subFrameCnt == 0) && (hAss->latmFrameCounter == 0) ) {
    544     hAss->noSubframes = noSubframes_next;
    545   }
    546 
    547   return TRANSPORTENC_OK;
    548 }
    549 
    550 static
    551 int allStreamsSameTimeFraming( HANDLE_LATM_STREAM hAss, UCHAR noProgram, UCHAR noLayer[] /* return */ )
    552 {
    553   int prog, layer;
    554 
    555   signed int lastNoSamples   = -1;
    556   signed int minFrameSamples = FDK_INT_MAX;
    557   signed int maxFrameSamples = 0;
    558 
    559   signed int highestSamplingRate = -1;
    560 
    561   for( prog=0; prog<noProgram; prog++ ) {
    562     noLayer[prog] = 0;
    563 
    564     for( layer=0; layer<LATM_MAX_LAYERS; layer++ )
    565     {
    566       if( hAss->config[prog][layer] != NULL )
    567       {
    568         INT hsfSamplesFrame;
    569 
    570         noLayer[prog]++;
    571 
    572         if( highestSamplingRate < 0 )
    573           highestSamplingRate = hAss->config[prog][layer]->samplingRate;
    574 
    575         hsfSamplesFrame = hAss->config[prog][layer]->samplesPerFrame  * highestSamplingRate / hAss->config[prog][layer]->samplingRate;
    576 
    577         if( hsfSamplesFrame <= minFrameSamples ) minFrameSamples = hsfSamplesFrame;
    578         if( hsfSamplesFrame >= maxFrameSamples ) maxFrameSamples = hsfSamplesFrame;
    579 
    580         if( lastNoSamples == -1 ) {
    581           lastNoSamples                             = hsfSamplesFrame;
    582         } else {
    583           if( hsfSamplesFrame != lastNoSamples ) {
    584             return 0;
    585           }
    586         }
    587       }
    588     }
    589   }
    590 
    591   return 1;
    592 }
    593 
    594 /**
    595  * Initialize LATM/LOAS Stream and add layer 0 at program 0.
    596  */
    597 static
    598 TRANSPORTENC_ERROR transportEnc_InitLatmStream( HANDLE_LATM_STREAM hAss,
    599                                                 int                fractDelayPresent,
    600                                                 signed int         muxConfigPeriod, /* insert setup data every muxConfigPeriod frames */
    601                                                 UINT               audioMuxVersion,
    602                                                 TRANSPORT_TYPE     tt
    603                                               )
    604 {
    605   TRANSPORTENC_ERROR ErrorStatus = TRANSPORTENC_OK;
    606 
    607   if (hAss == NULL)
    608     return TRANSPORTENC_INVALID_PARAMETER;
    609 
    610   hAss->tt = tt;
    611 
    612   hAss->noProgram = 1;
    613 
    614   hAss->audioMuxVersion = audioMuxVersion;
    615 
    616   /* Fill noLayer array using hAss->config */
    617   hAss->allStreamsSameTimeFraming = allStreamsSameTimeFraming( hAss, hAss->noProgram, hAss->noLayer );
    618   /* Only allStreamsSameTimeFraming==1 is supported */
    619   FDK_ASSERT(hAss->allStreamsSameTimeFraming);
    620 
    621   hAss->fractDelayPresent = fractDelayPresent;
    622   hAss->otherDataLenBytes = 0;
    623 
    624   hAss->varMode = LATMVAR_SIMPLE_SEQUENCE;
    625 
    626   /* initialize counters */
    627   hAss->subFrameCnt                  = 0;
    628   hAss->noSubframes                  = DEFAULT_LATM_NR_OF_SUBFRAMES;
    629   hAss->noSubframes_next             = DEFAULT_LATM_NR_OF_SUBFRAMES;
    630 
    631   /* sync layer related */
    632   hAss->audioMuxLengthBytes     = 0;
    633 
    634   hAss->latmFrameCounter        = 0;
    635   hAss->muxConfigPeriod = muxConfigPeriod;
    636 
    637   return ErrorStatus;
    638 }
    639 
    640 
    641 /**
    642  *
    643  */
    644 UINT transportEnc_LatmCountTotalBitDemandHeader ( HANDLE_LATM_STREAM hAss , unsigned int streamDataLength )
    645 {
    646   UINT bitDemand = 0;
    647 
    648   switch (hAss->tt) {
    649   case TT_MP4_LOAS:
    650   case TT_MP4_LATM_MCP0:
    651   case TT_MP4_LATM_MCP1:
    652     if (hAss->subFrameCnt == 0) {
    653       bitDemand  = transportEnc_LatmCountFixBitDemandHeader ( hAss );
    654     }
    655     bitDemand += transportEnc_LatmCountVarBitDemandHeader ( hAss , streamDataLength /*- bitDemand*/);
    656     break;
    657   default:
    658     break;
    659   }
    660 
    661   return bitDemand;
    662 }
    663 
    664 static TRANSPORTENC_ERROR
    665 AdvanceAudioMuxElement (
    666         HANDLE_LATM_STREAM   hAss,
    667         HANDLE_FDK_BITSTREAM hBs,
    668         int                  auBits,
    669         int                  bufferFullness,
    670         CSTpCallBacks    *cb
    671         )
    672 {
    673   TRANSPORTENC_ERROR ErrorStatus = TRANSPORTENC_OK;
    674   int insertMuxSetup;
    675 
    676   /* Insert setup data to assemble Buffer */
    677   if (hAss->subFrameCnt == 0)
    678   {
    679     if (hAss->muxConfigPeriod > 0) {
    680       insertMuxSetup = (hAss->latmFrameCounter == 0);
    681     } else  {
    682       insertMuxSetup = 0;
    683     }
    684 
    685     if (hAss->tt != TT_MP4_LATM_MCP0) {
    686       if( insertMuxSetup ) {
    687         FDKwriteBits( hBs, 0, 1 );  /* useSameStreamMux useNewStreamMux */
    688         CreateStreamMuxConfig(hAss, hBs, bufferFullness, cb);
    689         if (ErrorStatus != TRANSPORTENC_OK)
    690           return ErrorStatus;
    691       } else {
    692         FDKwriteBits( hBs, 1, 1 );   /* useSameStreamMux */
    693       }
    694     }
    695   }
    696 
    697   /* PayloadLengthInfo */
    698   {
    699     int prog, layer;
    700 
    701     for (prog = 0; prog < hAss->noProgram; prog++) {
    702       for (layer = 0; layer < hAss->noLayer[prog]; layer++) {
    703         ErrorStatus = WriteAuPayloadLengthInfo( hBs, auBits );
    704         if (ErrorStatus != TRANSPORTENC_OK)
    705           return ErrorStatus;
    706       }
    707     }
    708   }
    709   /* At this point comes the access unit. */
    710 
    711   return TRANSPORTENC_OK;
    712 }
    713 
    714 TRANSPORTENC_ERROR
    715 transportEnc_LatmWrite (
    716         HANDLE_LATM_STREAM    hAss,
    717         HANDLE_FDK_BITSTREAM  hBs,
    718         int                   auBits,
    719         int                   bufferFullness,
    720         CSTpCallBacks     *cb
    721         )
    722 {
    723   TRANSPORTENC_ERROR ErrorStatus;
    724 
    725   if (hAss->subFrameCnt == 0) {
    726     /* Start new frame */
    727     FDKresetBitbuffer(hBs, BS_WRITER);
    728   }
    729 
    730   hAss->latmSubframeStart = FDKgetValidBits(hBs);
    731 
    732   /* Insert syncword and syncword distance
    733      - only if loas
    734      - we must update the syncword distance (=audiomuxlengthbytes) later
    735    */
    736   if( hAss->tt == TT_MP4_LOAS && hAss->subFrameCnt == 0)
    737   {
    738     /* Start new LOAS frame */
    739     FDKwriteBits( hBs, 0x2B7, 11 );
    740     hAss->audioMuxLengthBytes = 0;
    741     hAss->audioMuxLengthBytesPos = FDKgetValidBits( hBs );  /* store read pointer position */
    742     FDKwriteBits( hBs, hAss->audioMuxLengthBytes, 13 );
    743   }
    744 
    745   ErrorStatus = AdvanceAudioMuxElement(
    746           hAss,
    747           hBs,
    748           auBits,
    749           bufferFullness,
    750           cb
    751           );
    752 
    753   if (ErrorStatus != TRANSPORTENC_OK)
    754     return ErrorStatus;
    755 
    756   return ErrorStatus;
    757 }
    758 
    759 void transportEnc_LatmAdjustSubframeBits(HANDLE_LATM_STREAM    hAss,
    760                                          int                  *bits)
    761 {
    762   /* Substract bits from possible previous subframe */
    763   *bits -= hAss->latmSubframeStart;
    764   /* Add fill bits */
    765   if (hAss->subFrameCnt == 0)
    766     *bits += hAss->fillBits;
    767 }
    768 
    769 
    770 void transportEnc_LatmGetFrame(HANDLE_LATM_STREAM    hAss,
    771                                HANDLE_FDK_BITSTREAM  hBs,
    772                                int                  *bytes)
    773 {
    774 
    775   hAss->subFrameCnt++;
    776   if (hAss->subFrameCnt >= hAss->noSubframes)
    777   {
    778 
    779     /* Add LOAS frame length if required. */
    780     if (hAss->tt == TT_MP4_LOAS)
    781     {
    782       int latmBytes;
    783 
    784       latmBytes = (FDKgetValidBits(hBs)+7) >> 3;
    785 
    786       /* write length info into assembler buffer */
    787       hAss->audioMuxLengthBytes = latmBytes - 3; /* 3=Syncword + length */
    788       {
    789         FDK_BITSTREAM tmpBuf;
    790 
    791         FDKinitBitStream( &tmpBuf, hBs->hBitBuf.Buffer, hBs->hBitBuf.bufSize, 0, BS_WRITER ) ;
    792         FDKpushFor( &tmpBuf, hAss->audioMuxLengthBytesPos );
    793         FDKwriteBits( &tmpBuf, hAss->audioMuxLengthBytes, 13 );
    794         FDKsyncCache( &tmpBuf );
    795       }
    796     }
    797 
    798     /* Write AudioMuxElement byte alignment fill bits */
    799     FDKwriteBits(hBs, 0, hAss->fillBits);
    800 
    801     FDK_ASSERT( (FDKgetValidBits(hBs) % 8) == 0);
    802 
    803     hAss->subFrameCnt = 0;
    804 
    805     FDKsyncCache(hBs);
    806     *bytes = (FDKgetValidBits(hBs) + 7)>>3;
    807     //FDKfetchBuffer(hBs, buffer, (UINT*)bytes);
    808 
    809     if (hAss->muxConfigPeriod > 0)
    810     {
    811       hAss->latmFrameCounter++;
    812 
    813       if (hAss->latmFrameCounter >= hAss->muxConfigPeriod) {
    814         hAss->latmFrameCounter = 0;
    815         hAss->noSubframes = hAss->noSubframes_next;
    816       }
    817     }
    818   } else {
    819     /* No data this time */
    820     *bytes = 0;
    821   }
    822 }
    823 
    824 /**
    825  * Init LATM/LOAS
    826  */
    827 TRANSPORTENC_ERROR transportEnc_Latm_Init(
    828         HANDLE_LATM_STREAM  hAss,
    829         HANDLE_FDK_BITSTREAM hBs,
    830         CODER_CONFIG  *layerConfig,
    831         UINT audioMuxVersion,
    832         TRANSPORT_TYPE tt,
    833         CSTpCallBacks *cb
    834         )
    835 {
    836   TRANSPORTENC_ERROR ErrorStatus;
    837   int fractDelayPresent = 0;
    838   int prog, layer;
    839 
    840   int setupDataDistanceFrames = layerConfig->headerPeriod;
    841 
    842   FDK_ASSERT(setupDataDistanceFrames>=0);
    843 
    844   for (prog=0; prog<LATM_MAX_PROGRAMS; prog++) {
    845     for (layer=0; layer<LATM_MAX_LAYERS; layer++) {
    846       hAss->config[prog][layer] = NULL;
    847       hAss->m_linfo[prog][layer].streamID = -1;
    848     }
    849   }
    850 
    851   hAss->config[0][0] = layerConfig;
    852   hAss->m_linfo[0][0].streamID = 0;
    853 
    854   ErrorStatus = transportEnc_InitLatmStream( hAss,
    855                                              fractDelayPresent,
    856                                              setupDataDistanceFrames,
    857                                              (audioMuxVersion)?1:0,
    858                                              tt
    859                                              );
    860   if (ErrorStatus != TRANSPORTENC_OK)
    861     goto bail;
    862 
    863   ErrorStatus = transportEnc_LatmSetNrOfSubframes(
    864                                                    hAss,
    865                                                    layerConfig->nSubFrames
    866                                                   );
    867   if (ErrorStatus != TRANSPORTENC_OK)
    868     goto bail;
    869 
    870   /* Get the size of the StreamMuxConfig somehow */
    871   AdvanceAudioMuxElement(hAss, hBs, 0, 0, cb);
    872   //CreateStreamMuxConfig(hAss, hBs, 0);
    873 
    874 bail:
    875   return ErrorStatus;
    876 }
    877 
    878 
    879 
    880 
    881 
    882 
    883