开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
bitstream.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：21k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

bitstream.c：源码内容
  1. /*
  2.  * FAAC - Freeware Advanced Audio Coder
  3.  * Copyright (C) 2001 Menno Bakker
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU Lesser General Public
  7.  * License as published by the Free Software Foundation; either
  8.  * version 2.1 of the License, or (at your option) any later version.
  9.  *
  10.  * This library is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  * Lesser General Public License for more details.
  15.  * You should have received a copy of the GNU Lesser General Public
  16.  * License along with this library; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  *
  19.  * $Id: bitstream.c,v 1.7 2002/02/25 22:26:43 dmackie Exp $
  20.  */
  22. #include <stdlib.h>
  23. #include <assert.h>
  25. #include "coder.h"
  26. #include "channels.h"
  27. #include "huffman.h"
  28. #include "bitstream.h"
  29. #include "ltp.h"
  30. #include "util.h"
  32. int WriteBitstream(faacEncHandle hEncoder,
  33.    CoderInfo *coderInfo,
  34.    ChannelInfo *channelInfo,
  35.    BitStream *bitStream,
  36.    int numChannel)
  37. {
  38. int channel;
  39. int bits = 0;
  40. int bitsLeftAfterFill, numFillBits;
  42. CountBitstream(hEncoder, coderInfo, channelInfo, bitStream, numChannel);
  44. bits += WriteADTSHeader(hEncoder, bitStream, 1);
  46. for (channel = 0; channel < numChannel; channel++) {
  48. if (channelInfo[channel].present) {
  50. /* Write out a single_channel_element */
  51. if (!channelInfo[channel].cpe) {
  53. if (channelInfo[channel].lfe) {
  54. /* Write out lfe */ 
  55. bits += WriteLFE(&coderInfo[channel],
  56. &channelInfo[channel],
  57. bitStream,
  58. hEncoder->config.aacObjectType,
  59. 1);
  60. } else {
  61. /* Write out sce */
  62. bits += WriteSCE(&coderInfo[channel],
  63. &channelInfo[channel],
  64. bitStream,
  65. hEncoder->config.aacObjectType,
  66. 1);
  67. }
  69. } else {
  71. if (channelInfo[channel].ch_is_left) {
  72. /* Write out cpe */
  73. bits += WriteCPE(&coderInfo[channel],
  74. &coderInfo[channelInfo[channel].paired_ch],
  75. &channelInfo[channel],
  76. bitStream,
  77. hEncoder->config.aacObjectType,
  78. 1);
  79. }
  80. }
  81. }
  82. }
  84. /* Compute how many fill bits are needed to avoid overflowing bit reservoir */
  85. /* Save room for ID_END terminator */
  86. if (bits < (8 - LEN_SE_ID) ) {
  87. numFillBits = 8 - LEN_SE_ID - bits;
  88. } else {
  89. numFillBits = 0;
  90. }
  92. /* Write AAC fill_elements, smallest fill element is 7 bits. */
  93. /* Function may leave up to 6 bits left after fill, so tell it to fill a few extra */
  94. numFillBits += 6;
  95. bitsLeftAfterFill = WriteAACFillBits(bitStream, numFillBits, 1);
  96. bits += (numFillBits - bitsLeftAfterFill);
  98. /* Write ID_END terminator */
  99. bits += LEN_SE_ID;
  100.     PutBit(bitStream, ID_END, LEN_SE_ID);
  102. /* Now byte align the bitstream */
  103. /*
  104.  * This byte_alignment() is correct for both MPEG2 and MPEG4, although
  105.  * in MPEG4 the byte_alignment() is officially done before the new frame
  106.  * instead of at the end. But this is basically the same.
  107.  */
  108. assert(bitStream->numBit==bits);
  109. bitStream->numBit=bits;
  110. #if 0
  111.     if (hEncoder->config.mpegVersion == 0)
  112.      bits += ByteAlign(bitStream, 1,2);
  113. #endif
  115. bits += ByteAlign(bitStream, 1,0);
  117. return bits;
  118. }
  120. static int CountBitstream(faacEncHandle hEncoder,
  121.   CoderInfo *coderInfo,
  122.   ChannelInfo *channelInfo,
  123.   BitStream *bitStream,
  124.   int numChannel)
  125. {
  126. int channel;
  127. int bits = 0;
  128. int bitsLeftAfterFill, numFillBits;
  130. bits += WriteADTSHeader(hEncoder, bitStream, 0);
  132. for (channel = 0; channel < numChannel; channel++) {
  134. if (channelInfo[channel].present) {
  136. /* Write out a single_channel_element */
  137. if (!channelInfo[channel].cpe) {
  139. if (channelInfo[channel].lfe) {
  140. /* Write out lfe */ 
  141. bits += WriteLFE(&coderInfo[channel],
  142. &channelInfo[channel],
  143. bitStream,
  144. hEncoder->config.aacObjectType,
  145. 0);
  146. } else {
  147. /* Write out sce */
  148. bits += WriteSCE(&coderInfo[channel],
  149. &channelInfo[channel],
  150. bitStream,
  151. hEncoder->config.aacObjectType,
  152. 0);
  153. }
  155. } else {
  157. if (channelInfo[channel].ch_is_left) {
  158. /* Write out cpe */
  159. bits += WriteCPE(&coderInfo[channel],
  160. &coderInfo[channelInfo[channel].paired_ch],
  161. &channelInfo[channel],
  162. bitStream,
  163. hEncoder->config.aacObjectType,
  164. 0);
  165. }
  166. }
  167. }
  168. }
  170. /* Compute how many fill bits are needed to avoid overflowing bit reservoir */
  171. /* Save room for ID_END terminator */
  172. if (bits < (8 - LEN_SE_ID) ) {
  173. numFillBits = 8 - LEN_SE_ID - bits;
  174. } else {
  175. numFillBits = 0;
  176. }
  178. /* Write AAC fill_elements, smallest fill element is 7 bits. */
  179. /* Function may leave up to 6 bits left after fill, so tell it to fill a few extra */
  180. numFillBits += 6;
  181. bitsLeftAfterFill = WriteAACFillBits(bitStream, numFillBits, 0);
  182. bits += (numFillBits - bitsLeftAfterFill);
  184. /* Write ID_END terminator */
  185. bits += LEN_SE_ID;
  187. /* Now byte align the bitstream */
  189. bitStream->numBit=bits;
  190. #if 0
  191.     if (hEncoder->config.mpegVersion == 0)
  192. bits += ByteAlign(bitStream, 0,2);
  193.     #endif
  195. bits += ByteAlign(bitStream, 0,0);
  197. hEncoder->usedBytes = bit2byte(bits);
  199. return bits;
  200. }
  202. static int WriteADTSHeader(faacEncHandle hEncoder,
  203.    BitStream *bitStream,
  204.    int writeFlag)
  205. {
  206. int bits = 56;
  208. #ifdef MPEG4IP
  209. if (hEncoder->config.useAdts == 0) {
  210. return 0;
  211. }
  212. #endif
  214. if (writeFlag) {
  215. /* Fixed ADTS header */
  216. PutBit(bitStream, 0xFFFF, 12); /* 12 bit Syncword */
  217. PutBit(bitStream, hEncoder->config.mpegVersion, 1); /* ID == 0 for MPEG4 AAC, 1 for MPEG2 AAC */
  218. PutBit(bitStream, 0, 2); /* layer == 0 */
  219. PutBit(bitStream, 1, 1); /* protection absent */
  220. PutBit(bitStream, hEncoder->config.aacObjectType, 2); /* profile */
  221. PutBit(bitStream, hEncoder->sampleRateIdx, 4); /* sampling rate */
  222. PutBit(bitStream, 0, 1); /* private bit */
  223. PutBit(bitStream, hEncoder->numChannels, 3); /* ch. config (must be > 0) */
  224.  /* simply using numChannels only works for
  225. 6 channels or less, else a channel
  226. configuration should be written */
  227. PutBit(bitStream, 0, 1); /* original/copy */
  228. PutBit(bitStream, 0, 1); /* home */
  229. if (hEncoder->config.mpegVersion == 0)
  230. PutBit(bitStream, 0, 2); /* emphasis */
  232. /* Variable ADTS header */
  233. PutBit(bitStream, 0, 1); /* copyr. id. bit */
  234. PutBit(bitStream, 0, 1); /* copyr. id. start */
  235. PutBit(bitStream, hEncoder->usedBytes, 13);
  236. PutBit(bitStream, 0x7FF, 11); /* buffer fullness (0x7FF for VBR) */
  237. PutBit(bitStream, 0, 2); /* raw data blocks (0+1=1) */
  239. }
  241. /*
  242.  * MPEG2 says byte_aligment() here, but ADTS always is multiple of 8 bits
  243.  * MPEG4 has no byte_alignment() here
  244.  */
  245. /*
  246. if (hEncoder->config.mpegVersion == 1)
  247. bits += ByteAlign(bitStream, writeFlag);
  248. */
  250. if (hEncoder->config.mpegVersion == 0)
  251. bits += 2; /* emphasis */
  253. return bits;
  254. }
  256. static int WriteCPE(CoderInfo *coderInfoL,
  257. CoderInfo *coderInfoR,
  258. ChannelInfo *channelInfo,
  259. BitStream* bitStream,
  260. int objectType,
  261. int writeFlag)
  262. {
  263. int bits = 0;
  265. if (writeFlag) {
  266. /* write ID_CPE, single_element_channel() identifier */
  267. PutBit(bitStream, ID_CPE, LEN_SE_ID);
  269. /* write the element_identifier_tag */
  270. PutBit(bitStream, channelInfo->tag, LEN_TAG);
  272. /* common_window? */
  273. PutBit(bitStream, channelInfo->common_window, LEN_COM_WIN);
  274. }
  276. bits += LEN_SE_ID;
  277. bits += LEN_TAG;
  278. bits += LEN_COM_WIN;
  280. /* if common_window, write ics_info */
  281. if (channelInfo->common_window) {
  282. int numWindows, maxSfb;
  284. bits += WriteICSInfo(coderInfoL, bitStream, objectType, writeFlag);
  285. numWindows = coderInfoL->num_window_groups;
  286. maxSfb = coderInfoL->max_sfb;
  288. if (writeFlag) {
  289. PutBit(bitStream, channelInfo->msInfo.is_present, LEN_MASK_PRES);
  290. if (channelInfo->msInfo.is_present == 1) {
  291. int g;
  292. int b;
  293. for (g=0;g<numWindows;g++) {
  294. for (b=0;b<maxSfb;b++) {
  295. PutBit(bitStream, channelInfo->msInfo.ms_used[g*maxSfb+b], LEN_MASK);
  296. }
  297. }
  298. }
  299. }
  300. bits += LEN_MASK_PRES;
  301. if (channelInfo->msInfo.is_present == 1)
  302. bits += (numWindows*maxSfb*LEN_MASK);
  303. }
  305. /* Write individual_channel_stream elements */
  306. bits += WriteICS(coderInfoL, bitStream, channelInfo->common_window, objectType, writeFlag);
  307. bits += WriteICS(coderInfoR, bitStream, channelInfo->common_window, objectType, writeFlag);
  309. return bits;
  310. }
  312. static int WriteSCE(CoderInfo *coderInfo,
  313. ChannelInfo *channelInfo,
  314. BitStream *bitStream,
  315. int objectType,
  316. int writeFlag)
  317. {
  318. int bits = 0;
  320. if (writeFlag) {
  321. /* write Single Element Channel (SCE) identifier */
  322. PutBit(bitStream, ID_SCE, LEN_SE_ID);
  324. /* write the element identifier tag */
  325. PutBit(bitStream, channelInfo->tag, LEN_TAG);
  326. }
  328. bits += LEN_SE_ID;
  329. bits += LEN_TAG;
  331. /* Write an Individual Channel Stream element */
  332. bits += WriteICS(coderInfo, bitStream, 0, objectType, writeFlag);
  334. return bits;
  335. }
  337. static int WriteLFE(CoderInfo *coderInfo,
  338. ChannelInfo *channelInfo,
  339. BitStream *bitStream,
  340. int objectType,
  341. int writeFlag)
  342. {
  343. int bits = 0;
  345. if (writeFlag) {
  346. /* write ID_LFE, lfe_element_channel() identifier */
  347. PutBit(bitStream, ID_LFE, LEN_SE_ID);
  349. /* write the element_identifier_tag */
  350. PutBit(bitStream, channelInfo->tag, LEN_TAG);
  351. }
  353. bits += LEN_SE_ID;
  354. bits += LEN_TAG;
  356. /* Write an individual_channel_stream element */
  357. bits += WriteICS(coderInfo, bitStream, 0, objectType, writeFlag);
  359. return bits;
  360. }
  362. static int WriteICSInfo(CoderInfo *coderInfo,
  363. BitStream *bitStream,
  364. int objectType,
  365. int writeFlag)
  366. {
  367. int grouping_bits;
  368. int bits = 0;
  370. if (writeFlag) {
  371. /* write out ics_info() information */
  372. PutBit(bitStream, 0, LEN_ICS_RESERV);  /* reserved Bit*/
  374. /* Write out window sequence */
  375. PutBit(bitStream, coderInfo->block_type, LEN_WIN_SEQ);  /* block type */
  377. /* Write out window shape */
  378. PutBit(bitStream, coderInfo->window_shape, LEN_WIN_SH);  /* window shape */
  379. }
  381. bits += LEN_ICS_RESERV;
  382. bits += LEN_WIN_SEQ;
  383. bits += LEN_WIN_SH;
  385. /* For short windows, write out max_sfb and scale_factor_grouping */
  386. if (coderInfo->block_type == ONLY_SHORT_WINDOW){
  387. if (writeFlag) {
  388. PutBit(bitStream, coderInfo->max_sfb, LEN_MAX_SFBS);
  389. grouping_bits = FindGroupingBits(coderInfo);
  390. PutBit(bitStream, grouping_bits, MAX_SHORT_WINDOWS - 1);  /* the grouping bits */
  391. }
  392. bits += LEN_MAX_SFBS;
  393. bits += MAX_SHORT_WINDOWS - 1;
  394. } else { /* Otherwise, write out max_sfb and predictor data */
  395. if (writeFlag) {
  396. PutBit(bitStream, coderInfo->max_sfb, LEN_MAX_SFBL);
  397. }
  398. bits += LEN_MAX_SFBL;
  399. if (objectType == LTP)
  400. bits += WriteLTPPredictorData(coderInfo, bitStream, writeFlag);
  401. else
  402. bits += WritePredictorData(coderInfo, bitStream, writeFlag);
  403. }
  405. return bits;
  406. }
  408. static int WriteICS(CoderInfo *coderInfo,
  409. BitStream *bitStream,
  410. int commonWindow,
  411. int objectType,
  412. int writeFlag)
  413. {
  414. /* this function writes out an individual_channel_stream to the bitstream and */
  415. /* returns the number of bits written to the bitstream */
  416. int bits = 0;
  418. /* Write the 8-bit global_gain */
  419. if (writeFlag)
  420. PutBit(bitStream, coderInfo->global_gain, LEN_GLOB_GAIN);
  421. bits += LEN_GLOB_GAIN;
  423. /* Write ics information */
  424. if (!commonWindow) {
  425. bits += WriteICSInfo(coderInfo, bitStream, objectType, writeFlag);
  426. }
  428. bits += SortBookNumbers(coderInfo, bitStream, writeFlag);
  429. bits += WriteScalefactors(coderInfo, bitStream, writeFlag);
  430. bits += WritePulseData(coderInfo, bitStream, writeFlag);
  431. bits += WriteTNSData(coderInfo, bitStream, writeFlag);
  432. bits += WriteGainControlData(coderInfo, bitStream, writeFlag);
  433. bits += WriteSpectralData(coderInfo, bitStream, writeFlag);
  435. /* Return number of bits */
  436. return bits;
  437. }
  439. static int WriteLTPPredictorData(CoderInfo *coderInfo, BitStream *bitStream, int writeFlag)
  440. {
  441. int i, last_band;
  442. int bits;
  443. LtpInfo *ltpInfo = &coderInfo->ltpInfo;
  445. bits = 1;
  447. if (ltpInfo->global_pred_flag)
  448. {
  449. if(writeFlag)
  450. PutBit(bitStream, 1, 1); /* LTP used */
  452. switch(coderInfo->block_type)
  453. {
  454. case ONLY_LONG_WINDOW:
  455. case LONG_SHORT_WINDOW:
  456. case SHORT_LONG_WINDOW:
  457. bits += LEN_LTP_LAG;
  458. bits += LEN_LTP_COEF;
  459. if(writeFlag)
  460. {
  461. PutBit(bitStream, ltpInfo->delay[0], LEN_LTP_LAG);
  462. PutBit(bitStream, ltpInfo->weight_idx,  LEN_LTP_COEF);
  463. }
  465. last_band = (coderInfo->nr_of_sfb < MAX_LT_PRED_LONG_SFB) ?
  466. coderInfo->nr_of_sfb : MAX_LT_PRED_LONG_SFB;
  468. bits += last_band;
  469. if(writeFlag)
  470. for (i = 0; i < last_band; i++)
  471. PutBit(bitStream, ltpInfo->sfb_prediction_used[i], LEN_LTP_LONG_USED);
  472. break;
  474. default:
  475. break;
  476. }
  477. } else {
  478. if(writeFlag)
  479. PutBit(bitStream, 0, 1); /* LTP not used */
  480. }
  482. return (bits);
  483. }
  485. static int WritePredictorData(CoderInfo *coderInfo,
  486.   BitStream *bitStream,
  487.   int writeFlag)
  488. {
  489. int bits = 0;
  491. /* Write global predictor data present */
  492. short predictorDataPresent = coderInfo->pred_global_flag;
  493. int numBands = min(coderInfo->max_pred_sfb, coderInfo->nr_of_sfb);
  495. if (writeFlag) {
  496. PutBit(bitStream, predictorDataPresent, LEN_PRED_PRES);  /* predictor_data_present */
  497. if (predictorDataPresent) {
  498. int b;
  499. if (coderInfo->reset_group_number == -1) {
  500. PutBit(bitStream, 0, LEN_PRED_RST); /* No prediction reset */
  501. } else {
  502. PutBit(bitStream, 1, LEN_PRED_RST);
  503. PutBit(bitStream, (unsigned long)coderInfo->reset_group_number,
  504. LEN_PRED_RSTGRP);
  505. }
  507. for (b=0;b<numBands;b++) {
  508. PutBit(bitStream, coderInfo->pred_sfb_flag[b], LEN_PRED_ENAB);
  509. }
  510. }
  511. }
  512. bits = LEN_PRED_PRES;
  513. bits += (predictorDataPresent) ?
  514. (LEN_PRED_RST + 
  515. ((coderInfo->reset_group_number)!=-1)*LEN_PRED_RSTGRP + 
  516. numBands*LEN_PRED_ENAB) : 0;
  518. return bits;
  519. }
  521. static int WritePulseData(CoderInfo *coderInfo,
  522.   BitStream *bitStream,
  523.   int writeFlag)
  524. {
  525. int bits = 0;
  527. if (writeFlag) {
  528. PutBit(bitStream, 0, LEN_PULSE_PRES);  /* no pulse_data_present */
  529. }
  531. bits += LEN_PULSE_PRES;
  533. return bits;
  534. }
  536. static int WriteTNSData(CoderInfo *coderInfo,
  537. BitStream *bitStream,
  538. int writeFlag)
  539. {
  540. int bits = 0;
  541. int numWindows;
  542. int len_tns_nfilt;
  543. int len_tns_length;
  544. int len_tns_order;
  545. int filtNumber;
  546. int resInBits;
  547. int bitsToTransmit;
  548. unsigned long unsignedIndex;
  549. int w;
  551. TnsInfo* tnsInfoPtr = &coderInfo->tnsInfo;
  553. if (writeFlag) {
  554. PutBit(bitStream,tnsInfoPtr->tnsDataPresent,LEN_TNS_PRES);
  555. }
  556. bits += LEN_TNS_PRES;
  558. /* If TNS is not present, bail */
  559. if (!tnsInfoPtr->tnsDataPresent) {
  560. return bits;
  561. }
  563. /* Set window-dependent TNS parameters */
  564. if (coderInfo->block_type == ONLY_SHORT_WINDOW) {
  565. numWindows = MAX_SHORT_WINDOWS;
  566. len_tns_nfilt = LEN_TNS_NFILTS;
  567. len_tns_length = LEN_TNS_LENGTHS;
  568. len_tns_order = LEN_TNS_ORDERS;
  569. }
  570. else {
  571. numWindows = 1;
  572. len_tns_nfilt = LEN_TNS_NFILTL;
  573. len_tns_length = LEN_TNS_LENGTHL;
  574. len_tns_order = LEN_TNS_ORDERL;
  575. }
  577. /* Write TNS data */
  578. bits += (numWindows * len_tns_nfilt);
  579. for (w=0;w<numWindows;w++) {
  580. TnsWindowData* windowDataPtr = &tnsInfoPtr->windowData[w];
  581. int numFilters = windowDataPtr->numFilters;
  582. if (writeFlag) {
  583. PutBit(bitStream,numFilters,len_tns_nfilt); /* n_filt[] = 0 */
  584. }
  585. if (numFilters) {
  586. bits += LEN_TNS_COEFF_RES;
  587. resInBits = windowDataPtr->coefResolution;
  588. if (writeFlag) {
  589. PutBit(bitStream,resInBits-DEF_TNS_RES_OFFSET,LEN_TNS_COEFF_RES);
  590. }
  591. bits += numFilters * (len_tns_length+len_tns_order);
  592. for (filtNumber=0;filtNumber<numFilters;filtNumber++) {
  593. TnsFilterData* tnsFilterPtr=&windowDataPtr->tnsFilter[filtNumber];
  594. int order = tnsFilterPtr->order;
  595. if (writeFlag) {
  596. PutBit(bitStream,tnsFilterPtr->length,len_tns_length);
  597. PutBit(bitStream,order,len_tns_order);
  598. }
  599. if (order) {
  600. bits += (LEN_TNS_DIRECTION + LEN_TNS_COMPRESS);
  601. if (writeFlag) {
  602. PutBit(bitStream,tnsFilterPtr->direction,LEN_TNS_DIRECTION);
  603. PutBit(bitStream,tnsFilterPtr->coefCompress,LEN_TNS_COMPRESS);
  604. }
  605. bitsToTransmit = resInBits - tnsFilterPtr->coefCompress;
  606. bits += order * bitsToTransmit;
  607. if (writeFlag) {
  608. int i;
  609. for (i=1;i<=order;i++) {
  610. unsignedIndex = (unsigned long) (tnsFilterPtr->index[i])&(~(~0<<bitsToTransmit));
  611. PutBit(bitStream,unsignedIndex,bitsToTransmit);
  612. }
  613. }
  614. }
  615. }
  616. }
  617. }
  618. return bits;
  619. }
  621. static int WriteGainControlData(CoderInfo *coderInfo,
  622. BitStream *bitStream,
  623. int writeFlag)
  624. {
  625. int bits = 0;
  627. if (writeFlag) {
  628. PutBit(bitStream, 0, LEN_GAIN_PRES);
  629. }
  631. bits += LEN_GAIN_PRES;
  633. return bits;
  634. }
  636. static int WriteSpectralData(CoderInfo *coderInfo,
  637.  BitStream *bitStream,
  638.  int writeFlag)
  639. {
  640. int i, bits = 0;
  642. /* set up local pointers to data and len */
  643. /* data array contains data to be written */
  644. /* len array contains lengths of data words */
  645. int* data = coderInfo->data;
  646. int* len  = coderInfo->len;
  648. if (writeFlag) {
  649. for(i = 0; i < coderInfo->spectral_count; i++) {
  650. if (len[i] > 0) {  /* only send out non-zero codebook data */
  651. PutBit(bitStream, data[i], len[i]); /* write data */
  652. bits += len[i];
  653. }
  654. }
  655. } else {
  656. for(i = 0; i < coderInfo->spectral_count; i++) {
  657. bits += len[i];
  658. }
  659. }
  661. return bits;
  662. }
  664. static int WriteAACFillBits(BitStream* bitStream,
  665. int numBits,
  666. int writeFlag)
  667. {
  668. int numberOfBitsLeft = numBits;
  670. /* Need at least (LEN_SE_ID + LEN_F_CNT) bits for a fill_element */
  671. int minNumberOfBits = LEN_SE_ID + LEN_F_CNT;
  673. while (numberOfBitsLeft >= minNumberOfBits)
  674. {
  675. int numberOfBytes;
  676. int maxCount;
  678. if (writeFlag) {
  679. PutBit(bitStream, ID_FIL, LEN_SE_ID); /* Write fill_element ID */
  680. }
  681. numberOfBitsLeft -= minNumberOfBits; /* Subtract for ID,count */
  683. numberOfBytes = (int)(numberOfBitsLeft/LEN_BYTE);
  684. maxCount = (1<<LEN_F_CNT) - 1;  /* Max count without escaping */
  686. /* if we have less than maxCount bytes, write them now */
  687. if (numberOfBytes < maxCount) {
  688. int i;
  689. if (writeFlag) {
  690. PutBit(bitStream, numberOfBytes, LEN_F_CNT);
  691. for (i = 0; i < numberOfBytes; i++) {
  692. PutBit(bitStream, 0, LEN_BYTE);
  693. }
  694. }
  695. /* otherwise, we need to write an escape count */
  696. }
  697. else {
  698. int maxEscapeCount, maxNumberOfBytes, escCount;
  699. int i;
  700. if (writeFlag) {
  701. PutBit(bitStream, maxCount, LEN_F_CNT);
  702. }
  703. maxEscapeCount = (1<<LEN_BYTE) - 1;  /* Max escape count */
  704. maxNumberOfBytes = maxCount + maxEscapeCount;
  705. numberOfBytes = (numberOfBytes > maxNumberOfBytes ) ? (maxNumberOfBytes) : (numberOfBytes);
  706. escCount = numberOfBytes - maxCount;
  707. if (writeFlag) {
  708. PutBit(bitStream, escCount, LEN_BYTE);
  709. for (i = 0; i < numberOfBytes-1; i++) {
  710. PutBit(bitStream, 0, LEN_BYTE);
  711. }
  712. }
  713. }
  714. numberOfBitsLeft -= LEN_BYTE*numberOfBytes;
  715. }
  717. return numberOfBitsLeft;
  718. }
  720. static int FindGroupingBits(CoderInfo *coderInfo)
  721. {
  722. /* This function inputs the grouping information and outputs the seven bit 
  723. 'grouping_bits' field that the AAC decoder expects.  */
  725. int grouping_bits = 0;
  726. int tmp[8];
  727. int i, j;
  728. int index = 0;
  730. for(i = 0; i < coderInfo->num_window_groups; i++){
  731. for (j = 0; j < coderInfo->window_group_length[i]; j++){
  732. tmp[index++] = i;
  733. }
  734. }
  736. for(i = 1; i < 8; i++){
  737. grouping_bits = grouping_bits << 1;
  738. if(tmp[i] == tmp[i-1]) {
  739. grouping_bits++;
  740. }
  741. }
  743. return grouping_bits;
  744. }
  746. /* size in bytes! */
  747. BitStream *OpenBitStream(int size, unsigned char *buffer)
  748. {
  749. BitStream *bitStream;
  751. bitStream = AllocMemory(sizeof(BitStream));
  752. bitStream->size = size;
  753. bitStream->numBit = 0;
  754. bitStream->currentBit = 0;
  755. bitStream->data = buffer;
  756. SetMemory(bitStream->data, 0, size);
  758. return bitStream;
  759. }
  761. int CloseBitStream(BitStream *bitStream)
  762. {
  763. int bytes = bit2byte(bitStream->numBit);
  765. FreeMemory(bitStream);
  767. return bytes;
  768. }
  770. static long BufferNumBit(BitStream *bitStream)
  771. {
  772. return bitStream->numBit;
  773. }
  775. static int WriteByte(BitStream *bitStream,
  776.  unsigned long data,
  777.  int numBit)
  778. {
  779. long numUsed,idx;
  781. idx = (bitStream->currentBit / BYTE_NUMBIT) % bitStream->size;
  782. numUsed = bitStream->currentBit % BYTE_NUMBIT;
  783. if (numUsed == 0)
  784. bitStream->data[idx] = 0;
  785. bitStream->data[idx] |= (data & ((1<<numBit)-1)) <<
  786. (BYTE_NUMBIT-numUsed-numBit);
  787. bitStream->currentBit += numBit;
  788. bitStream->numBit = bitStream->currentBit;
  790. return 0;
  791. }
  793. int PutBit(BitStream *bitStream,
  794.    unsigned long data,
  795.    int numBit)
  796. {
  797. int num,maxNum,curNum;
  798. unsigned long bits;
  800. if (numBit == 0)
  801. return 0;
  803. /* write bits in packets according to buffer byte boundaries */
  804. num = 0;
  805. maxNum = BYTE_NUMBIT - bitStream->currentBit % BYTE_NUMBIT;
  806. while (num < numBit) {
  807. curNum = min(numBit-num,maxNum);
  808. bits = data>>(numBit-num-curNum);
  809. if (WriteByte(bitStream, bits, curNum)) {
  810. return 1;
  811. }
  812. num += curNum;
  813. maxNum = BYTE_NUMBIT;
  814. }
  816. return 0;
  817. }
  819. static int ByteAlign(BitStream *bitStream, int writeFlag, int offset)
  820. {
  821. int len, i,j;
  823. assert(offset<8);
  824. assert(offset>=0);
  826. len = BufferNumBit(bitStream);
  828. j = (16+offset - (len%8))%8;
  830. if ((len % 8) == offset) 
  831. j = 0;
  833. if (writeFlag) {
  834. for( i=0; i<j; i++ ) {
  835. PutBit(bitStream, 0, 1);
  836. }
  837. }
  838. else
  839. bitStream->numBit+=j;
  841. return j;
  842. }