1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 /* 19 20 Pathname: pvmp4audiodecodeframe 21 22 ------------------------------------------------------------------------------ 23 REVISION HISTORY 24 25 Description: Modified from original shareware code 26 27 Description: Pulled in loop structure from console.c, so that this function 28 now decodes all frames in the file. 29 30 Original program used several global variables. These have been 31 eliminated, except for situations in which the global variables 32 could be converted into const types. Otherwise, they are passed 33 by reference through the functions. 34 35 Description: Begin mods for file I/O removal 36 37 Description: Merged trans4m_freq_2_time, trans4m_time_2_freq, etc. 38 39 Description: Removing commented out sections of code. This includes the 40 removal of unneeded functions init_lt_pred, reset_mc_info, 41 42 Description: Copied from aac_decode_frame.c and renamed file, 43 Made many changes. 44 45 Description: Prepare for code review 46 47 Description: Update per review comments: 48 1) Add comment about leaveGetLoop 49 2) Remove inverseTNSCoef array 50 3) fix wnd_shape_this_bk to wnd_shape_prev_bk in F to T 51 4) Clean up comments 52 5) Change call to long_term_synthesis 53 54 Description: Remove division for calculation of bitrate. 55 56 Description: Remove update of LTP buffers if not LTP audio object type. 57 58 Description: Add hasmask to call to right_ch_sfb_tools_ms 59 60 Description: 61 Modified to call ltp related routines on the left channel 62 before intensity is called on the right channel. The previous version 63 was causing a problem when IS was used on the right channel and LTP 64 on the left channel for the same scalefactor band. 65 66 This fix required creating a new function, apply_ms_synt, deleting another 67 function (right_ch_sfb_tools_noms.c), and modifying the calling order of 68 the other functions. 69 70 Description: Made changes per review comments. 71 72 Description: Changed name of right_ch_sfb_tools_ms to pns_intensity_right 73 74 Description: Added cast, since pVars->inputStream.usedBits is UInt, and 75 pExt->remainderBits is Int. 76 77 pExt->remainderBits = 78 (Int)(pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK); 79 80 Description: Modified to pass a pointer to scratch memory into 81 tns_setup_filter.c 82 83 Description: Removed include of "s_TNSInfo.h" 84 85 Description: Removed call to "tns_setup_filter" which has been eliminated 86 by merging its functionality into "get_tns" 87 88 Description: Passing in a pointer to a q-format array, rather than 89 the address of a single q-format, for the inverse filter case for 90 apply_tns. 91 92 Description: 93 (1) Added #include of "e_ElementId.h" 94 Previously, this function was relying on another include file 95 to include "e_ElementId.h" 96 97 (2) Updated the copyright header. 98 99 Description: 100 Per review comments, declared two temporary variables 101 102 pChLeftShare = pChVars[LEFT]->pShareWfxpCoef; 103 pChRightShare = pChVars[RIGHT]->pShareWfxpCoef; 104 105 Description: 106 long_term_synthesis should have been invoked with max_sfb 107 as the 2nd parameter, rather than pFrameInfo->sfb_per_win[0]. 108 109 Old 110 long_term_synthesis( 111 pChVars[ch]->wnd, 112 pFrameInfo->sfb_per_win[0] ... 113 114 Correction 115 long_term_synthesis( 116 pChVars[ch]->wnd, 117 pChVars[ch]->pShareWfxpCoef->max_sfb ... 118 119 This problem caused long_term_synthesis to read memory which 120 was not initialized in get_ics_info.c 121 122 Description: 123 (1) Utilize scratch memory for the scratch Prog_Config. 124 125 Description: (1) Modified to decode ID_END syntactic element after header 126 127 Description: 128 (1) Reconfigured LTP buffer as a circular buffer. This saves 129 2048 Int16->Int16 copies per frame. 130 131 Description: Updated so ltp buffers are not used as a wasteful 132 intermediate buffer for LC streams. Data is transferred directly 133 from the filterbank to the output stream. 134 135 Description: Decode ADIF header if frame count is zero. 136 The AudioSpecificConfig is decoded by a separate API. 137 138 Description: Added comments explaining how the ltp_buffer_state 139 variable is updated. 140 141 142 Description: Modified code to take advantage of new trans4m_freq_2_time_fxp, 143 which writes the output directly into a 16-bit output buffer. This 144 improvement allows faster operation by reducing the amount of memory 145 transfers. Speed can be further improved on most platforms via use of a 146 DMA transfer in the function write_output.c 147 148 Description: perChan[] is an array of structures in tDec_Int_File. Made 149 corresponding changes. 150 151 Description: Included changes in interface for q_normalize() and 152 trans4m_freq_2_time_fxp. 153 154 Description: Included changes in interface for long_term_prediction. 155 156 Description: Added support for DSE (Data Streaming Channel). Added 157 function get_dse() and included file get_dse.h 158 159 Description: Added support for the ill-case when a raw data block contains 160 only a terminator <ID_END>. This is illegal but is added 161 for convinience 162 163 Description: Added support for empty audio frames, such the one containing 164 only DSE or FILL elements. A trap was added to stop processing 165 when no audio information was sent. 166 167 Description: Added support for adts format files. Added saturation to 168 floating point version of aac+ decoding 169 170 Description: 171 172 ------------------------------------------------------------------------------ 173 INPUT AND OUTPUT DEFINITIONS 174 175 Inputs: 176 pExt = pointer to the external interface structure. See the file 177 PVMP4AudioDecoder_API.h for a description of each field. 178 Data type of pointer to a tPVMP4AudioDecoderExternal 179 structure. 180 181 pMem = void pointer to hide the internal implementation of the library 182 It is cast back to a tDec_Int_File structure. This structure 183 contains information that needs to persist between calls to 184 this function, or is too big to be placed on the stack, even 185 though the data is only needed during execution of this function 186 Data type void pointer, internally pointer to a tDec_Int_File 187 structure. 188 189 Local Stores/Buffers/Pointers Needed: None 190 (The memory set aside in pMem performs this task) 191 192 Global Stores/Buffers/Pointers Needed: None 193 194 Outputs: 195 status = 0 if no error occurred 196 MP4AUDEC_NONRECOVERABLE if a non-recoverable error occurred 197 MP4AUDEC_RECOVERABLE if a recoverable error occurred. 198 Presently a recoverable error does not exist, but this 199 was a requirement. 200 201 202 Pointers and Buffers Modified: 203 pMem contents are modified. 204 pExt: (more detail in the file PVMP4AudioDecoder_API.h) 205 inputBufferUsedLength - number of array elements used up by the stream. 206 remainderBits - remaining bits in the next UInt32 buffer 207 samplingRate - sampling rate in samples per sec 208 bitRate - bit rate in bits per second, varies frame to frame. 209 encodedChannels - channels found on the file (informative) 210 frameLength - length of the frame 211 212 Local Stores Modified: None. 213 214 Global Stores Modified: None. 215 216 ------------------------------------------------------------------------------ 217 FUNCTION DESCRIPTION 218 219 Decodes one frame of an MPEG-2/MPEG-4 encoded audio bitstream. 220 221 This function calls the various components of the decoder in the proper order. 222 223 224 Left Channel Right Channel 225 | | 226 | | 227 | | 228 \|/ \|/ 229 #1 ____________________ #2 ____________________ 230 | | | | 231 | Huffman Decoding | | Huffman Decoding | 232 |__________________| |__________________| 233 | | 234 | | 235 | | 236 \|/ | 237 #3 ____________________ | 238 | | | 239 | PNS LEFT | | 240 |__________________| | 241 | | 242 | | 243 | | 244 \|/ \|/ 245 #4 ______________________________________________________________________ 246 | | 247 | Apply MS_Synt | 248 |____________________________________________________________________| 249 | | 250 | | 251 \|/ | 252 #5 ____________________ | 253 | | W 254 | LTP | A 255 |__________________| I 256 | T 257 | | 258 | F 259 \|/ O 260 #6 ____________________ R 261 | | | 262 | Time -> Freq | L 263 |__________________| E 264 | F 265 | T 266 | | 267 \|/ C 268 #7 ____________________ H 269 | | A 270 | TNS Inverse | N 271 |__________________| N 272 | E 273 | L 274 | | 275 \|/ | 276 #8 ____________________ | 277 | | | 278 | Long Term Synth | | 279 |__________________| | 280 | | 281 | \|/ 282 | #9 ____________________ 283 | | | 284 |--DATA ON LEFT CHANNEL MAY BE USED----->| PNS/Intensity Rt | 285 | |__________________| 286 | | 287 | | 288 | \|/ 289 | #10 ____________________ 290 W | | 291 A | LTP | 292 I |__________________| 293 T | 294 | | 295 F | 296 O \|/ 297 R #11 ____________________ 298 | | | 299 R | Time -> Freq | 300 I |__________________| 301 G | 302 H | 303 T | 304 | \|/ 305 C #12 ____________________ 306 H | | 307 A | TNS Inverse | 308 N |__________________| 309 N | 310 E | 311 L | 312 | \|/ 313 | #13 ____________________ 314 | | | 315 | | Long Term Synth | 316 | |__________________| 317 | | 318 | | 319 | | 320 \|/ \|/ 321 #14 ____________________ #18 ____________________ 322 | | | | 323 | TNS | | TNS | 324 |__________________| |__________________| 325 | | 326 | | 327 | | 328 \|/ \|/ 329 #15 ____________________ #19 ____________________ 330 | | | | 331 | qFormatNorm | | qFormatNorm | 332 |__________________| |__________________| 333 | | 334 | | 335 | | 336 \|/ \|/ 337 #16 ____________________ #20 ____________________ 338 | | | | 339 | Freq / Time | | Freq / Time | 340 |__________________| |__________________| 341 | | 342 | | 343 | | 344 \|/ \|/ 345 #17 ____________________ #21 ____________________ 346 | | | | 347 | Limit Buffer | | Limit Buffer | 348 |__________________| |__________________| 349 | | 350 | | 351 | | 352 \|/ \|/ 353 #22 ______________________________________________________________________ 354 | | 355 | Write Output | 356 |____________________________________________________________________| 357 358 359 ------------------------------------------------------------------------------ 360 REQUIREMENTS 361 362 PacketVideo Document # CCC-AUD-AAC-ERS-0003 363 364 ------------------------------------------------------------------------------ 365 REFERENCES 366 367 (1) MPEG-2 NBC Audio Decoder 368 "This software module was originally developed by AT&T, Dolby 369 Laboratories, Fraunhofer Gesellschaft IIS in the course of development 370 of the MPEG-2 NBC/MPEG-4 Audio standard ISO/IEC 13818-7, 14496-1,2 and 371 3. This software module is an implementation of a part of one or more 372 MPEG-2 NBC/MPEG-4 Audio tools as specified by the MPEG-2 NBC/MPEG-4 373 Audio standard. ISO/IEC gives users of the MPEG-2 NBC/MPEG-4 Audio 374 standards free license to this software module or modifications thereof 375 for use in hardware or software products claiming conformance to the 376 MPEG-2 NBC/MPEG-4 Audio standards. Those intending to use this software 377 module in hardware or software products are advised that this use may 378 infringe existing patents. The original developer of this software 379 module and his/her company, the subsequent editors and their companies, 380 and ISO/IEC have no liability for use of this software module or 381 modifications thereof in an implementation. Copyright is not released 382 for non MPEG-2 NBC/MPEG-4 Audio conforming products.The original 383 developer retains full right to use the code for his/her own purpose, 384 assign or donate the code to a third party and to inhibit third party 385 from using the code for non MPEG-2 NBC/MPEG-4 Audio conforming products. 386 This copyright notice must be included in all copies or derivative 387 works." 388 Copyright(c)1996. 389 390 ------------------------------------------------------------------------------ 391 RESOURCES USED 392 When the code is written for a specific target processor the 393 the resources used should be documented below. 394 395 STACK USAGE: [stack count for this module] + [variable to represent 396 stack usage for each subroutine called] 397 398 where: [stack usage variable] = stack usage for [subroutine 399 name] (see [filename].ext) 400 401 DATA MEMORY USED: x words 402 403 PROGRAM MEMORY USED: x words 404 405 CLOCK CYCLES: [cycle count equation for this module] + [variable 406 used to represent cycle count for each subroutine 407 called] 408 409 where: [cycle count variable] = cycle count for [subroutine 410 name] (see [filename].ext) 411 412 ------------------------------------------------------------------------------ 413 */ 414 415 416 /*---------------------------------------------------------------------------- 417 ; INCLUDES 418 ----------------------------------------------------------------------------*/ 419 #include "pv_audio_type_defs.h" 420 421 #include "s_tdec_int_chan.h" 422 #include "s_tdec_int_file.h" 423 #include "aac_mem_funcs.h" 424 #include "sfb.h" /* Where samp_rate_info[] is declared */ 425 #include "e_tmp4audioobjecttype.h" 426 #include "e_elementid.h" 427 428 429 #include "get_adif_header.h" 430 #include "get_adts_header.h" 431 #include "get_audio_specific_config.h" 432 #include "ibstream.h" /* where getbits is declared */ 433 434 #include "huffman.h" /* where huffdecode is declared */ 435 #include "get_prog_config.h" 436 #include "getfill.h" 437 #include "pns_left.h" 438 439 #include "apply_ms_synt.h" 440 #include "pns_intensity_right.h" 441 #include "q_normalize.h" 442 #include "long_term_prediction.h" 443 #include "long_term_synthesis.h" 444 #include "ltp_common_internal.h" 445 #include "apply_tns.h" 446 447 #include "window_block_fxp.h" 448 449 #include "write_output.h" 450 451 #include "pvmp4audiodecoder_api.h" /* Where this function is declared */ 452 #include "get_dse.h" 453 454 #include "sbr_applied.h" 455 #include "sbr_open.h" 456 #include "get_sbr_bitstream.h" 457 #include "e_sbr_element_id.h" 458 459 460 461 /*---------------------------------------------------------------------------- 462 ; MACROS 463 ; Define module specific macros here 464 ----------------------------------------------------------------------------*/ 465 466 /*---------------------------------------------------------------------------- 467 ; DEFINES 468 ; Include all pre-processor statements here. Include conditional 469 ; compile variables also. 470 ----------------------------------------------------------------------------*/ 471 472 #define LEFT (0) 473 #define RIGHT (1) 474 475 476 /*---------------------------------------------------------------------------- 477 ; LOCAL FUNCTION DEFINITIONS 478 ; Function Prototype declaration 479 ----------------------------------------------------------------------------*/ 480 481 /*---------------------------------------------------------------------------- 482 ; LOCAL STORE/BUFFER/POINTER DEFINITIONS 483 ; Variable declaration - defined here and used outside this module 484 ----------------------------------------------------------------------------*/ 485 486 /*---------------------------------------------------------------------------- 487 ; EXTERNAL FUNCTION REFERENCES 488 ; Declare functions defined elsewhere and referenced in this module 489 ----------------------------------------------------------------------------*/ 490 491 void InitSbrSynFilterbank(bool bDownSampleSBR); 492 493 494 495 /*---------------------------------------------------------------------------- 496 ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES 497 ; Declare variables used in this module but defined elsewhere 498 ----------------------------------------------------------------------------*/ 499 500 /*---------------------------------------------------------------------------- 501 ; FUNCTION CODE 502 ----------------------------------------------------------------------------*/ 503 504 505 OSCL_EXPORT_REF Int PVMP4AudioDecodeFrame( 506 tPVMP4AudioDecoderExternal *pExt, 507 void *pMem) 508 { 509 Int frameLength; /* Helper variable */ 510 Int ch; 511 Int id_syn_ele; 512 UInt initialUsedBits; /* Unsigned for C55x */ 513 Int qFormatNorm; 514 Int qPredictedSamples; 515 Bool leaveGetLoop; 516 MC_Info *pMC_Info; /* Helper pointer */ 517 FrameInfo *pFrameInfo; /* Helper pointer */ 518 tDec_Int_File *pVars; /* Helper pointer */ 519 tDec_Int_Chan *pChVars[Chans]; /* Helper pointer */ 520 521 per_chan_share_w_fxpCoef *pChLeftShare; /* Helper pointer */ 522 per_chan_share_w_fxpCoef *pChRightShare; /* Helper pointer */ 523 524 Int status = MP4AUDEC_SUCCESS; 525 526 527 Bool empty_frame; 528 529 #ifdef AAC_PLUS 530 531 SBRDECODER_DATA *sbrDecoderData; 532 SBR_DEC *sbrDec; 533 SBRBITSTREAM *sbrBitStream; 534 535 #endif 536 /* 537 * Initialize "helper" pointers to existing memory. 538 */ 539 pVars = (tDec_Int_File *)pMem; 540 541 pMC_Info = &pVars->mc_info; 542 543 pChVars[LEFT] = &pVars->perChan[LEFT]; 544 pChVars[RIGHT] = &pVars->perChan[RIGHT]; 545 546 pChLeftShare = pChVars[LEFT]->pShareWfxpCoef; 547 pChRightShare = pChVars[RIGHT]->pShareWfxpCoef; 548 549 550 #ifdef AAC_PLUS 551 552 sbrDecoderData = (SBRDECODER_DATA *) & pVars->sbrDecoderData; 553 sbrDec = (SBR_DEC *) & pVars->sbrDec; 554 sbrBitStream = (SBRBITSTREAM *) & pVars->sbrBitStr; 555 556 #ifdef PARAMETRICSTEREO 557 sbrDecoderData->hParametricStereoDec = (HANDLE_PS_DEC) & pVars->sbrDecoderData.ParametricStereoDec; 558 #endif 559 560 #endif 561 /* 562 * Translate input buffer variables. 563 */ 564 pVars->inputStream.pBuffer = pExt->pInputBuffer; 565 566 pVars->inputStream.inputBufferCurrentLength = (UInt)pExt->inputBufferCurrentLength; 567 568 pVars->inputStream.availableBits = 569 (UInt)(pExt->inputBufferCurrentLength << INBUF_ARRAY_INDEX_SHIFT); 570 571 initialUsedBits = 572 (UInt)((pExt->inputBufferUsedLength << INBUF_ARRAY_INDEX_SHIFT) + 573 pExt->remainderBits); 574 575 pVars->inputStream.usedBits = initialUsedBits; 576 577 if (initialUsedBits > pVars->inputStream.availableBits) 578 { 579 status = MP4AUDEC_INVALID_FRAME; 580 } 581 else if (pVars->bno == 0) 582 { 583 /* 584 * Attempt to read in ADIF format first because it is easily identified. 585 * If its not an ADIF bitstream, get_adif_header rewinds the "pointer" 586 * (actually usedBits). 587 */ 588 status = 589 get_adif_header( 590 pVars, 591 &(pVars->scratch.scratch_prog_config)); 592 593 byte_align(&pVars->inputStream); 594 595 if (status == SUCCESS) 596 { 597 pVars->prog_config.file_is_adts = FALSE; 598 } 599 else /* we've tried simple audio config, adif, then it should be adts */ 600 { 601 pVars->prog_config.file_is_adts = TRUE; 602 } 603 } 604 else if ((pVars->bno == 1) && (pVars->prog_config.file_is_adts == FALSE)) 605 { 606 607 /* 608 * There might be an ID_END element following immediately after the 609 * AudioSpecificConfig header. This syntactic element should be read 610 * and byte_aligned before proceeds to decode "real" AAC raw data. 611 */ 612 id_syn_ele = (Int)getbits(LEN_SE_ID, &pVars->inputStream) ; 613 614 if (id_syn_ele == ID_END) 615 { 616 617 byte_align(&pVars->inputStream); 618 619 pExt->inputBufferUsedLength = 620 pVars->inputStream.usedBits >> INBUF_ARRAY_INDEX_SHIFT; 621 622 pExt->remainderBits = pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK; 623 624 pVars->bno++; 625 626 return(status); 627 } 628 else 629 { 630 /* 631 * Rewind bitstream pointer so that the syntactic element can be 632 * read when decoding raw bitstream 633 */ 634 pVars->inputStream.usedBits -= LEN_SE_ID; 635 } 636 637 } 638 639 if (pVars->prog_config.file_is_adts == TRUE) 640 { 641 /* 642 * If file is adts format, let the decoder handle only on data raw 643 * block at the time, once the last (or only) data block has been 644 * processed, then synch on the next header 645 */ 646 if (pVars->prog_config.headerless_frames) 647 { 648 pVars->prog_config.headerless_frames--; /* raw data block counter */ 649 } 650 else 651 { 652 status = get_adts_header(pVars, 653 &(pVars->syncword), 654 &(pVars->invoke), 655 3); /* CorrectlyReadFramesCount */ 656 657 if (status != SUCCESS) 658 { 659 status = MP4AUDEC_LOST_FRAME_SYNC; /* we lost track of header */ 660 } 661 } 662 } 663 else 664 { 665 byte_align(&pVars->inputStream); 666 } 667 668 #ifdef AAC_PLUS 669 sbrBitStream->NrElements = 0; 670 sbrBitStream->NrElementsCore = 0; 671 672 #endif 673 674 /* 675 * The variable leaveGetLoop is used to signal that the following 676 * loop can be left, which retrieves audio syntatic elements until 677 * an ID_END is found, or an error occurs. 678 */ 679 leaveGetLoop = FALSE; 680 empty_frame = TRUE; 681 682 while ((leaveGetLoop == FALSE) && (status == SUCCESS)) 683 { 684 /* get audio syntactic element */ 685 id_syn_ele = (Int)get9_n_lessbits(LEN_SE_ID, &pVars->inputStream); 686 687 /* 688 * As fractional frames are a possible input, check that parsing does not 689 * go beyond the available bits before parsing the syntax. 690 */ 691 if (pVars->inputStream.usedBits > pVars->inputStream.availableBits) 692 { 693 status = MP4AUDEC_INCOMPLETE_FRAME; /* possible EOF or fractional frame */ 694 id_syn_ele = ID_END; /* quit while-loop */ 695 } 696 697 switch (id_syn_ele) 698 { 699 case ID_END: /* terminator field */ 700 leaveGetLoop = TRUE; 701 break; 702 703 case ID_SCE: /* single channel */ 704 case ID_CPE: /* channel pair */ 705 empty_frame = FALSE; 706 status = 707 huffdecode( 708 id_syn_ele, 709 &(pVars->inputStream), 710 pVars, 711 pChVars); 712 713 #ifdef AAC_PLUS 714 if (id_syn_ele == ID_SCE) 715 { 716 sbrBitStream->sbrElement[sbrBitStream->NrElements].ElementID = SBR_ID_SCE; 717 } 718 else if (id_syn_ele == ID_CPE) 719 { 720 sbrBitStream->sbrElement[sbrBitStream->NrElements].ElementID = SBR_ID_CPE; 721 } 722 sbrBitStream->NrElementsCore++; 723 724 725 #endif 726 727 break; 728 729 case ID_PCE: /* program config element */ 730 /* 731 * PCE are not accepted in the middle of a 732 * raw_data_block. If found, a possible error may happen 733 * If a PCE is encountered during the first 2 frames, 734 * it will be read and accepted 735 * if its tag matches the first, with no error checking 736 * (inside of get_prog_config) 737 */ 738 739 if (pVars->bno <= 1) 740 { 741 status = get_prog_config(pVars, 742 &(pVars->scratch.scratch_prog_config)); 743 } 744 else 745 { 746 status = MP4AUDEC_INVALID_FRAME; 747 } 748 break; 749 750 case ID_FIL: /* fill element */ 751 #ifdef AAC_PLUS 752 get_sbr_bitstream(sbrBitStream, &pVars->inputStream); 753 754 #else 755 getfill(&pVars->inputStream); 756 #endif 757 758 break; 759 760 case ID_DSE: /* Data Streaming element */ 761 get_dse(pVars->share.data_stream_bytes, 762 &pVars->inputStream); 763 break; 764 765 default: /* Unsupported element, including ID_LFE */ 766 status = -1; /* ERROR CODE needs to be updated */ 767 break; 768 769 } /* end switch() */ 770 771 } /* end while() */ 772 773 byte_align(&pVars->inputStream); 774 775 /* 776 * After parsing the first frame ( bno=0 (adif), bno=1 (raw)) 777 * verify if implicit signalling is forcing to upsample AAC with 778 * no AAC+/eAAC+ content. If so, disable upsampling 779 */ 780 781 #ifdef AAC_PLUS 782 if (pVars->bno <= 1) 783 { 784 if ((pVars->mc_info.ExtendedAudioObjectType == MP4AUDIO_AAC_LC) && 785 (!sbrBitStream->NrElements)) 786 { 787 PVMP4AudioDecoderDisableAacPlus(pExt, pMem); 788 } 789 } 790 #endif 791 792 /* 793 * There might be an empty raw data block with only a 794 * ID_END element or non audio ID_DSE, ID_FIL 795 * This is an "illegal" condition but this trap 796 * avoids any further processing 797 */ 798 799 if (empty_frame == TRUE) 800 { 801 pExt->inputBufferUsedLength = 802 pVars->inputStream.usedBits >> INBUF_ARRAY_INDEX_SHIFT; 803 804 pExt->remainderBits = pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK; 805 806 pVars->bno++; 807 808 return(status); 809 810 } 811 812 #ifdef AAC_PLUS 813 814 if (sbrBitStream->NrElements) 815 { 816 /* for every core SCE or CPE there must be an SBR element, otherwise sths. wrong */ 817 if (sbrBitStream->NrElements != sbrBitStream->NrElementsCore) 818 { 819 status = MP4AUDEC_INVALID_FRAME; 820 } 821 822 if (pExt->aacPlusEnabled == false) 823 { 824 sbrBitStream->NrElements = 0; /* disable aac processing */ 825 } 826 } 827 else 828 { 829 /* 830 * This is AAC, but if aac+/eaac+ was declared in the stream, and there is not sbr content 831 * something is wrong 832 */ 833 if (pMC_Info->sbrPresentFlag || pMC_Info->psPresentFlag) 834 { 835 status = MP4AUDEC_INVALID_FRAME; 836 } 837 } 838 #endif 839 840 841 842 843 /* 844 * Signal processing section. 845 */ 846 frameLength = pVars->frameLength; 847 848 if (status == SUCCESS) 849 { 850 /* 851 * PNS and INTENSITY STEREO and MS 852 */ 853 854 pFrameInfo = pVars->winmap[pChVars[LEFT]->wnd]; 855 856 pns_left( 857 pFrameInfo, 858 pChLeftShare->group, 859 pChLeftShare->cb_map, 860 pChLeftShare->factors, 861 pChLeftShare->lt_status.sfb_prediction_used, 862 pChLeftShare->lt_status.ltp_data_present, 863 pChVars[LEFT]->fxpCoef, 864 pChLeftShare->qFormat, 865 &(pVars->pns_cur_noise_state)); 866 867 /* 868 * apply_ms_synt can only be ran for common windows. 869 * (where both the left and right channel share the 870 * same grouping, window length, etc. 871 * 872 * pVars->hasmask will be > 0 only if 873 * common windows are enabled for this frame. 874 */ 875 876 if (pVars->hasmask > 0) 877 { 878 apply_ms_synt( 879 pFrameInfo, 880 pChLeftShare->group, 881 pVars->mask, 882 pChLeftShare->cb_map, 883 pChVars[LEFT]->fxpCoef, 884 pChVars[RIGHT]->fxpCoef, 885 pChLeftShare->qFormat, 886 pChRightShare->qFormat); 887 } 888 889 for (ch = 0; (ch < pMC_Info->nch); ch++) 890 { 891 pFrameInfo = pVars->winmap[pChVars[ch]->wnd]; 892 893 /* 894 * Note: This MP4 library assumes that if there are two channels, 895 * then the second channel is right AND it was a coupled channel, 896 * therefore there is no need to check the "is_cpe" flag. 897 */ 898 899 if (ch > 0) 900 { 901 pns_intensity_right( 902 pVars->hasmask, 903 pFrameInfo, 904 pChRightShare->group, 905 pVars->mask, 906 pChRightShare->cb_map, 907 pChLeftShare->factors, 908 pChRightShare->factors, 909 pChRightShare->lt_status.sfb_prediction_used, 910 pChRightShare->lt_status.ltp_data_present, 911 pChVars[LEFT]->fxpCoef, 912 pChVars[RIGHT]->fxpCoef, 913 pChLeftShare->qFormat, 914 pChRightShare->qFormat, 915 &(pVars->pns_cur_noise_state)); 916 } 917 918 if (pChVars[ch]->pShareWfxpCoef->lt_status.ltp_data_present != FALSE) 919 { 920 /* 921 * LTP - Long Term Prediction 922 */ 923 924 qPredictedSamples = long_term_prediction( 925 pChVars[ch]->wnd, 926 pChVars[ch]->pShareWfxpCoef->lt_status. 927 weight_index, 928 pChVars[ch]->pShareWfxpCoef->lt_status. 929 delay, 930 pChVars[ch]->ltp_buffer, 931 pVars->ltp_buffer_state, 932 pChVars[ch]->time_quant, 933 pVars->share.predictedSamples, /* Scratch */ 934 frameLength); 935 936 trans4m_time_2_freq_fxp( 937 pVars->share.predictedSamples, 938 pChVars[ch]->wnd, 939 pChVars[ch]->wnd_shape_prev_bk, 940 pChVars[ch]->wnd_shape_this_bk, 941 &qPredictedSamples, 942 pVars->scratch.fft); /* scratch memory for FFT */ 943 944 945 /* 946 * To solve a potential problem where a pointer tied to 947 * the qFormat was being incremented, a pointer to 948 * pChVars[ch]->qFormat is passed in here rather than 949 * the address of qPredictedSamples. 950 * 951 * Neither values are actually needed in the case of 952 * inverse filtering, but the pointer was being 953 * passed (and incremented) regardless. 954 * 955 * So, the solution is to pass a space of memory 956 * that a pointer can happily point to. 957 */ 958 959 /* This is the inverse filter */ 960 apply_tns( 961 pVars->share.predictedSamples, /* scratch re-used for each ch */ 962 pChVars[ch]->pShareWfxpCoef->qFormat, /* Not used by the inv_filter */ 963 pFrameInfo, 964 &(pChVars[ch]->pShareWfxpCoef->tns), 965 TRUE, /* TRUE is FIR */ 966 pVars->scratch.tns_inv_filter); 967 968 /* 969 * For the next function long_term_synthesis, 970 * the third param win_sfb_top[], and 971 * the tenth param coef_per_win, 972 * are used differently that in the rest of the project. This 973 * is because originally the ISO code was going to have 974 * these parameters change as the "short window" changed. 975 * These are all now the same value for each of the eight 976 * windows. This is why there is a [0] at the 977 * end of each of theses parameters. 978 * Note in particular that win_sfb_top was originally an 979 * array of pointers to arrays, but inside long_term_synthesis 980 * it is now a simple array. 981 * When the rest of the project functions are changed, the 982 * structure FrameInfo changes, and the [0]'s are removed, 983 * this comment could go away. 984 */ 985 long_term_synthesis( 986 pChVars[ch]->wnd, 987 pChVars[ch]->pShareWfxpCoef->max_sfb, 988 pFrameInfo->win_sfb_top[0], /* Look above */ 989 pChVars[ch]->pShareWfxpCoef->lt_status.win_prediction_used, 990 pChVars[ch]->pShareWfxpCoef->lt_status.sfb_prediction_used, 991 pChVars[ch]->fxpCoef, /* input and output */ 992 pChVars[ch]->pShareWfxpCoef->qFormat, /* input and output */ 993 pVars->share.predictedSamples, 994 qPredictedSamples, /* q format for previous aray */ 995 pFrameInfo->coef_per_win[0], /* Look above */ 996 NUM_SHORT_WINDOWS, 997 NUM_RECONSTRUCTED_SFB); 998 999 } /* end if (pChVars[ch]->lt_status.ltp_data_present != FALSE) */ 1000 1001 } /* for(ch) */ 1002 1003 for (ch = 0; (ch < pMC_Info->nch); ch++) 1004 { 1005 1006 pFrameInfo = pVars->winmap[pChVars[ch]->wnd]; 1007 1008 /* 1009 * TNS - Temporal Noise Shaping 1010 */ 1011 1012 /* This is the forward filter 1013 * 1014 * A special note: Scratch memory is not used by 1015 * the forward filter, but is passed in to maintain 1016 * common interface for inverse and forward filter 1017 */ 1018 apply_tns( 1019 pChVars[ch]->fxpCoef, 1020 pChVars[ch]->pShareWfxpCoef->qFormat, 1021 pFrameInfo, 1022 &(pChVars[ch]->pShareWfxpCoef->tns), 1023 FALSE, /* FALSE is IIR */ 1024 pVars->scratch.tns_inv_filter); 1025 1026 /* 1027 * Normalize the q format across all scale factor bands 1028 * to one value. 1029 */ 1030 qFormatNorm = 1031 q_normalize( 1032 pChVars[ch]->pShareWfxpCoef->qFormat, 1033 pFrameInfo, 1034 pChVars[ch]->abs_max_per_window, 1035 pChVars[ch]->fxpCoef); 1036 1037 /* 1038 * filterbank - converts frequency coeficients to time domain. 1039 */ 1040 1041 #ifdef AAC_PLUS 1042 if (sbrBitStream->NrElements == 0 && pMC_Info->upsamplingFactor == 1) 1043 { 1044 trans4m_freq_2_time_fxp_2( 1045 pChVars[ch]->fxpCoef, 1046 pChVars[ch]->time_quant, 1047 pChVars[ch]->wnd, /* window sequence */ 1048 pChVars[ch]->wnd_shape_prev_bk, 1049 pChVars[ch]->wnd_shape_this_bk, 1050 qFormatNorm, 1051 pChVars[ch]->abs_max_per_window, 1052 pVars->scratch.fft, 1053 &pExt->pOutputBuffer[ch]); 1054 /* 1055 * Update LTP buffers if needed 1056 */ 1057 1058 if (pVars->mc_info.audioObjectType == MP4AUDIO_LTP) 1059 { 1060 Int16 * pt = &pExt->pOutputBuffer[ch]; 1061 Int16 * ptr = &(pChVars[ch]->ltp_buffer[pVars->ltp_buffer_state]); 1062 Int16 x, y; 1063 for (Int32 i = HALF_LONG_WINDOW; i != 0; i--) 1064 { 1065 x = *pt; 1066 pt += 2; 1067 y = *pt; 1068 pt += 2; 1069 *(ptr++) = x; 1070 *(ptr++) = y; 1071 } 1072 } 1073 } 1074 else 1075 { 1076 trans4m_freq_2_time_fxp_1( 1077 pChVars[ch]->fxpCoef, 1078 pChVars[ch]->time_quant, 1079 &(pChVars[ch]->ltp_buffer[pVars->ltp_buffer_state + 288]), 1080 pChVars[ch]->wnd, /* window sequence */ 1081 pChVars[ch]->wnd_shape_prev_bk, 1082 pChVars[ch]->wnd_shape_this_bk, 1083 qFormatNorm, 1084 pChVars[ch]->abs_max_per_window, 1085 pVars->scratch.fft); 1086 1087 } 1088 #else 1089 1090 trans4m_freq_2_time_fxp_2( 1091 pChVars[ch]->fxpCoef, 1092 pChVars[ch]->time_quant, 1093 pChVars[ch]->wnd, /* window sequence */ 1094 pChVars[ch]->wnd_shape_prev_bk, 1095 pChVars[ch]->wnd_shape_this_bk, 1096 qFormatNorm, 1097 pChVars[ch]->abs_max_per_window, 1098 pVars->scratch.fft, 1099 &pExt->pOutputBuffer[ch]); 1100 /* 1101 * Update LTP buffers only if needed 1102 */ 1103 1104 if (pVars->mc_info.audioObjectType == MP4AUDIO_LTP) 1105 { 1106 Int16 * pt = &pExt->pOutputBuffer[ch]; 1107 Int16 * ptr = &(pChVars[ch]->ltp_buffer[pVars->ltp_buffer_state]); 1108 Int16 x, y; 1109 for (Int32 i = HALF_LONG_WINDOW; i != 0; i--) 1110 { 1111 x = *pt; 1112 pt += 2; 1113 y = *pt; 1114 pt += 2; 1115 *(ptr++) = x; 1116 *(ptr++) = y; 1117 } 1118 1119 } 1120 1121 1122 #endif 1123 1124 1125 /* Update the window shape */ 1126 pChVars[ch]->wnd_shape_prev_bk = pChVars[ch]->wnd_shape_this_bk; 1127 1128 } /* end for() */ 1129 1130 1131 /* 1132 * Copy to the final output buffer, taking into account the desired 1133 * channels from the calling environment, the actual channels, and 1134 * whether the data should be interleaved or not. 1135 * 1136 * If the stream had only one channel, write_output will not use 1137 * the right channel data. 1138 * 1139 */ 1140 1141 1142 /* CONSIDER USE OF DMA OPTIMIZATIONS WITHIN THE write_output FUNCTION. 1143 * 1144 * It is presumed that the ltp_buffer will reside in internal (fast) 1145 * memory, while the pExt->pOutputBuffer will reside in external 1146 * (slow) memory. 1147 * 1148 */ 1149 1150 1151 #ifdef AAC_PLUS 1152 1153 if (sbrBitStream->NrElements || pMC_Info->upsamplingFactor == 2) 1154 { 1155 1156 if (pVars->bno <= 1) /* allows console to operate with ADIF and audio config */ 1157 { 1158 if (sbrDec->outSampleRate == 0) /* do it only once (disregarding of signaling type) */ 1159 { 1160 sbr_open(samp_rate_info[pVars->mc_info.sampling_rate_idx].samp_rate, 1161 sbrDec, 1162 sbrDecoderData, 1163 pVars->mc_info.bDownSampledSbr); 1164 } 1165 1166 } 1167 pMC_Info->upsamplingFactor = 1168 sbrDecoderData->SbrChannel[0].frameData.sbr_header.sampleRateMode; 1169 1170 1171 /* reuse right aac spectrum channel */ 1172 { 1173 Int16 *pt_left = &(pChVars[LEFT ]->ltp_buffer[pVars->ltp_buffer_state]); 1174 Int16 *pt_right = &(pChVars[RIGHT]->ltp_buffer[pVars->ltp_buffer_state]); 1175 1176 if (sbr_applied(sbrDecoderData, 1177 sbrBitStream, 1178 pt_left, 1179 pt_right, 1180 pExt->pOutputBuffer, 1181 sbrDec, 1182 pVars, 1183 pMC_Info->nch) != SBRDEC_OK) 1184 { 1185 status = MP4AUDEC_INVALID_FRAME; 1186 } 1187 } 1188 1189 1190 } /* if( pExt->aacPlusEnabled == FALSE) */ 1191 #endif 1192 1193 /* 1194 * Copied mono data in both channels or just leave it as mono, 1195 * according with desiredChannels (default is 2) 1196 */ 1197 1198 if (pExt->desiredChannels == 2) 1199 { 1200 1201 #if defined(AAC_PLUS) 1202 #if defined(PARAMETRICSTEREO)&&defined(HQ_SBR) 1203 if (pMC_Info->nch != 2 && pMC_Info->psPresentFlag != 1) 1204 #else 1205 if (pMC_Info->nch != 2) 1206 #endif 1207 #else 1208 if (pMC_Info->nch != 2) 1209 #endif 1210 { 1211 /* mono */ 1212 1213 1214 Int16 * pt = &pExt->pOutputBuffer[0]; 1215 Int16 * pt2 = &pExt->pOutputBuffer[1]; 1216 Int i; 1217 if (pMC_Info->upsamplingFactor == 2) 1218 { 1219 for (i = 0; i < 1024; i++) 1220 { 1221 *pt2 = *pt; 1222 pt += 2; 1223 pt2 += 2; 1224 } 1225 pt = &pExt->pOutputBuffer_plus[0]; 1226 pt2 = &pExt->pOutputBuffer_plus[1]; 1227 1228 for (i = 0; i < 1024; i++) 1229 { 1230 *pt2 = *pt; 1231 pt += 2; 1232 pt2 += 2; 1233 } 1234 } 1235 else 1236 { 1237 for (i = 0; i < 1024; i++) 1238 { 1239 *pt2 = *pt; 1240 pt += 2; 1241 pt2 += 2; 1242 } 1243 } 1244 1245 } 1246 1247 #if defined(AAC_PLUS) 1248 #if defined(PARAMETRICSTEREO)&&defined(HQ_SBR) 1249 1250 else if (pMC_Info->psPresentFlag == 1) 1251 { 1252 Int32 frameSize = 0; 1253 if (pExt->aacPlusEnabled == false) 1254 { 1255 /* 1256 * Decoding eaac+ when only aac is enabled, copy L into R 1257 */ 1258 frameSize = 1024; 1259 } 1260 else if (sbrDecoderData->SbrChannel[0].syncState != SBR_ACTIVE) 1261 { 1262 /* 1263 * Decoding eaac+ when no PS data was found, copy upsampled L into R 1264 */ 1265 frameSize = 2048; 1266 } 1267 1268 Int16 * pt = &pExt->pOutputBuffer[0]; 1269 Int16 * pt2 = &pExt->pOutputBuffer[1]; 1270 Int i; 1271 for (i = 0; i < frameSize; i++) 1272 { 1273 *pt2 = *pt; 1274 pt += 2; 1275 pt2 += 2; 1276 } 1277 } 1278 #endif 1279 #endif 1280 1281 } 1282 else 1283 { 1284 1285 #if defined(AAC_PLUS) 1286 #if defined(PARAMETRICSTEREO)&&defined(HQ_SBR) 1287 if (pMC_Info->nch != 2 && pMC_Info->psPresentFlag != 1) 1288 #else 1289 if (pMC_Info->nch != 2) 1290 #endif 1291 #else 1292 if (pMC_Info->nch != 2) 1293 #endif 1294 { 1295 /* mono */ 1296 Int16 * pt = &pExt->pOutputBuffer[0]; 1297 Int16 * pt2 = &pExt->pOutputBuffer[0]; 1298 Int i; 1299 1300 if (pMC_Info->upsamplingFactor == 2) 1301 { 1302 for (i = 0; i < 1024; i++) 1303 { 1304 *pt2++ = *pt; 1305 pt += 2; 1306 } 1307 1308 pt = &pExt->pOutputBuffer_plus[0]; 1309 pt2 = &pExt->pOutputBuffer_plus[0]; 1310 1311 for (i = 0; i < 1024; i++) 1312 { 1313 *pt2++ = *pt; 1314 pt += 2; 1315 } 1316 } 1317 else 1318 { 1319 for (i = 0; i < 1024; i++) 1320 { 1321 *pt2++ = *pt; 1322 pt += 2; 1323 } 1324 } 1325 1326 } 1327 1328 } 1329 1330 1331 1332 1333 /* pVars->ltp_buffer_state cycles between 0 and 1024. The value 1334 * indicates the location of the data corresponding to t == -2. 1335 * 1336 * | t == -2 | t == -1 | pVars->ltp_buffer_state == 0 1337 * 1338 * | t == -1 | t == -2 | pVars->ltp_buffer_state == 1024 1339 * 1340 */ 1341 1342 #ifdef AAC_PLUS 1343 if (sbrBitStream->NrElements == 0 && pMC_Info->upsamplingFactor == 1) 1344 { 1345 pVars->ltp_buffer_state ^= frameLength; 1346 } 1347 else 1348 { 1349 pVars->ltp_buffer_state ^= (frameLength + 288); 1350 } 1351 #else 1352 pVars->ltp_buffer_state ^= frameLength; 1353 #endif 1354 1355 1356 if (pVars->bno <= 1) 1357 { 1358 /* 1359 * to set these values only during the second call 1360 * when they change. 1361 */ 1362 pExt->samplingRate = 1363 samp_rate_info[pVars->mc_info.sampling_rate_idx].samp_rate; 1364 1365 pVars->mc_info.implicit_channeling = 0; /* disable flag, as this is allowed 1366 * only the first time 1367 */ 1368 1369 1370 #ifdef AAC_PLUS 1371 1372 if (pMC_Info->upsamplingFactor == 2) 1373 { 1374 pExt->samplingRate *= pMC_Info->upsamplingFactor; 1375 pExt->aacPlusUpsamplingFactor = pMC_Info->upsamplingFactor; 1376 } 1377 1378 #endif 1379 1380 pExt->extendedAudioObjectType = pMC_Info->ExtendedAudioObjectType; 1381 pExt->audioObjectType = pMC_Info->audioObjectType; 1382 1383 pExt->encodedChannels = pMC_Info->nch; 1384 pExt->frameLength = pVars->frameLength; 1385 } 1386 1387 pVars->bno++; 1388 1389 1390 /* 1391 * Using unit analysis, the bitrate is a function of the sampling rate, bits, 1392 * points in a frame 1393 * 1394 * bits samples frame 1395 * ---- = --------- * bits * ------- 1396 * sec sec sample 1397 * 1398 * To save a divide, a shift is used. Presently only the value of 1399 * 1024 is used by this library, so make it the most accurate for that 1400 * value. This may need to be updated later. 1401 */ 1402 1403 pExt->bitRate = (pExt->samplingRate * 1404 (pVars->inputStream.usedBits - initialUsedBits)) >> 10; /* LONG_WINDOW 1024 */ 1405 1406 pExt->bitRate >>= (pMC_Info->upsamplingFactor - 1); 1407 1408 1409 } /* end if (status == SUCCESS) */ 1410 1411 1412 if (status != MP4AUDEC_SUCCESS) 1413 { 1414 /* 1415 * A non-SUCCESS decoding could be due to an error on the bitstream or 1416 * an incomplete frame. As access to the bitstream beyond frame boundaries 1417 * are not allowed, in those cases the bitstream reading routine return a 0 1418 * Zero values guarantees that the data structures are filled in with values 1419 * that eventually will signal an error (like invalid parameters) or that allow 1420 * completion of the parsing routine. Either way, the partial frame condition 1421 * is verified at this time. 1422 */ 1423 if (pVars->prog_config.file_is_adts == TRUE) 1424 { 1425 status = MP4AUDEC_LOST_FRAME_SYNC; 1426 pVars->prog_config.headerless_frames = 0; /* synchronization forced */ 1427 } 1428 else 1429 { 1430 /* 1431 * Check if the decoding error was due to buffer overrun, if it was, 1432 * update status 1433 */ 1434 if (pVars->inputStream.usedBits > pVars->inputStream.availableBits) 1435 { 1436 /* all bits were used but were not enough to complete decoding */ 1437 pVars->inputStream.usedBits = pVars->inputStream.availableBits; 1438 1439 status = MP4AUDEC_INCOMPLETE_FRAME; /* possible EOF or fractional frame */ 1440 } 1441 } 1442 } 1443 1444 /* 1445 * Translate from units of bits back into units of words. 1446 */ 1447 1448 pExt->inputBufferUsedLength = 1449 pVars->inputStream.usedBits >> INBUF_ARRAY_INDEX_SHIFT; 1450 1451 pExt->remainderBits = (Int)(pVars->inputStream.usedBits & INBUF_BIT_MODULO_MASK); 1452 1453 1454 1455 return (status); 1456 1457 } /* PVMP4AudioDecoderDecodeFrame */ 1458 1459
