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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

frame.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: frame.c,v 1.4 2002/02/25 22:26:43 dmackie Exp $
  20.  */
  22. /*
  23.  * CHANGES:
  24.  *  2001/01/17: menno: Added frequency cut off filter.
  25.  *  2001/02/28: menno: Added Temporal Noise Shaping.
  26.  *  2001/03/05: menno: Added Long Term Prediction.
  27.  *  2001/05/01: menno: Added backward prediction.
  28.  *
  29.  */
  31. #include <stdio.h>
  32. #include <stdlib.h>
  34. #include "frame.h"
  35. #include "coder.h"
  36. #include "joint.h"
  37. #include "channels.h"
  38. #include "bitstream.h"
  39. #include "filtbank.h"
  40. #include "aacquant.h"
  41. #include "util.h"
  42. #include "huffman.h"
  43. #include "psych.h"
  44. #include "tns.h"
  45. #include "ltp.h"
  46. #include "backpred.h"
  49. faacEncConfigurationPtr FAACAPI faacEncGetCurrentConfiguration(faacEncHandle hEncoder)
  50. {
  51. faacEncConfigurationPtr config = &(hEncoder->config);
  53. return config;
  54. }
  56. int FAACAPI faacEncSetConfiguration(faacEncHandle hEncoder,
  57. faacEncConfigurationPtr config)
  58. {
  59. hEncoder->config.allowMidside = config->allowMidside;
  60. hEncoder->config.useLfe = config->useLfe;
  61. hEncoder->config.useTns = config->useTns;
  62. hEncoder->config.aacObjectType = config->aacObjectType;
  63. hEncoder->config.mpegVersion = config->mpegVersion;
  65. /* No SSR supported for now */
  66. if (hEncoder->config.aacObjectType == SSR)
  67. return 0;
  69. /* LTP only with MPEG4 */
  70. if ((hEncoder->config.aacObjectType == LTP) && (hEncoder->config.mpegVersion != MPEG4))
  71. return 0;
  73. /* Re-init TNS for new profile */
  74. TnsInit(hEncoder);
  76. /* Check for correct bitrate */
  77. if (config->bitRate > MaxBitrate(hEncoder->sampleRate))
  78. return 0;
  79. if (config->bitRate < MinBitrate())
  80. return 0;
  82. /* Bitrate check passed */
  83. hEncoder->config.bitRate = config->bitRate;
  85. /* OK */
  86. return 1;
  87. }
  89. faacEncHandle FAACAPI faacEncOpen(unsigned long sampleRate,
  90.   unsigned int numChannels,
  91.   unsigned long *inputSamples,
  92.   unsigned long *maxOutputBytes)
  93. {
  94. unsigned int channel;
  95. faacEncHandle hEncoder;
  97. *inputSamples = 1024*numChannels;
  98. *maxOutputBytes = (6144/8)*numChannels;
  100. hEncoder = (faacEncStruct*)AllocMemory(sizeof(faacEncStruct));
  101. SetMemory(hEncoder, 0, sizeof(faacEncStruct));
  103. hEncoder->numChannels = numChannels;
  104. hEncoder->sampleRate = sampleRate;
  105. hEncoder->sampleRateIdx = GetSRIndex(sampleRate);
  107. /* Initialize variables to default values */
  108. hEncoder->frameNum = 0;
  109. hEncoder->flushFrame = 0;
  111. /* Default configuration */
  112. hEncoder->config.mpegVersion = MPEG4;
  113. hEncoder->config.aacObjectType = LTP;
  114. hEncoder->config.allowMidside = 1;
  115. hEncoder->config.useLfe = 0;
  116. hEncoder->config.useTns = 0;
  117. hEncoder->config.bitRate = 64000; /* default bitrate / channel */
  118. hEncoder->config.bandWidth = 18000; /* default bandwidth */
  119. #ifdef MPEG4IP
  120. hEncoder->config.useAdts = 1;
  121. #endif
  123. /* find correct sampling rate depending parameters */
  124. hEncoder->srInfo = &srInfo[hEncoder->sampleRateIdx];
  126. for (channel = 0; channel < numChannels; channel++) {
  127. hEncoder->coderInfo[channel].prev_window_shape = SINE_WINDOW;
  128. hEncoder->coderInfo[channel].window_shape = SINE_WINDOW;
  129. hEncoder->coderInfo[channel].block_type = ONLY_LONG_WINDOW;
  130. hEncoder->coderInfo[channel].num_window_groups = 1;
  131. hEncoder->coderInfo[channel].window_group_length[0] = 1;
  133. /* FIXME: Use sr_idx here */
  134. hEncoder->coderInfo[channel].max_pred_sfb = GetMaxPredSfb(hEncoder->sampleRateIdx);
  136. hEncoder->sampleBuff[channel] = NULL;
  137. hEncoder->nextSampleBuff[channel] = NULL;
  138. hEncoder->next2SampleBuff[channel] = NULL;
  139. hEncoder->ltpTimeBuff[channel] = (double*)AllocMemory(2*BLOCK_LEN_LONG*sizeof(double));
  140. SetMemory(hEncoder->ltpTimeBuff[channel], 0, 2*BLOCK_LEN_LONG*sizeof(double));
  141. }
  143. /* Initialize coder functions */
  144. PsyInit(&hEncoder->gpsyInfo, hEncoder->psyInfo, hEncoder->numChannels,
  145. hEncoder->sampleRate, hEncoder->sampleRateIdx);
  147. FilterBankInit(hEncoder);
  149.     TnsInit(hEncoder);
  151. LtpInit(hEncoder);
  153. PredInit(hEncoder);
  155. AACQuantizeInit(hEncoder->coderInfo, hEncoder->numChannels);
  157. HuffmanInit(hEncoder->coderInfo, hEncoder->numChannels);
  159. /* Return handle */
  160. return hEncoder;
  161. }
  163. int FAACAPI faacEncClose(faacEncHandle hEncoder)
  164. {
  165. unsigned int channel;
  167. /* Deinitialize coder functions */
  168. PsyEnd(&hEncoder->gpsyInfo, hEncoder->psyInfo, hEncoder->numChannels);
  170. FilterBankEnd(hEncoder);
  172. LtpEnd(hEncoder);
  174. AACQuantizeEnd(hEncoder->coderInfo, hEncoder->numChannels);
  176. HuffmanEnd(hEncoder->coderInfo, hEncoder->numChannels);
  178. /* Free remaining buffer memory */
  179. for (channel = 0; channel < hEncoder->numChannels; channel++) {
  180. if (hEncoder->ltpTimeBuff[channel]) FreeMemory(hEncoder->ltpTimeBuff[channel]);
  181. if (hEncoder->sampleBuff[channel]) FreeMemory(hEncoder->sampleBuff[channel]);
  182. if (hEncoder->nextSampleBuff[channel]) FreeMemory(hEncoder->nextSampleBuff[channel]);
  183. }
  185. /* Free handle */
  186. if (hEncoder) FreeMemory(hEncoder);
  188. return 0;
  189. }
  191. int FAACAPI faacEncEncode(faacEncHandle hEncoder,
  192.   short *inputBuffer,
  193.   unsigned int samplesInput,
  194.   unsigned char *outputBuffer,
  195.   unsigned int bufferSize
  196.   )
  197. {
  198. unsigned int channel, i;
  199. int sb, frameBytes;
  200. unsigned int bitsToUse, offset;
  201. BitStream *bitStream; /* bitstream used for writing the frame to */
  202. TnsInfo *tnsInfo_for_LTP;
  203. TnsInfo *tnsDecInfo;
  205. /* local copy's of parameters */
  206. ChannelInfo *channelInfo = hEncoder->channelInfo;
  207. CoderInfo *coderInfo = hEncoder->coderInfo;
  208. unsigned int numChannels = hEncoder->numChannels;
  209. unsigned int sampleRate = hEncoder->sampleRate;
  210. unsigned int aacObjectType = hEncoder->config.aacObjectType;
  211. unsigned int mpegVersion = hEncoder->config.mpegVersion;
  212. unsigned int useLfe = hEncoder->config.useLfe;
  213. unsigned int useTns = hEncoder->config.useTns;
  214. unsigned int allowMidside = hEncoder->config.allowMidside;
  215. unsigned int bitRate = hEncoder->config.bitRate;
  216. unsigned int bandWidth = hEncoder->config.bandWidth;
  218. /* Increase frame number */
  219. hEncoder->frameNum++;
  221. if (samplesInput == 0)
  222. hEncoder->flushFrame++;
  224. /* After 2 flush frames all samples have been encoded,
  225.    return 0 bytes written */
  226. if (hEncoder->flushFrame == 2)
  227. return 0;
  229. /* Determine the channel configuration */
  230. GetChannelInfo(channelInfo, numChannels, useLfe);
  232. /* Update current sample buffers */
  233. for (channel = 0; channel < numChannels; channel++) {
  234. if (hEncoder->sampleBuff[channel]) {
  235. for(i = 0; i < FRAME_LEN; i++) {
  236. hEncoder->ltpTimeBuff[channel][i] = hEncoder->sampleBuff[channel][i];
  237. }
  238. }
  239. if (hEncoder->nextSampleBuff[channel]) {
  240. for(i = 0; i < FRAME_LEN; i++) {
  241. hEncoder->ltpTimeBuff[channel][FRAME_LEN + i] =
  242. hEncoder->nextSampleBuff[channel][i];
  243. }
  244. }
  246. if (hEncoder->sampleBuff[channel])
  247. FreeMemory(hEncoder->sampleBuff[channel]);
  248. hEncoder->sampleBuff[channel] = hEncoder->nextSampleBuff[channel];
  249. hEncoder->nextSampleBuff[channel] = (double*)AllocMemory(FRAME_LEN*sizeof(double));
  251. if (samplesInput == 0) { /* start flushing*/
  252. for (i = 0; i < FRAME_LEN; i++)
  253. hEncoder->nextSampleBuff[channel][i] = 0.0;
  254. } else {
  255. for (i = 0; i < (int)(samplesInput/numChannels); i++)
  256. hEncoder->nextSampleBuff[channel][i] = 
  257. (double)inputBuffer[(i*numChannels)+channel];
  258. for (i = (int)(samplesInput/numChannels); i < FRAME_LEN; i++)
  259. hEncoder->nextSampleBuff[channel][i] = 0.0;
  260. }
  262. /* Psychoacoustics */
  263. /* Update buffers and run FFT on new samples */
  264. PsyBufferUpdate(&hEncoder->gpsyInfo, &hEncoder->psyInfo[channel],
  265. hEncoder->nextSampleBuff[channel]);
  266. }
  268. if (hEncoder->frameNum <= 1) /* Still filling up the buffers */
  269. return 0;
  271. /* Psychoacoustics */
  272. PsyCalculate(channelInfo, &hEncoder->gpsyInfo, hEncoder->psyInfo,
  273. hEncoder->srInfo->cb_width_long, hEncoder->srInfo->num_cb_long,
  274. hEncoder->srInfo->cb_width_short,
  275. hEncoder->srInfo->num_cb_short, numChannels);
  277. BlockSwitch(coderInfo, hEncoder->psyInfo, numChannels);
  279. /* AAC Filterbank, MDCT with overlap and add */
  280. for (channel = 0; channel < numChannels; channel++) {
  281. int k;
  283. FilterBank(hEncoder,
  284. &coderInfo[channel],
  285. hEncoder->sampleBuff[channel],
  286. hEncoder->freqBuff[channel],
  287. hEncoder->overlapBuff[channel],
  288. MOVERLAPPED);
  290. if (coderInfo[channel].block_type == ONLY_SHORT_WINDOW) {
  291. for (k = 0; k < 8; k++) {
  292. specFilter(hEncoder->freqBuff[channel]+k*BLOCK_LEN_SHORT,
  293. sampleRate, bandWidth, BLOCK_LEN_SHORT);
  294. }
  295. } else {
  296. specFilter(hEncoder->freqBuff[channel], sampleRate,
  297. bandWidth, BLOCK_LEN_LONG);
  298. }
  299. }
  301. /* TMP: Build sfb offset table and other stuff */
  302. for (channel = 0; channel < numChannels; channel++) {
  303. channelInfo[channel].msInfo.is_present = 0;
  305. if (coderInfo[channel].block_type == ONLY_SHORT_WINDOW) {
  306. coderInfo[channel].max_sfb = hEncoder->srInfo->num_cb_short;
  307. coderInfo[channel].nr_of_sfb = hEncoder->srInfo->num_cb_short;
  309. coderInfo[channel].num_window_groups = 1;
  310. coderInfo[channel].window_group_length[0] = 8;
  311. coderInfo[channel].window_group_length[1] = 0;
  312. coderInfo[channel].window_group_length[2] = 0;
  313. coderInfo[channel].window_group_length[3] = 0;
  314. coderInfo[channel].window_group_length[4] = 0;
  315. coderInfo[channel].window_group_length[5] = 0;
  316. coderInfo[channel].window_group_length[6] = 0;
  317. coderInfo[channel].window_group_length[7] = 0;
  319. offset = 0;
  320. for (sb = 0; sb < coderInfo[channel].nr_of_sfb; sb++) {
  321. coderInfo[channel].sfb_offset[sb] = offset;
  322. offset += hEncoder->srInfo->cb_width_short[sb];
  323. }
  324. coderInfo[channel].sfb_offset[coderInfo[channel].nr_of_sfb] = offset;
  325. } else {
  326. coderInfo[channel].max_sfb = hEncoder->srInfo->num_cb_long;
  327. coderInfo[channel].nr_of_sfb = hEncoder->srInfo->num_cb_long;
  329. coderInfo[channel].num_window_groups = 1;
  330. coderInfo[channel].window_group_length[0] = 1;
  332. offset = 0;
  333. for (sb = 0; sb < coderInfo[channel].nr_of_sfb; sb++) {
  334. coderInfo[channel].sfb_offset[sb] = offset;
  335. offset += hEncoder->srInfo->cb_width_long[sb];
  336. }
  337. coderInfo[channel].sfb_offset[coderInfo[channel].nr_of_sfb] = offset;
  338. }
  339. }
  341. /* Perform TNS analysis and filtering */
  342. for (channel = 0; channel < numChannels; channel++) {
  343. if ((!channelInfo[channel].lfe) && (useTns)) {
  344. TnsEncode(&(coderInfo[channel].tnsInfo),
  345. coderInfo[channel].max_sfb,
  346. coderInfo[channel].max_sfb,
  347. coderInfo[channel].block_type,
  348. coderInfo[channel].sfb_offset,
  349. hEncoder->freqBuff[channel]);
  350. } else {
  351. coderInfo[channel].tnsInfo.tnsDataPresent = 0;      /* TNS not used for LFE */
  352. }
  353. }
  355. for(channel = 0; channel < numChannels; channel++)
  356. {
  357. if((coderInfo[channel].tnsInfo.tnsDataPresent != 0) && (useTns))
  358. tnsInfo_for_LTP = &(coderInfo[channel].tnsInfo);
  359. else
  360. tnsInfo_for_LTP = NULL;
  362. if(channelInfo[channel].present && (!channelInfo[channel].lfe) &&
  363. (coderInfo[channel].block_type != ONLY_SHORT_WINDOW) &&
  364. (mpegVersion == MPEG4) && (aacObjectType == LTP)) 
  365. {
  366. LtpEncode(hEncoder,
  367. &coderInfo[channel],
  368. &(coderInfo[channel].ltpInfo),
  369. tnsInfo_for_LTP,
  370. hEncoder->freqBuff[channel],
  371. hEncoder->ltpTimeBuff[channel]);
  372. } else {
  373. coderInfo[channel].ltpInfo.global_pred_flag = 0;
  374. }
  375. }
  377. for(channel = 0; channel < numChannels; channel++)
  378. {
  379. if ((aacObjectType == MAIN) && (!channelInfo[channel].lfe)) {
  380. int numPredBands = min(coderInfo[channel].max_pred_sfb, coderInfo[channel].nr_of_sfb);
  381. PredCalcPrediction(hEncoder->freqBuff[channel], 
  382. coderInfo[channel].requantFreq,
  383. coderInfo[channel].block_type,
  384. numPredBands,
  385. (coderInfo[channel].block_type==ONLY_SHORT_WINDOW)?
  386. hEncoder->srInfo->cb_width_short:hEncoder->srInfo->cb_width_long,
  387. coderInfo,
  388. channelInfo,
  389. channel); 
  390. } else {
  391. coderInfo[channel].pred_global_flag = 0;
  392. }
  393. }
  395. MSEncode(coderInfo, channelInfo, hEncoder->freqBuff, numChannels, allowMidside);
  397. /* Quantize and code the signal */
  398. bitsToUse = (int)(bitRate*FRAME_LEN/sampleRate+0.5);
  399. for (channel = 0; channel < numChannels; channel++) {
  400. if (coderInfo[channel].block_type == ONLY_SHORT_WINDOW) {
  401. AACQuantize(&coderInfo[channel], &hEncoder->psyInfo[channel],
  402. &channelInfo[channel], hEncoder->srInfo->cb_width_short,
  403. hEncoder->srInfo->num_cb_short, hEncoder->freqBuff[channel], bitsToUse);
  404. } else {
  405. AACQuantize(&coderInfo[channel], &hEncoder->psyInfo[channel],
  406. &channelInfo[channel], hEncoder->srInfo->cb_width_long,
  407. hEncoder->srInfo->num_cb_long, hEncoder->freqBuff[channel], bitsToUse);
  408. }
  409. }
  411. MSReconstruct(coderInfo, channelInfo, numChannels);
  413. for (channel = 0; channel < numChannels; channel++) 
  414. {
  415. /* If short window, reconstruction not needed for prediction */
  416. if ((coderInfo[channel].block_type == ONLY_SHORT_WINDOW)) {
  417. int sind;
  418. for (sind = 0; sind < 1024; sind++) {
  419. coderInfo[channel].requantFreq[sind] = 0.0;
  420. }
  421. } else {
  423. if((coderInfo[channel].tnsInfo.tnsDataPresent != 0) && (useTns))
  424. tnsDecInfo = &(coderInfo[channel].tnsInfo);
  425. else
  426. tnsDecInfo = NULL;
  428. if ((!channelInfo[channel].lfe) && (aacObjectType == LTP)) {  /* no reconstruction needed for LFE channel*/
  430. LtpReconstruct(&coderInfo[channel], &(coderInfo[channel].ltpInfo),
  431. coderInfo[channel].requantFreq);
  433. if(tnsDecInfo != NULL)
  434. TnsDecodeFilterOnly(&(coderInfo[channel].tnsInfo), coderInfo[channel].nr_of_sfb,
  435. coderInfo[channel].max_sfb, coderInfo[channel].block_type,
  436. coderInfo[channel].sfb_offset, coderInfo[channel].requantFreq);
  438. IFilterBank(hEncoder, &coderInfo[channel],
  439. coderInfo[channel].requantFreq,
  440. coderInfo[channel].ltpInfo.time_buffer,
  441. coderInfo[channel].ltpInfo.ltp_overlap_buffer,
  442. MOVERLAPPED);
  444. LtpUpdate(&(coderInfo[channel].ltpInfo),
  445. coderInfo[channel].ltpInfo.time_buffer,
  446. coderInfo[channel].ltpInfo.ltp_overlap_buffer,
  447. BLOCK_LEN_LONG);
  448. }
  449. }
  450. }
  452. /* Write the AAC bitstream */
  453. bitStream = OpenBitStream(bufferSize, outputBuffer);
  455. WriteBitstream(hEncoder, coderInfo, channelInfo, bitStream, numChannels);
  457. /* Close the bitstream and return the number of bytes written */
  458. frameBytes = CloseBitStream(bitStream);
  460. #ifdef _DEBUG
  461. printf("%4d %4dn", hEncoder->frameNum-1, frameBytes);
  462. #endif
  464. return frameBytes;
  465. }
  468. /* Scalefactorband data table */
  469. static SR_INFO srInfo[12+1] =
  470. {
  471. { 96000, 41, 12,
  472. {
  473. 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  474. 8, 8, 8, 8, 8, 12, 12, 12, 12, 12, 16, 16, 24, 28, 
  475. 36, 44, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
  476. },{
  477. 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36
  478. }
  479. }, { 88200, 41, 12,
  480. {
  481. 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  482. 8, 8, 8, 8, 8, 12, 12, 12, 12, 12, 16, 16, 24, 28, 
  483. 36, 44, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
  484. },{
  485. 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36
  486. }
  487. }, { 64000, 47, 12,
  488. {
  489. 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  490. 8, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 24, 24, 28,
  491. 36, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
  492. 40, 40, 40, 40, 40
  493. },{
  494. 4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 32
  495. }
  496. }, { 48000, 49, 14,
  497. {
  498. 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8, 
  499. 12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32, 32, 32, 32, 32,
  500. 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 96
  501. }, {
  502. 4,  4,  4,  4,  4,  8,  8,  8, 12, 12, 12, 16, 16, 16 
  503. }
  504. }, { 44100, 49, 14,
  505. {
  506. 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8, 
  507. 12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28, 32, 32, 32, 32, 32, 32,
  508. 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 96
  509. }, {
  510. 4,  4,  4,  4,  4,  8,  8,  8, 12, 12, 12, 16, 16, 16 
  511. }
  512. }, { 32000, 51, 14,
  513. {
  514. 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
  515. 8, 8, 8, 12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28,
  516. 28, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
  517. 32, 32, 32, 32, 32, 32, 32, 32, 32
  518. },{
  519. 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16
  520. }
  521. }, { 24000, 47, 15,
  522. {
  523. 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8,
  524. 8,  8,  8,  12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28, 32,
  525. 36, 36, 40, 44, 48, 52, 52, 64, 64, 64, 64, 64
  526. }, {
  527. 4,  4,  4,  4,  4,  4,  4,  8,  8,  8, 12, 12, 16, 16, 20
  528. }
  529. }, { 22050, 47, 15,
  530. {
  531. 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  8,  8,  8,  8,  8,  8,  8,
  532. 8,  8,  8,  12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28, 32,
  533. 36, 36, 40, 44, 48, 52, 52, 64, 64, 64, 64, 64
  534. }, {
  535. 4,  4,  4,  4,  4,  4,  4,  8,  8,  8, 12, 12, 16, 16, 20
  536. }
  537. }, { 16000, 43, 15,
  538. {
  539. 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 
  540. 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24, 
  541. 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64, 64
  542. }, {
  543. 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20
  544. }
  545. }, { 12000, 43, 15,
  546. {
  547. 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 
  548. 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24, 
  549. 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64, 64
  550. }, {
  551. 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20
  552. }
  553. }, { 11025, 43, 15,
  554. {
  555. 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 
  556. 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24,
  557. 24, 28, 28, 32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64, 64
  558. }, {
  559. 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20
  560. }
  561. }, { 8000, 40, 15,
  562. {
  563. 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 16, 
  564. 16, 16, 16, 16, 16, 16, 20, 20, 20, 20, 24, 24, 24, 28, 
  565. 28, 32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 80
  566. }, {
  567. 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 20
  568. }
  569. },
  570. { -1 }
  571. };