1 /* 2 ** Copyright 2003-2010, VisualOn, Inc. 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 express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 /******************************************************************************* 17 File: qc_main.c 18 19 Content: Quantizing & coding functions 20 21 *******************************************************************************/ 22 23 #include "basic_op.h" 24 #include "oper_32b.h" 25 #include "qc_main.h" 26 #include "quantize.h" 27 #include "interface.h" 28 #include "adj_thr.h" 29 #include "sf_estim.h" 30 #include "stat_bits.h" 31 #include "bit_cnt.h" 32 #include "dyn_bits.h" 33 #include "channel_map.h" 34 #include "memalign.h" 35 36 37 typedef enum{ 38 FRAME_LEN_BYTES_MODULO = 1, 39 FRAME_LEN_BYTES_INT = 2 40 }FRAME_LEN_RESULT_MODE; 41 42 static const Word16 maxFillElemBits = 7 + 270*8; 43 44 /* forward declarations */ 45 46 static Word16 calcMaxValueInSfb(Word16 sfbCnt, 47 Word16 maxSfbPerGroup, 48 Word16 sfbPerGroup, 49 Word16 sfbOffset[MAX_GROUPED_SFB], 50 Word16 quantSpectrum[FRAME_LEN_LONG], 51 UWord16 maxValue[MAX_GROUPED_SFB]); 52 53 54 /***************************************************************************** 55 * 56 * function name: calcFrameLen 57 * description: estimate the frame length according the bitrates 58 * 59 *****************************************************************************/ 60 static Word16 calcFrameLen(Word32 bitRate, 61 Word32 sampleRate, 62 FRAME_LEN_RESULT_MODE mode) 63 { 64 65 Word32 result; 66 Word32 quot; 67 68 result = (FRAME_LEN_LONG >> 3) * bitRate; 69 quot = result / sampleRate; 70 71 72 if (mode == FRAME_LEN_BYTES_MODULO) { 73 result -= quot * sampleRate; 74 } 75 else { /* FRAME_LEN_BYTES_INT */ 76 result = quot; 77 } 78 79 return result; 80 } 81 82 /***************************************************************************** 83 * 84 * function name:framePadding 85 * description: Calculates if padding is needed for actual frame 86 * returns: paddingOn or not 87 * 88 *****************************************************************************/ 89 static Word16 framePadding(Word32 bitRate, 90 Word32 sampleRate, 91 Word32 *paddingRest) 92 { 93 Word16 paddingOn; 94 Word16 difference; 95 96 paddingOn = 0; 97 98 difference = calcFrameLen( bitRate, 99 sampleRate, 100 FRAME_LEN_BYTES_MODULO ); 101 *paddingRest = *paddingRest - difference; 102 103 104 if (*paddingRest <= 0 ) { 105 paddingOn = 1; 106 *paddingRest = *paddingRest + sampleRate; 107 } 108 109 return paddingOn; 110 } 111 112 113 /********************************************************************************* 114 * 115 * function name: QCOutNew 116 * description: init qcout parameter 117 * returns: 0 if success 118 * 119 **********************************************************************************/ 120 121 Word16 QCOutNew(QC_OUT *hQC, Word16 nChannels, VO_MEM_OPERATOR *pMemOP) 122 { 123 Word32 i; 124 Word16 *quantSpec; 125 Word16 *scf; 126 UWord16 *maxValueInSfb; 127 128 quantSpec = (Word16 *)mem_malloc(pMemOP, nChannels * FRAME_LEN_LONG * sizeof(Word16), 32, VO_INDEX_ENC_AAC); 129 if(NULL == quantSpec) 130 return 1; 131 scf = (Word16 *)mem_malloc(pMemOP, nChannels * MAX_GROUPED_SFB * sizeof(Word16), 32, VO_INDEX_ENC_AAC); 132 if(NULL == scf) 133 { 134 return 1; 135 } 136 maxValueInSfb = (UWord16 *)mem_malloc(pMemOP, nChannels * MAX_GROUPED_SFB * sizeof(UWord16), 32, VO_INDEX_ENC_AAC); 137 if(NULL == maxValueInSfb) 138 { 139 return 1; 140 } 141 142 for (i=0; i<nChannels; i++) { 143 hQC->qcChannel[i].quantSpec = quantSpec + i*FRAME_LEN_LONG; 144 145 hQC->qcChannel[i].maxValueInSfb = maxValueInSfb + i*MAX_GROUPED_SFB; 146 147 hQC->qcChannel[i].scf = scf + i*MAX_GROUPED_SFB; 148 } 149 150 return 0; 151 } 152 153 154 /********************************************************************************* 155 * 156 * function name: QCOutDelete 157 * description: unint qcout parameter 158 * returns: 0 if success 159 * 160 **********************************************************************************/ 161 void QCOutDelete(QC_OUT* hQC, VO_MEM_OPERATOR *pMemOP) 162 { 163 Word32 i; 164 if(hQC) 165 { 166 if(hQC->qcChannel[0].quantSpec) 167 mem_free(pMemOP, hQC->qcChannel[0].quantSpec, VO_INDEX_ENC_AAC); 168 169 if(hQC->qcChannel[0].maxValueInSfb) 170 mem_free(pMemOP, hQC->qcChannel[0].maxValueInSfb, VO_INDEX_ENC_AAC); 171 172 if(hQC->qcChannel[0].scf) 173 mem_free(pMemOP, hQC->qcChannel[0].scf, VO_INDEX_ENC_AAC); 174 175 for (i=0; i<MAX_CHANNELS; i++) { 176 hQC->qcChannel[i].quantSpec = NULL; 177 178 hQC->qcChannel[i].maxValueInSfb = NULL; 179 180 hQC->qcChannel[i].scf = NULL; 181 } 182 } 183 } 184 185 /********************************************************************************* 186 * 187 * function name: QCNew 188 * description: set QC to zero 189 * returns: 0 if success 190 * 191 **********************************************************************************/ 192 Word16 QCNew(QC_STATE *hQC, VO_MEM_OPERATOR *pMemOP) 193 { 194 pMemOP->Set(VO_INDEX_ENC_AAC, hQC,0,sizeof(QC_STATE)); 195 196 return (0); 197 } 198 199 /********************************************************************************* 200 * 201 * function name: QCDelete 202 * description: unint qcout parameter 203 * 204 **********************************************************************************/ 205 void QCDelete(QC_STATE *hQC, VO_MEM_OPERATOR *pMemOP) 206 { 207 208 /* 209 nothing to do 210 */ 211 hQC=NULL; 212 } 213 214 /********************************************************************************* 215 * 216 * function name: QCInit 217 * description: init QD parameter 218 * returns: 0 if success 219 * 220 **********************************************************************************/ 221 Word16 QCInit(QC_STATE *hQC, 222 struct QC_INIT *init) 223 { 224 hQC->nChannels = init->elInfo->nChannelsInEl; 225 hQC->maxBitsTot = init->maxBits; 226 hQC->bitResTot = sub(init->bitRes, init->averageBits); 227 hQC->averageBitsTot = init->averageBits; 228 hQC->maxBitFac = init->maxBitFac; 229 230 hQC->padding.paddingRest = init->padding.paddingRest; 231 232 hQC->globStatBits = 3; /* for ID_END */ 233 234 /* channel elements init */ 235 InitElementBits(&hQC->elementBits, 236 *init->elInfo, 237 init->bitrate, 238 init->averageBits, 239 hQC->globStatBits); 240 241 /* threshold parameter init */ 242 AdjThrInit(&hQC->adjThr, 243 init->meanPe, 244 hQC->elementBits.chBitrate); 245 246 return 0; 247 } 248 249 250 /********************************************************************************* 251 * 252 * function name: QCMain 253 * description: quantization and coding the spectrum 254 * returns: 0 if success 255 * 256 **********************************************************************************/ 257 Word16 QCMain(QC_STATE* hQC, 258 ELEMENT_BITS* elBits, 259 ATS_ELEMENT* adjThrStateElement, 260 PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS], /* may be modified in-place */ 261 PSY_OUT_ELEMENT* psyOutElement, 262 QC_OUT_CHANNEL qcOutChannel[MAX_CHANNELS], /* out */ 263 QC_OUT_ELEMENT* qcOutElement, 264 Word16 nChannels, 265 Word16 ancillaryDataBytes) 266 { 267 Word16 maxChDynBits[MAX_CHANNELS]; 268 Word16 chBitDistribution[MAX_CHANNELS]; 269 Word32 ch; 270 271 if (elBits->bitResLevel < 0) { 272 return -1; 273 } 274 275 if (elBits->bitResLevel > elBits->maxBitResBits) { 276 return -1; 277 } 278 279 qcOutElement->staticBitsUsed = countStaticBitdemand(psyOutChannel, 280 psyOutElement, 281 nChannels, 282 qcOutElement->adtsUsed); 283 284 285 if (ancillaryDataBytes) { 286 qcOutElement->ancBitsUsed = 7 + (ancillaryDataBytes << 3); 287 288 if (ancillaryDataBytes >= 15) 289 qcOutElement->ancBitsUsed = qcOutElement->ancBitsUsed + 8; 290 } 291 else { 292 qcOutElement->ancBitsUsed = 0; 293 } 294 295 CalcFormFactor(hQC->logSfbFormFactor, hQC->sfbNRelevantLines, hQC->logSfbEnergy, psyOutChannel, nChannels); 296 297 /*adjust thresholds for the desired bitrate */ 298 AdjustThresholds(&hQC->adjThr, 299 adjThrStateElement, 300 psyOutChannel, 301 psyOutElement, 302 chBitDistribution, 303 hQC->logSfbEnergy, 304 hQC->sfbNRelevantLines, 305 qcOutElement, 306 elBits, 307 nChannels, 308 hQC->maxBitFac); 309 310 /*estimate scale factors */ 311 EstimateScaleFactors(psyOutChannel, 312 qcOutChannel, 313 hQC->logSfbEnergy, 314 hQC->logSfbFormFactor, 315 hQC->sfbNRelevantLines, 316 nChannels); 317 318 /* condition to prevent empty bitreservoir */ 319 for (ch = 0; ch < nChannels; ch++) { 320 Word32 maxDynBits; 321 maxDynBits = elBits->averageBits + elBits->bitResLevel - 7; /* -7 bec. of align bits */ 322 maxDynBits = maxDynBits - qcOutElement->staticBitsUsed + qcOutElement->ancBitsUsed; 323 maxChDynBits[ch] = extract_l(chBitDistribution[ch] * maxDynBits / 1000); 324 } 325 326 qcOutElement->dynBitsUsed = 0; 327 for (ch = 0; ch < nChannels; ch++) { 328 Word32 chDynBits; 329 Flag constraintsFulfilled; 330 Word32 iter; 331 iter = 0; 332 do { 333 constraintsFulfilled = 1; 334 335 QuantizeSpectrum(psyOutChannel[ch].sfbCnt, 336 psyOutChannel[ch].maxSfbPerGroup, 337 psyOutChannel[ch].sfbPerGroup, 338 psyOutChannel[ch].sfbOffsets, 339 psyOutChannel[ch].mdctSpectrum, 340 qcOutChannel[ch].globalGain, 341 qcOutChannel[ch].scf, 342 qcOutChannel[ch].quantSpec); 343 344 if (calcMaxValueInSfb(psyOutChannel[ch].sfbCnt, 345 psyOutChannel[ch].maxSfbPerGroup, 346 psyOutChannel[ch].sfbPerGroup, 347 psyOutChannel[ch].sfbOffsets, 348 qcOutChannel[ch].quantSpec, 349 qcOutChannel[ch].maxValueInSfb) > MAX_QUANT) { 350 constraintsFulfilled = 0; 351 } 352 353 chDynBits = dynBitCount(qcOutChannel[ch].quantSpec, 354 qcOutChannel[ch].maxValueInSfb, 355 qcOutChannel[ch].scf, 356 psyOutChannel[ch].windowSequence, 357 psyOutChannel[ch].sfbCnt, 358 psyOutChannel[ch].maxSfbPerGroup, 359 psyOutChannel[ch].sfbPerGroup, 360 psyOutChannel[ch].sfbOffsets, 361 &qcOutChannel[ch].sectionData); 362 363 if (chDynBits >= maxChDynBits[ch]) { 364 constraintsFulfilled = 0; 365 } 366 367 if (!constraintsFulfilled) { 368 qcOutChannel[ch].globalGain = qcOutChannel[ch].globalGain + 1; 369 } 370 371 iter = iter + 1; 372 373 } while(!constraintsFulfilled); 374 375 qcOutElement->dynBitsUsed = qcOutElement->dynBitsUsed + chDynBits; 376 377 qcOutChannel[ch].mdctScale = psyOutChannel[ch].mdctScale; 378 qcOutChannel[ch].groupingMask = psyOutChannel[ch].groupingMask; 379 qcOutChannel[ch].windowShape = psyOutChannel[ch].windowShape; 380 } 381 382 /* save dynBitsUsed for correction of bits2pe relation */ 383 AdjThrUpdate(adjThrStateElement, qcOutElement->dynBitsUsed); 384 385 { 386 Word16 bitResSpace = elBits->maxBitResBits - elBits->bitResLevel; 387 Word16 deltaBitRes = elBits->averageBits - 388 (qcOutElement->staticBitsUsed + 389 qcOutElement->dynBitsUsed + qcOutElement->ancBitsUsed); 390 391 qcOutElement->fillBits = max(0, (deltaBitRes - bitResSpace)); 392 } 393 394 return 0; /* OK */ 395 } 396 397 398 /********************************************************************************* 399 * 400 * function name: calcMaxValueInSfb 401 * description: search the max Spectrum in one sfb 402 * 403 **********************************************************************************/ 404 static Word16 calcMaxValueInSfb(Word16 sfbCnt, 405 Word16 maxSfbPerGroup, 406 Word16 sfbPerGroup, 407 Word16 sfbOffset[MAX_GROUPED_SFB], 408 Word16 quantSpectrum[FRAME_LEN_LONG], 409 UWord16 maxValue[MAX_GROUPED_SFB]) 410 { 411 Word16 sfbOffs, sfb; 412 Word16 maxValueAll; 413 414 maxValueAll = 0; 415 416 for(sfbOffs=0;sfbOffs<sfbCnt;sfbOffs+=sfbPerGroup) { 417 for (sfb = 0; sfb < maxSfbPerGroup; sfb++) { 418 Word16 line; 419 Word16 maxThisSfb; 420 maxThisSfb = 0; 421 422 for (line = sfbOffset[sfbOffs+sfb]; line < sfbOffset[sfbOffs+sfb+1]; line++) { 423 Word16 absVal; 424 absVal = abs_s(quantSpectrum[line]); 425 maxThisSfb = max(maxThisSfb, absVal); 426 } 427 428 maxValue[sfbOffs+sfb] = maxThisSfb; 429 maxValueAll = max(maxValueAll, maxThisSfb); 430 } 431 } 432 return maxValueAll; 433 } 434 435 436 /********************************************************************************* 437 * 438 * function name: updateBitres 439 * description: update bitreservoir 440 * 441 **********************************************************************************/ 442 void updateBitres(QC_STATE* qcKernel, 443 QC_OUT* qcOut) 444 445 { 446 ELEMENT_BITS *elBits; 447 448 qcKernel->bitResTot = 0; 449 450 elBits = &qcKernel->elementBits; 451 452 453 if (elBits->averageBits > 0) { 454 /* constant bitrate */ 455 Word16 bitsUsed; 456 bitsUsed = (qcOut->qcElement.staticBitsUsed + qcOut->qcElement.dynBitsUsed) + 457 (qcOut->qcElement.ancBitsUsed + qcOut->qcElement.fillBits); 458 elBits->bitResLevel = elBits->bitResLevel + (elBits->averageBits - bitsUsed); 459 qcKernel->bitResTot = qcKernel->bitResTot + elBits->bitResLevel; 460 } 461 else { 462 /* variable bitrate */ 463 elBits->bitResLevel = elBits->maxBits; 464 qcKernel->bitResTot = qcKernel->maxBitsTot; 465 } 466 } 467 468 /********************************************************************************* 469 * 470 * function name: FinalizeBitConsumption 471 * description: count bits used 472 * 473 **********************************************************************************/ 474 Word16 FinalizeBitConsumption(QC_STATE *qcKernel, 475 QC_OUT* qcOut) 476 { 477 Word32 nFullFillElem; 478 Word32 totFillBits; 479 Word16 diffBits; 480 Word16 bitsUsed; 481 482 totFillBits = 0; 483 484 qcOut->totStaticBitsUsed = qcKernel->globStatBits; 485 qcOut->totStaticBitsUsed += qcOut->qcElement.staticBitsUsed; 486 qcOut->totDynBitsUsed = qcOut->qcElement.dynBitsUsed; 487 qcOut->totAncBitsUsed = qcOut->qcElement.ancBitsUsed; 488 qcOut->totFillBits = qcOut->qcElement.fillBits; 489 490 if (qcOut->qcElement.fillBits) { 491 totFillBits += qcOut->qcElement.fillBits; 492 } 493 494 nFullFillElem = (max((qcOut->totFillBits - 1), 0) / maxFillElemBits) * maxFillElemBits; 495 496 qcOut->totFillBits = qcOut->totFillBits - nFullFillElem; 497 498 /* check fill elements */ 499 500 if (qcOut->totFillBits > 0) { 501 /* minimum Fillelement contains 7 (TAG + byte cnt) bits */ 502 qcOut->totFillBits = max(7, qcOut->totFillBits); 503 /* fill element size equals n*8 + 7 */ 504 qcOut->totFillBits = qcOut->totFillBits + ((8 - ((qcOut->totFillBits - 7) & 0x0007)) & 0x0007); 505 } 506 507 qcOut->totFillBits = qcOut->totFillBits + nFullFillElem; 508 509 /* now distribute extra fillbits and alignbits over channel elements */ 510 qcOut->alignBits = 7 - ((qcOut->totDynBitsUsed + qcOut->totStaticBitsUsed + 511 qcOut->totAncBitsUsed + qcOut->totFillBits - 1) & 0x0007); 512 513 514 if ( (qcOut->alignBits + qcOut->totFillBits - totFillBits == 8) && 515 (qcOut->totFillBits > 8)) 516 qcOut->totFillBits = qcOut->totFillBits - 8; 517 518 519 diffBits = qcOut->alignBits + qcOut->totFillBits - totFillBits; 520 521 if(diffBits>=0) { 522 qcOut->qcElement.fillBits += diffBits; 523 } 524 525 bitsUsed = qcOut->totDynBitsUsed + qcOut->totStaticBitsUsed + qcOut->totAncBitsUsed; 526 bitsUsed = bitsUsed + qcOut->totFillBits + qcOut->alignBits; 527 528 if (bitsUsed > qcKernel->maxBitsTot) { 529 return -1; 530 } 531 return bitsUsed; 532 } 533 534 535 /********************************************************************************* 536 * 537 * function name: AdjustBitrate 538 * description: adjusts framelength via padding on a frame to frame basis, 539 * to achieve a bitrate that demands a non byte aligned 540 * framelength 541 * return: errorcode 542 * 543 **********************************************************************************/ 544 Word16 AdjustBitrate(QC_STATE *hQC, 545 Word32 bitRate, /* total bitrate */ 546 Word32 sampleRate) /* output sampling rate */ 547 { 548 Word16 paddingOn; 549 Word16 frameLen; 550 Word16 codeBits; 551 Word16 codeBitsLast; 552 553 /* Do we need a extra padding byte? */ 554 paddingOn = framePadding(bitRate, 555 sampleRate, 556 &hQC->padding.paddingRest); 557 558 /* frame length */ 559 frameLen = paddingOn + calcFrameLen(bitRate, 560 sampleRate, 561 FRAME_LEN_BYTES_INT); 562 563 frameLen = frameLen << 3; 564 codeBitsLast = hQC->averageBitsTot - hQC->globStatBits; 565 codeBits = frameLen - hQC->globStatBits; 566 567 /* calculate bits for every channel element */ 568 if (codeBits != codeBitsLast) { 569 Word16 totalBits = 0; 570 571 hQC->elementBits.averageBits = (hQC->elementBits.relativeBits * codeBits) >> 16; /* relativeBits was scaled down by 2 */ 572 totalBits += hQC->elementBits.averageBits; 573 574 hQC->elementBits.averageBits = hQC->elementBits.averageBits + (codeBits - totalBits); 575 } 576 577 hQC->averageBitsTot = frameLen; 578 579 return 0; 580 } 581
