libMpegTPEnc/src/tpenc_latm.cpp

   1
   2 /* -----------------------------------------------------------------------------------------------------------
   3 Software License for The Fraunhofer FDK AAC Codec Library for Android
   4
   5 © Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung 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@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