Newer
Older
DH_Apicture / scripts / new_node_modules / lamejs / src / js / Encoder.js
@zhangqy zhangqy on 29 Nov 21 KB first commit
  1. var common = require('./common.js');
  2. var System = common.System;
  3. var VbrMode = common.VbrMode;
  4. var Float = common.Float;
  5. var ShortBlock = common.ShortBlock;
  6. var Util = common.Util;
  7. var Arrays = common.Arrays;
  8. var new_array_n = common.new_array_n;
  9. var new_byte = common.new_byte;
  10. var new_double = common.new_double;
  11. var new_float = common.new_float;
  12. var new_float_n = common.new_float_n;
  13. var new_int = common.new_int;
  14. var new_int_n = common.new_int_n;
  15. var assert = common.assert;
  16.  
  17. /**
  18. * ENCDELAY The encoder delay.
  19. *
  20. * Minimum allowed is MDCTDELAY (see below)
  21. *
  22. * The first 96 samples will be attenuated, so using a value less than 96
  23. * will result in corrupt data for the first 96-ENCDELAY samples.
  24. *
  25. * suggested: 576 set to 1160 to sync with FhG.
  26. */
  27. Encoder.ENCDELAY = 576;
  28. /**
  29. * make sure there is at least one complete frame after the last frame
  30. * containing real data
  31. *
  32. * Using a value of 288 would be sufficient for a a very sophisticated
  33. * decoder that can decode granule-by-granule instead of frame by frame. But
  34. * lets not assume this, and assume the decoder will not decode frame N
  35. * unless it also has data for frame N+1
  36. */
  37. Encoder.POSTDELAY = 1152;
  38.  
  39. /**
  40. * delay of the MDCT used in mdct.c original ISO routines had a delay of
  41. * 528! Takehiro's routines:
  42. */
  43. Encoder.MDCTDELAY = 48;
  44. Encoder.FFTOFFSET = (224 + Encoder.MDCTDELAY);
  45.  
  46. /**
  47. * Most decoders, including the one we use, have a delay of 528 samples.
  48. */
  49. Encoder.DECDELAY = 528;
  50.  
  51. /**
  52. * number of subbands
  53. */
  54. Encoder.SBLIMIT = 32;
  55.  
  56. /**
  57. * parition bands bands
  58. */
  59. Encoder.CBANDS = 64;
  60.  
  61. /**
  62. * number of critical bands/scale factor bands where masking is computed
  63. */
  64. Encoder.SBPSY_l = 21;
  65. Encoder.SBPSY_s = 12;
  66.  
  67. /**
  68. * total number of scalefactor bands encoded
  69. */
  70. Encoder.SBMAX_l = 22;
  71. Encoder.SBMAX_s = 13;
  72. Encoder.PSFB21 = 6;
  73. Encoder.PSFB12 = 6;
  74.  
  75. /**
  76. * FFT sizes
  77. */
  78. Encoder.BLKSIZE = 1024;
  79. Encoder.HBLKSIZE = (Encoder.BLKSIZE / 2 + 1);
  80. Encoder.BLKSIZE_s = 256;
  81. Encoder.HBLKSIZE_s = (Encoder.BLKSIZE_s / 2 + 1);
  82.  
  83. Encoder.NORM_TYPE = 0;
  84. Encoder.START_TYPE = 1;
  85. Encoder.SHORT_TYPE = 2;
  86. Encoder.STOP_TYPE = 3;
  87.  
  88. /**
  89. * <PRE>
  90. * Mode Extention:
  91. * When we are in stereo mode, there are 4 possible methods to store these
  92. * two channels. The stereo modes -m? are using a subset of them.
  93. *
  94. * -ms: MPG_MD_LR_LR
  95. * -mj: MPG_MD_LR_LR and MPG_MD_MS_LR
  96. * -mf: MPG_MD_MS_LR
  97. * -mi: all
  98. * </PRE>
  99. */
  100. Encoder.MPG_MD_LR_LR = 0;
  101. Encoder.MPG_MD_LR_I = 1;
  102. Encoder.MPG_MD_MS_LR = 2;
  103. Encoder.MPG_MD_MS_I = 3;
  104.  
  105. Encoder.fircoef = [-0.0207887 * 5, -0.0378413 * 5,
  106. -0.0432472 * 5, -0.031183 * 5, 7.79609e-18 * 5, 0.0467745 * 5,
  107. 0.10091 * 5, 0.151365 * 5, 0.187098 * 5];
  108.  
  109. function Encoder () {
  110. var NewMDCT = require('./NewMDCT.js');
  111. var III_psy_ratio = require('./III_psy_ratio.js');
  112. var MPEGMode = require('./MPEGMode.js');
  113. var FFTOFFSET = Encoder.FFTOFFSET;
  114. var MPG_MD_MS_LR = Encoder.MPG_MD_MS_LR;
  115. //BitStream bs;
  116. //PsyModel psy;
  117. //VBRTag vbr;
  118. //QuantizePVT qupvt;
  119. var bs = null;
  120. this.psy = null;
  121. var psy = null;
  122. var vbr = null;
  123. var qupvt = null;
  124.  
  125. //public final void setModules(BitStream bs, PsyModel psy, QuantizePVT qupvt,
  126. // VBRTag vbr) {
  127. this.setModules = function (_bs, _psy, _qupvt, _vbr) {
  128. bs = _bs;
  129. this.psy = _psy;
  130. psy = _psy;
  131. vbr = _vbr;
  132. qupvt = _qupvt;
  133. };
  134.  
  135. var newMDCT = new NewMDCT();
  136.  
  137. /***********************************************************************
  138. *
  139. * encoder and decoder delays
  140. *
  141. ***********************************************************************/
  142.  
  143. /**
  144. * <PRE>
  145. * layer III enc->dec delay: 1056 (1057?) (observed)
  146. * layer II enc->dec delay: 480 (481?) (observed)
  147. *
  148. * polyphase 256-16 (dec or enc) = 240
  149. * mdct 256+32 (9*32) (dec or enc) = 288
  150. * total: 512+16
  151. *
  152. * My guess is that delay of polyphase filterbank is actualy 240.5
  153. * (there are technical reasons for this, see postings in mp3encoder).
  154. * So total Encode+Decode delay = ENCDELAY + 528 + 1
  155. * </PRE>
  156. */
  157.  
  158.  
  159. /**
  160. * auto-adjust of ATH, useful for low volume Gabriel Bouvigne 3 feb 2001
  161. *
  162. * modifies some values in gfp.internal_flags.ATH (gfc.ATH)
  163. */
  164. //private void adjust_ATH(final LameInternalFlags gfc) {
  165. function adjust_ATH (gfc) {
  166. var gr2_max, max_pow;
  167.  
  168. if (gfc.ATH.useAdjust == 0) {
  169. gfc.ATH.adjust = 1.0;
  170. /* no adjustment */
  171. return;
  172. }
  173.  
  174. /* jd - 2001 mar 12, 27, jun 30 */
  175. /* loudness based on equal loudness curve; */
  176. /* use granule with maximum combined loudness */
  177. max_pow = gfc.loudness_sq[0][0];
  178. gr2_max = gfc.loudness_sq[1][0];
  179. if (gfc.channels_out == 2) {
  180. max_pow += gfc.loudness_sq[0][1];
  181. gr2_max += gfc.loudness_sq[1][1];
  182. } else {
  183. max_pow += max_pow;
  184. gr2_max += gr2_max;
  185. }
  186. if (gfc.mode_gr == 2) {
  187. max_pow = Math.max(max_pow, gr2_max);
  188. }
  189. max_pow *= 0.5;
  190. /* max_pow approaches 1.0 for full band noise */
  191.  
  192. /* jd - 2001 mar 31, jun 30 */
  193. /* user tuning of ATH adjustment region */
  194. max_pow *= gfc.ATH.aaSensitivityP;
  195.  
  196. /*
  197. * adjust ATH depending on range of maximum value
  198. */
  199.  
  200. /* jd - 2001 feb27, mar12,20, jun30, jul22 */
  201. /* continuous curves based on approximation */
  202. /* to GB's original values. */
  203. /* For an increase in approximate loudness, */
  204. /* set ATH adjust to adjust_limit immediately */
  205. /* after a delay of one frame. */
  206. /* For a loudness decrease, reduce ATH adjust */
  207. /* towards adjust_limit gradually. */
  208. /* max_pow is a loudness squared or a power. */
  209. if (max_pow > 0.03125) { /* ((1 - 0.000625)/ 31.98) from curve below */
  210. if (gfc.ATH.adjust >= 1.0) {
  211. gfc.ATH.adjust = 1.0;
  212. } else {
  213. /* preceding frame has lower ATH adjust; */
  214. /* ascend only to the preceding adjust_limit */
  215. /* in case there is leading low volume */
  216. if (gfc.ATH.adjust < gfc.ATH.adjustLimit) {
  217. gfc.ATH.adjust = gfc.ATH.adjustLimit;
  218. }
  219. }
  220. gfc.ATH.adjustLimit = 1.0;
  221. } else { /* adjustment curve */
  222. /* about 32 dB maximum adjust (0.000625) */
  223. var adj_lim_new = 31.98 * max_pow + 0.000625;
  224. if (gfc.ATH.adjust >= adj_lim_new) { /* descend gradually */
  225. gfc.ATH.adjust *= adj_lim_new * 0.075 + 0.925;
  226. if (gfc.ATH.adjust < adj_lim_new) { /* stop descent */
  227. gfc.ATH.adjust = adj_lim_new;
  228. }
  229. } else { /* ascend */
  230. if (gfc.ATH.adjustLimit >= adj_lim_new) {
  231. gfc.ATH.adjust = adj_lim_new;
  232. } else {
  233. /* preceding frame has lower ATH adjust; */
  234. /* ascend only to the preceding adjust_limit */
  235. if (gfc.ATH.adjust < gfc.ATH.adjustLimit) {
  236. gfc.ATH.adjust = gfc.ATH.adjustLimit;
  237. }
  238. }
  239. }
  240. gfc.ATH.adjustLimit = adj_lim_new;
  241. }
  242. }
  243.  
  244. /**
  245. * <PRE>
  246. * some simple statistics
  247. *
  248. * bitrate index 0: free bitrate . not allowed in VBR mode
  249. * : bitrates, kbps depending on MPEG version
  250. * bitrate index 15: forbidden
  251. *
  252. * mode_ext:
  253. * 0: LR
  254. * 1: LR-i
  255. * 2: MS
  256. * 3: MS-i
  257. * </PRE>
  258. */
  259. function updateStats (gfc) {
  260. var gr, ch;
  261. assert(0 <= gfc.bitrate_index && gfc.bitrate_index < 16);
  262. assert(0 <= gfc.mode_ext && gfc.mode_ext < 4);
  263.  
  264. /* count bitrate indices */
  265. gfc.bitrate_stereoMode_Hist[gfc.bitrate_index][4]++;
  266. gfc.bitrate_stereoMode_Hist[15][4]++;
  267.  
  268. /* count 'em for every mode extension in case of 2 channel encoding */
  269. if (gfc.channels_out == 2) {
  270. gfc.bitrate_stereoMode_Hist[gfc.bitrate_index][gfc.mode_ext]++;
  271. gfc.bitrate_stereoMode_Hist[15][gfc.mode_ext]++;
  272. }
  273. for (gr = 0; gr < gfc.mode_gr; ++gr) {
  274. for (ch = 0; ch < gfc.channels_out; ++ch) {
  275. var bt = gfc.l3_side.tt[gr][ch].block_type | 0;
  276. if (gfc.l3_side.tt[gr][ch].mixed_block_flag != 0)
  277. bt = 4;
  278. gfc.bitrate_blockType_Hist[gfc.bitrate_index][bt]++;
  279. gfc.bitrate_blockType_Hist[gfc.bitrate_index][5]++;
  280. gfc.bitrate_blockType_Hist[15][bt]++;
  281. gfc.bitrate_blockType_Hist[15][5]++;
  282. }
  283. }
  284. }
  285.  
  286. function lame_encode_frame_init (gfp, inbuf) {
  287. var gfc = gfp.internal_flags;
  288.  
  289. var ch, gr;
  290.  
  291. if (gfc.lame_encode_frame_init == 0) {
  292. /* prime the MDCT/polyphase filterbank with a short block */
  293. var i, j;
  294. var primebuff0 = new_float(286 + 1152 + 576);
  295. var primebuff1 = new_float(286 + 1152 + 576);
  296. gfc.lame_encode_frame_init = 1;
  297. for (i = 0, j = 0; i < 286 + 576 * (1 + gfc.mode_gr); ++i) {
  298. if (i < 576 * gfc.mode_gr) {
  299. primebuff0[i] = 0;
  300. if (gfc.channels_out == 2)
  301. primebuff1[i] = 0;
  302. } else {
  303. primebuff0[i] = inbuf[0][j];
  304. if (gfc.channels_out == 2)
  305. primebuff1[i] = inbuf[1][j];
  306. ++j;
  307. }
  308. }
  309. /* polyphase filtering / mdct */
  310. for (gr = 0; gr < gfc.mode_gr; gr++) {
  311. for (ch = 0; ch < gfc.channels_out; ch++) {
  312. gfc.l3_side.tt[gr][ch].block_type = Encoder.SHORT_TYPE;
  313. }
  314. }
  315. newMDCT.mdct_sub48(gfc, primebuff0, primebuff1);
  316.  
  317. /* check FFT will not use a negative starting offset */
  318. assert(576 >= Encoder.FFTOFFSET);
  319. /* check if we have enough data for FFT */
  320. assert(gfc.mf_size >= (Encoder.BLKSIZE + gfp.framesize - Encoder.FFTOFFSET));
  321. /* check if we have enough data for polyphase filterbank */
  322. assert(gfc.mf_size >= (512 + gfp.framesize - 32));
  323. }
  324.  
  325. }
  326.  
  327. /**
  328. * <PRE>
  329. * encodeframe() Layer 3
  330. *
  331. * encode a single frame
  332. *
  333. *
  334. * lame_encode_frame()
  335. *
  336. *
  337. * gr 0 gr 1
  338. * inbuf: |--------------|--------------|--------------|
  339. *
  340. *
  341. * Polyphase (18 windows, each shifted 32)
  342. * gr 0:
  343. * window1 <----512---.
  344. * window18 <----512---.
  345. *
  346. * gr 1:
  347. * window1 <----512---.
  348. * window18 <----512---.
  349. *
  350. *
  351. *
  352. * MDCT output: |--------------|--------------|--------------|
  353. *
  354. * FFT's <---------1024---------.
  355. * <---------1024-------.
  356. *
  357. *
  358. *
  359. * inbuf = buffer of PCM data size=MP3 framesize
  360. * encoder acts on inbuf[ch][0], but output is delayed by MDCTDELAY
  361. * so the MDCT coefficints are from inbuf[ch][-MDCTDELAY]
  362. *
  363. * psy-model FFT has a 1 granule delay, so we feed it data for the
  364. * next granule.
  365. * FFT is centered over granule: 224+576+224
  366. * So FFT starts at: 576-224-MDCTDELAY
  367. *
  368. * MPEG2: FFT ends at: BLKSIZE+576-224-MDCTDELAY (1328)
  369. * MPEG1: FFT ends at: BLKSIZE+2*576-224-MDCTDELAY (1904)
  370. *
  371. * MPEG2: polyphase first window: [0..511]
  372. * 18th window: [544..1055] (1056)
  373. * MPEG1: 36th window: [1120..1631] (1632)
  374. * data needed: 512+framesize-32
  375. *
  376. * A close look newmdct.c shows that the polyphase filterbank
  377. * only uses data from [0..510] for each window. Perhaps because the window
  378. * used by the filterbank is zero for the last point, so Takehiro's
  379. * code doesn't bother to compute with it.
  380. *
  381. * FFT starts at 576-224-MDCTDELAY (304) = 576-FFTOFFSET
  382. *
  383. * </PRE>
  384. */
  385.  
  386.  
  387. this.lame_encode_mp3_frame = function (gfp, inbuf_l, inbuf_r, mp3buf, mp3bufPos, mp3buf_size) {
  388. var mp3count;
  389. var masking_LR = new_array_n([2, 2]);
  390. /*
  391. * LR masking &
  392. * energy
  393. */
  394. masking_LR[0][0] = new III_psy_ratio();
  395. masking_LR[0][1] = new III_psy_ratio();
  396. masking_LR[1][0] = new III_psy_ratio();
  397. masking_LR[1][1] = new III_psy_ratio();
  398. var masking_MS = new_array_n([2, 2]);
  399. /* MS masking & energy */
  400. masking_MS[0][0] = new III_psy_ratio();
  401. masking_MS[0][1] = new III_psy_ratio();
  402. masking_MS[1][0] = new III_psy_ratio();
  403. masking_MS[1][1] = new III_psy_ratio();
  404. //III_psy_ratio masking[][];
  405. var masking;
  406. /* pointer to selected maskings */
  407. var inbuf = [null, null];
  408. var gfc = gfp.internal_flags;
  409.  
  410. var tot_ener = new_float_n([2, 4]);
  411. var ms_ener_ratio = [.5, .5];
  412. var pe = [[0., 0.], [0., 0.]];
  413. var pe_MS = [[0., 0.], [0., 0.]];
  414.  
  415. //float[][] pe_use;
  416. var pe_use;
  417.  
  418. var ch, gr;
  419.  
  420. inbuf[0] = inbuf_l;
  421. inbuf[1] = inbuf_r;
  422.  
  423. if (gfc.lame_encode_frame_init == 0) {
  424. /* first run? */
  425. lame_encode_frame_init(gfp, inbuf);
  426.  
  427. }
  428.  
  429. /********************** padding *****************************/
  430. /**
  431. * <PRE>
  432. * padding method as described in
  433. * "MPEG-Layer3 / Bitstream Syntax and Decoding"
  434. * by Martin Sieler, Ralph Sperschneider
  435. *
  436. * note: there is no padding for the very first frame
  437. *
  438. * Robert Hegemann 2000-06-22
  439. * </PRE>
  440. */
  441. gfc.padding = 0;
  442. if ((gfc.slot_lag -= gfc.frac_SpF) < 0) {
  443. gfc.slot_lag += gfp.out_samplerate;
  444. gfc.padding = 1;
  445. }
  446.  
  447. /****************************************
  448. * Stage 1: psychoacoustic model *
  449. ****************************************/
  450.  
  451. if (gfc.psymodel != 0) {
  452. /*
  453. * psychoacoustic model psy model has a 1 granule (576) delay that
  454. * we must compensate for (mt 6/99).
  455. */
  456. var ret;
  457. var bufp = [null, null];
  458. /* address of beginning of left & right granule */
  459. var bufpPos = 0;
  460. /* address of beginning of left & right granule */
  461. var blocktype = new_int(2);
  462.  
  463. for (gr = 0; gr < gfc.mode_gr; gr++) {
  464.  
  465. for (ch = 0; ch < gfc.channels_out; ch++) {
  466. bufp[ch] = inbuf[ch];
  467. bufpPos = 576 + gr * 576 - Encoder.FFTOFFSET;
  468. }
  469. if (gfp.VBR == VbrMode.vbr_mtrh || gfp.VBR == VbrMode.vbr_mt) {
  470. ret = psy.L3psycho_anal_vbr(gfp, bufp, bufpPos, gr,
  471. masking_LR, masking_MS, pe[gr], pe_MS[gr],
  472. tot_ener[gr], blocktype);
  473. } else {
  474. ret = psy.L3psycho_anal_ns(gfp, bufp, bufpPos, gr,
  475. masking_LR, masking_MS, pe[gr], pe_MS[gr],
  476. tot_ener[gr], blocktype);
  477. }
  478. if (ret != 0)
  479. return -4;
  480.  
  481. if (gfp.mode == MPEGMode.JOINT_STEREO) {
  482. ms_ener_ratio[gr] = tot_ener[gr][2] + tot_ener[gr][3];
  483. if (ms_ener_ratio[gr] > 0)
  484. ms_ener_ratio[gr] = tot_ener[gr][3] / ms_ener_ratio[gr];
  485. }
  486.  
  487. /* block type flags */
  488. for (ch = 0; ch < gfc.channels_out; ch++) {
  489. var cod_info = gfc.l3_side.tt[gr][ch];
  490. cod_info.block_type = blocktype[ch];
  491. cod_info.mixed_block_flag = 0;
  492. }
  493. }
  494. } else {
  495. /* no psy model */
  496. for (gr = 0; gr < gfc.mode_gr; gr++)
  497. for (ch = 0; ch < gfc.channels_out; ch++) {
  498. gfc.l3_side.tt[gr][ch].block_type = Encoder.NORM_TYPE;
  499. gfc.l3_side.tt[gr][ch].mixed_block_flag = 0;
  500. pe_MS[gr][ch] = pe[gr][ch] = 700;
  501. }
  502. }
  503.  
  504. /* auto-adjust of ATH, useful for low volume */
  505. adjust_ATH(gfc);
  506.  
  507. /****************************************
  508. * Stage 2: MDCT *
  509. ****************************************/
  510.  
  511. /* polyphase filtering / mdct */
  512. newMDCT.mdct_sub48(gfc, inbuf[0], inbuf[1]);
  513.  
  514. /****************************************
  515. * Stage 3: MS/LR decision *
  516. ****************************************/
  517.  
  518. /* Here will be selected MS or LR coding of the 2 stereo channels */
  519. gfc.mode_ext = Encoder.MPG_MD_LR_LR;
  520.  
  521. if (gfp.force_ms) {
  522. gfc.mode_ext = Encoder.MPG_MD_MS_LR;
  523. } else if (gfp.mode == MPEGMode.JOINT_STEREO) {
  524. /*
  525. * ms_ratio = is scaled, for historical reasons, to look like a
  526. * ratio of side_channel / total. 0 = signal is 100% mono .5 = L & R
  527. * uncorrelated
  528. */
  529.  
  530. /**
  531. * <PRE>
  532. * [0] and [1] are the results for the two granules in MPEG-1,
  533. * in MPEG-2 it's only a faked averaging of the same value
  534. * _prev is the value of the last granule of the previous frame
  535. * _next is the value of the first granule of the next frame
  536. * </PRE>
  537. */
  538.  
  539. var sum_pe_MS = 0.;
  540. var sum_pe_LR = 0.;
  541. for (gr = 0; gr < gfc.mode_gr; gr++) {
  542. for (ch = 0; ch < gfc.channels_out; ch++) {
  543. sum_pe_MS += pe_MS[gr][ch];
  544. sum_pe_LR += pe[gr][ch];
  545. }
  546. }
  547.  
  548. /* based on PE: M/S coding would not use much more bits than L/R */
  549. if (sum_pe_MS <= 1.00 * sum_pe_LR) {
  550.  
  551. var gi0 = gfc.l3_side.tt[0];
  552. var gi1 = gfc.l3_side.tt[gfc.mode_gr - 1];
  553.  
  554. if (gi0[0].block_type == gi0[1].block_type
  555. && gi1[0].block_type == gi1[1].block_type) {
  556.  
  557. gfc.mode_ext = Encoder.MPG_MD_MS_LR;
  558. }
  559. }
  560. }
  561.  
  562. /* bit and noise allocation */
  563. if (gfc.mode_ext == MPG_MD_MS_LR) {
  564. masking = masking_MS;
  565. /* use MS masking */
  566. pe_use = pe_MS;
  567. } else {
  568. masking = masking_LR;
  569. /* use LR masking */
  570. pe_use = pe;
  571. }
  572.  
  573. /* copy data for MP3 frame analyzer */
  574. if (gfp.analysis && gfc.pinfo != null) {
  575. for (gr = 0; gr < gfc.mode_gr; gr++) {
  576. for (ch = 0; ch < gfc.channels_out; ch++) {
  577. gfc.pinfo.ms_ratio[gr] = gfc.ms_ratio[gr];
  578. gfc.pinfo.ms_ener_ratio[gr] = ms_ener_ratio[gr];
  579. gfc.pinfo.blocktype[gr][ch] = gfc.l3_side.tt[gr][ch].block_type;
  580. gfc.pinfo.pe[gr][ch] = pe_use[gr][ch];
  581. System.arraycopy(gfc.l3_side.tt[gr][ch].xr, 0,
  582. gfc.pinfo.xr[gr][ch], 0, 576);
  583. /*
  584. * in psymodel, LR and MS data was stored in pinfo. switch
  585. * to MS data:
  586. */
  587. if (gfc.mode_ext == MPG_MD_MS_LR) {
  588. gfc.pinfo.ers[gr][ch] = gfc.pinfo.ers[gr][ch + 2];
  589. System.arraycopy(gfc.pinfo.energy[gr][ch + 2], 0,
  590. gfc.pinfo.energy[gr][ch], 0,
  591. gfc.pinfo.energy[gr][ch].length);
  592. }
  593. }
  594. }
  595. }
  596.  
  597. /****************************************
  598. * Stage 4: quantization loop *
  599. ****************************************/
  600.  
  601. if (gfp.VBR == VbrMode.vbr_off || gfp.VBR == VbrMode.vbr_abr) {
  602.  
  603. var i;
  604. var f;
  605.  
  606. for (i = 0; i < 18; i++)
  607. gfc.nsPsy.pefirbuf[i] = gfc.nsPsy.pefirbuf[i + 1];
  608.  
  609. f = 0.0;
  610. for (gr = 0; gr < gfc.mode_gr; gr++)
  611. for (ch = 0; ch < gfc.channels_out; ch++)
  612. f += pe_use[gr][ch];
  613. gfc.nsPsy.pefirbuf[18] = f;
  614.  
  615. f = gfc.nsPsy.pefirbuf[9];
  616. for (i = 0; i < 9; i++)
  617. f += (gfc.nsPsy.pefirbuf[i] + gfc.nsPsy.pefirbuf[18 - i])
  618. * Encoder.fircoef[i];
  619.  
  620. f = (670 * 5 * gfc.mode_gr * gfc.channels_out) / f;
  621. for (gr = 0; gr < gfc.mode_gr; gr++) {
  622. for (ch = 0; ch < gfc.channels_out; ch++) {
  623. pe_use[gr][ch] *= f;
  624. }
  625. }
  626. }
  627. gfc.iteration_loop.iteration_loop(gfp, pe_use, ms_ener_ratio, masking);
  628.  
  629. /****************************************
  630. * Stage 5: bitstream formatting *
  631. ****************************************/
  632.  
  633. /* write the frame to the bitstream */
  634. bs.format_bitstream(gfp);
  635.  
  636. /* copy mp3 bit buffer into array */
  637. mp3count = bs.copy_buffer(gfc, mp3buf, mp3bufPos, mp3buf_size, 1);
  638.  
  639. if (gfp.bWriteVbrTag)
  640. vbr.addVbrFrame(gfp);
  641.  
  642. if (gfp.analysis && gfc.pinfo != null) {
  643. for (ch = 0; ch < gfc.channels_out; ch++) {
  644. var j;
  645. for (j = 0; j < FFTOFFSET; j++)
  646. gfc.pinfo.pcmdata[ch][j] = gfc.pinfo.pcmdata[ch][j
  647. + gfp.framesize];
  648. for (j = FFTOFFSET; j < 1600; j++) {
  649. gfc.pinfo.pcmdata[ch][j] = inbuf[ch][j - FFTOFFSET];
  650. }
  651. }
  652. qupvt.set_frame_pinfo(gfp, masking);
  653. }
  654.  
  655. updateStats(gfc);
  656.  
  657. return mp3count;
  658. }
  659. }
  660.  
  661.  
  662. module.exports = Encoder;