mapping0.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845
  1. /********************************************************************
  2. * *
  3. * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
  4. * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
  5. * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  6. * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
  7. * *
  8. * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
  9. * by the XIPHOPHORUS Company http://www.xiph.org/ *
  10. * *
  11. ********************************************************************
  12. function: channel mapping 0 implementation
  13. last mod: $Id: mapping0.c,v 1.61 2003/12/30 11:02:22 xiphmont Exp $
  14. ********************************************************************/
  15. #include <stdlib.h>
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <math.h>
  19. #include <ogg/ogg.h>
  20. #include "vorbis/codec.h"
  21. #include "codec_internal.h"
  22. #include "codebook.h"
  23. #include "window.h"
  24. #include "registry.h"
  25. #include "psy.h"
  26. #include "misc.h"
  27. /* simplistic, wasteful way of doing this (unique lookup for each
  28. mode/submapping); there should be a central repository for
  29. identical lookups. That will require minor work, so I'm putting it
  30. off as low priority.
  31. Why a lookup for each backend in a given mode? Because the
  32. blocksize is set by the mode, and low backend lookups may require
  33. parameters from other areas of the mode/mapping */
  34. static void mapping0_free_info(vorbis_info_mapping *i){
  35. vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)i;
  36. if(info){
  37. memset(info,0,sizeof(*info));
  38. _ogg_free(info);
  39. }
  40. }
  41. static int ilog(unsigned int v){
  42. int ret=0;
  43. if(v)--v;
  44. while(v){
  45. ret++;
  46. v>>=1;
  47. }
  48. return(ret);
  49. }
  50. static void mapping0_pack(vorbis_info *vi,vorbis_info_mapping *vm,
  51. oggpack_buffer *opb){
  52. int i;
  53. vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)vm;
  54. /* another 'we meant to do it this way' hack... up to beta 4, we
  55. packed 4 binary zeros here to signify one submapping in use. We
  56. now redefine that to mean four bitflags that indicate use of
  57. deeper features; bit0:submappings, bit1:coupling,
  58. bit2,3:reserved. This is backward compatable with all actual uses
  59. of the beta code. */
  60. if(info->submaps>1){
  61. oggpack_write(opb,1,1);
  62. oggpack_write(opb,info->submaps-1,4);
  63. }else
  64. oggpack_write(opb,0,1);
  65. if(info->coupling_steps>0){
  66. oggpack_write(opb,1,1);
  67. oggpack_write(opb,info->coupling_steps-1,8);
  68. for(i=0;i<info->coupling_steps;i++){
  69. oggpack_write(opb,info->coupling_mag[i],ilog(vi->channels));
  70. oggpack_write(opb,info->coupling_ang[i],ilog(vi->channels));
  71. }
  72. }else
  73. oggpack_write(opb,0,1);
  74. oggpack_write(opb,0,2); /* 2,3:reserved */
  75. /* we don't write the channel submappings if we only have one... */
  76. if(info->submaps>1){
  77. for(i=0;i<vi->channels;i++)
  78. oggpack_write(opb,info->chmuxlist[i],4);
  79. }
  80. for(i=0;i<info->submaps;i++){
  81. oggpack_write(opb,0,8); /* time submap unused */
  82. oggpack_write(opb,info->floorsubmap[i],8);
  83. oggpack_write(opb,info->residuesubmap[i],8);
  84. }
  85. }
  86. /* also responsible for range checking */
  87. static vorbis_info_mapping *mapping0_unpack(vorbis_info *vi,oggpack_buffer *opb){
  88. int i;
  89. vorbis_info_mapping0 *info=_ogg_calloc(1,sizeof(*info));
  90. codec_setup_info *ci=vi->codec_setup;
  91. memset(info,0,sizeof(*info));
  92. if(oggpack_read(opb,1))
  93. info->submaps=oggpack_read(opb,4)+1;
  94. else
  95. info->submaps=1;
  96. if(oggpack_read(opb,1)){
  97. info->coupling_steps=oggpack_read(opb,8)+1;
  98. for(i=0;i<info->coupling_steps;i++){
  99. int testM=info->coupling_mag[i]=oggpack_read(opb,ilog(vi->channels));
  100. int testA=info->coupling_ang[i]=oggpack_read(opb,ilog(vi->channels));
  101. if(testM<0 ||
  102. testA<0 ||
  103. testM==testA ||
  104. testM>=vi->channels ||
  105. testA>=vi->channels) goto err_out;
  106. }
  107. }
  108. if(oggpack_read(opb,2)>0)goto err_out; /* 2,3:reserved */
  109. if(info->submaps>1){
  110. for(i=0;i<vi->channels;i++){
  111. info->chmuxlist[i]=oggpack_read(opb,4);
  112. if(info->chmuxlist[i]>=info->submaps)goto err_out;
  113. }
  114. }
  115. for(i=0;i<info->submaps;i++){
  116. oggpack_read(opb,8); /* time submap unused */
  117. info->floorsubmap[i]=oggpack_read(opb,8);
  118. if(info->floorsubmap[i]>=ci->floors)goto err_out;
  119. info->residuesubmap[i]=oggpack_read(opb,8);
  120. if(info->residuesubmap[i]>=ci->residues)goto err_out;
  121. }
  122. return info;
  123. err_out:
  124. mapping0_free_info(info);
  125. return(NULL);
  126. }
  127. #include "os.h"
  128. #include "lpc.h"
  129. #include "lsp.h"
  130. #include "envelope.h"
  131. #include "mdct.h"
  132. #include "psy.h"
  133. #include "scales.h"
  134. #if 0
  135. static long seq=0;
  136. static ogg_int64_t total=0;
  137. static float FLOOR1_fromdB_LOOKUP[256]={
  138. 1.0649863e-07F, 1.1341951e-07F, 1.2079015e-07F, 1.2863978e-07F,
  139. 1.3699951e-07F, 1.4590251e-07F, 1.5538408e-07F, 1.6548181e-07F,
  140. 1.7623575e-07F, 1.8768855e-07F, 1.9988561e-07F, 2.128753e-07F,
  141. 2.2670913e-07F, 2.4144197e-07F, 2.5713223e-07F, 2.7384213e-07F,
  142. 2.9163793e-07F, 3.1059021e-07F, 3.3077411e-07F, 3.5226968e-07F,
  143. 3.7516214e-07F, 3.9954229e-07F, 4.2550680e-07F, 4.5315863e-07F,
  144. 4.8260743e-07F, 5.1396998e-07F, 5.4737065e-07F, 5.8294187e-07F,
  145. 6.2082472e-07F, 6.6116941e-07F, 7.0413592e-07F, 7.4989464e-07F,
  146. 7.9862701e-07F, 8.5052630e-07F, 9.0579828e-07F, 9.6466216e-07F,
  147. 1.0273513e-06F, 1.0941144e-06F, 1.1652161e-06F, 1.2409384e-06F,
  148. 1.3215816e-06F, 1.4074654e-06F, 1.4989305e-06F, 1.5963394e-06F,
  149. 1.7000785e-06F, 1.8105592e-06F, 1.9282195e-06F, 2.0535261e-06F,
  150. 2.1869758e-06F, 2.3290978e-06F, 2.4804557e-06F, 2.6416497e-06F,
  151. 2.8133190e-06F, 2.9961443e-06F, 3.1908506e-06F, 3.3982101e-06F,
  152. 3.6190449e-06F, 3.8542308e-06F, 4.1047004e-06F, 4.3714470e-06F,
  153. 4.6555282e-06F, 4.9580707e-06F, 5.2802740e-06F, 5.6234160e-06F,
  154. 5.9888572e-06F, 6.3780469e-06F, 6.7925283e-06F, 7.2339451e-06F,
  155. 7.7040476e-06F, 8.2047000e-06F, 8.7378876e-06F, 9.3057248e-06F,
  156. 9.9104632e-06F, 1.0554501e-05F, 1.1240392e-05F, 1.1970856e-05F,
  157. 1.2748789e-05F, 1.3577278e-05F, 1.4459606e-05F, 1.5399272e-05F,
  158. 1.6400004e-05F, 1.7465768e-05F, 1.8600792e-05F, 1.9809576e-05F,
  159. 2.1096914e-05F, 2.2467911e-05F, 2.3928002e-05F, 2.5482978e-05F,
  160. 2.7139006e-05F, 2.8902651e-05F, 3.0780908e-05F, 3.2781225e-05F,
  161. 3.4911534e-05F, 3.7180282e-05F, 3.9596466e-05F, 4.2169667e-05F,
  162. 4.4910090e-05F, 4.7828601e-05F, 5.0936773e-05F, 5.4246931e-05F,
  163. 5.7772202e-05F, 6.1526565e-05F, 6.5524908e-05F, 6.9783085e-05F,
  164. 7.4317983e-05F, 7.9147585e-05F, 8.4291040e-05F, 8.9768747e-05F,
  165. 9.5602426e-05F, 0.00010181521F, 0.00010843174F, 0.00011547824F,
  166. 0.00012298267F, 0.00013097477F, 0.00013948625F, 0.00014855085F,
  167. 0.00015820453F, 0.00016848555F, 0.00017943469F, 0.00019109536F,
  168. 0.00020351382F, 0.00021673929F, 0.00023082423F, 0.00024582449F,
  169. 0.00026179955F, 0.00027881276F, 0.00029693158F, 0.00031622787F,
  170. 0.00033677814F, 0.00035866388F, 0.00038197188F, 0.00040679456F,
  171. 0.00043323036F, 0.00046138411F, 0.00049136745F, 0.00052329927F,
  172. 0.00055730621F, 0.00059352311F, 0.00063209358F, 0.00067317058F,
  173. 0.00071691700F, 0.00076350630F, 0.00081312324F, 0.00086596457F,
  174. 0.00092223983F, 0.00098217216F, 0.0010459992F, 0.0011139742F,
  175. 0.0011863665F, 0.0012634633F, 0.0013455702F, 0.0014330129F,
  176. 0.0015261382F, 0.0016253153F, 0.0017309374F, 0.0018434235F,
  177. 0.0019632195F, 0.0020908006F, 0.0022266726F, 0.0023713743F,
  178. 0.0025254795F, 0.0026895994F, 0.0028643847F, 0.0030505286F,
  179. 0.0032487691F, 0.0034598925F, 0.0036847358F, 0.0039241906F,
  180. 0.0041792066F, 0.0044507950F, 0.0047400328F, 0.0050480668F,
  181. 0.0053761186F, 0.0057254891F, 0.0060975636F, 0.0064938176F,
  182. 0.0069158225F, 0.0073652516F, 0.0078438871F, 0.0083536271F,
  183. 0.0088964928F, 0.009474637F, 0.010090352F, 0.010746080F,
  184. 0.011444421F, 0.012188144F, 0.012980198F, 0.013823725F,
  185. 0.014722068F, 0.015678791F, 0.016697687F, 0.017782797F,
  186. 0.018938423F, 0.020169149F, 0.021479854F, 0.022875735F,
  187. 0.024362330F, 0.025945531F, 0.027631618F, 0.029427276F,
  188. 0.031339626F, 0.033376252F, 0.035545228F, 0.037855157F,
  189. 0.040315199F, 0.042935108F, 0.045725273F, 0.048696758F,
  190. 0.051861348F, 0.055231591F, 0.058820850F, 0.062643361F,
  191. 0.066714279F, 0.071049749F, 0.075666962F, 0.080584227F,
  192. 0.085821044F, 0.091398179F, 0.097337747F, 0.10366330F,
  193. 0.11039993F, 0.11757434F, 0.12521498F, 0.13335215F,
  194. 0.14201813F, 0.15124727F, 0.16107617F, 0.17154380F,
  195. 0.18269168F, 0.19456402F, 0.20720788F, 0.22067342F,
  196. 0.23501402F, 0.25028656F, 0.26655159F, 0.28387361F,
  197. 0.30232132F, 0.32196786F, 0.34289114F, 0.36517414F,
  198. 0.38890521F, 0.41417847F, 0.44109412F, 0.46975890F,
  199. 0.50028648F, 0.53279791F, 0.56742212F, 0.60429640F,
  200. 0.64356699F, 0.68538959F, 0.72993007F, 0.77736504F,
  201. 0.82788260F, 0.88168307F, 0.9389798F, 1.F,
  202. };
  203. #endif
  204. extern int *floor1_fit(vorbis_block *vb,vorbis_look_floor *look,
  205. const float *logmdct, /* in */
  206. const float *logmask);
  207. extern int *floor1_interpolate_fit(vorbis_block *vb,vorbis_look_floor *look,
  208. int *A,int *B,
  209. int del);
  210. extern int floor1_encode(oggpack_buffer *opb,vorbis_block *vb,
  211. vorbis_look_floor *look,
  212. int *post,int *ilogmask);
  213. static int mapping0_forward(vorbis_block *vb){
  214. vorbis_dsp_state *vd=vb->vd;
  215. vorbis_info *vi=vd->vi;
  216. codec_setup_info *ci=vi->codec_setup;
  217. private_state *b=vb->vd->backend_state;
  218. vorbis_block_internal *vbi=(vorbis_block_internal *)vb->internal;
  219. int n=vb->pcmend;
  220. int i,j,k;
  221. int *nonzero = alloca(sizeof(*nonzero)*vi->channels);
  222. float **gmdct = _vorbis_block_alloc(vb,vi->channels*sizeof(*gmdct));
  223. int **ilogmaskch= _vorbis_block_alloc(vb,vi->channels*sizeof(*ilogmaskch));
  224. int ***floor_posts = _vorbis_block_alloc(vb,vi->channels*sizeof(*floor_posts));
  225. float global_ampmax=vbi->ampmax;
  226. float *local_ampmax=alloca(sizeof(*local_ampmax)*vi->channels);
  227. int blocktype=vbi->blocktype;
  228. int modenumber=vb->W;
  229. vorbis_info_mapping0 *info=ci->map_param[modenumber];
  230. vorbis_look_psy *psy_look=
  231. b->psy+blocktype+(vb->W?2:0);
  232. vb->mode=modenumber;
  233. for(i=0;i<vi->channels;i++){
  234. float scale=4.f/n;
  235. float scale_dB;
  236. float *pcm =vb->pcm[i];
  237. float *logfft =pcm;
  238. gmdct[i]=_vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
  239. scale_dB=todB(&scale) + .345; /* + .345 is a hack; the original
  240. todB estimation used on IEEE 754
  241. compliant machines had a bug that
  242. returned dB values about a third
  243. of a decibel too high. The bug
  244. was harmless because tunings
  245. implicitly took that into
  246. account. However, fixing the bug
  247. in the estimator requires
  248. changing all the tunings as well.
  249. For now, it's easier to sync
  250. things back up here, and
  251. recalibrate the tunings in the
  252. next major model upgrade. */
  253. #if 0
  254. if(vi->channels==2)
  255. if(i==0)
  256. _analysis_output("pcmL",seq,pcm,n,0,0,total-n/2);
  257. else
  258. _analysis_output("pcmR",seq,pcm,n,0,0,total-n/2);
  259. #endif
  260. /* window the PCM data */
  261. _vorbis_apply_window(pcm,b->window,ci->blocksizes,vb->lW,vb->W,vb->nW);
  262. #if 0
  263. if(vi->channels==2)
  264. if(i==0)
  265. _analysis_output("windowedL",seq,pcm,n,0,0,total-n/2);
  266. else
  267. _analysis_output("windowedR",seq,pcm,n,0,0,total-n/2);
  268. #endif
  269. /* transform the PCM data */
  270. /* only MDCT right now.... */
  271. mdct_forward(b->transform[vb->W][0],pcm,gmdct[i]);
  272. /* FFT yields more accurate tonal estimation (not phase sensitive) */
  273. drft_forward(&b->fft_look[vb->W],pcm);
  274. logfft[0]=scale_dB+todB(pcm) + .345; /* + .345 is a hack; the
  275. original todB estimation used on
  276. IEEE 754 compliant machines had a
  277. bug that returned dB values about
  278. a third of a decibel too high.
  279. The bug was harmless because
  280. tunings implicitly took that into
  281. account. However, fixing the bug
  282. in the estimator requires
  283. changing all the tunings as well.
  284. For now, it's easier to sync
  285. things back up here, and
  286. recalibrate the tunings in the
  287. next major model upgrade. */
  288. local_ampmax[i]=logfft[0];
  289. for(j=1;j<n-1;j+=2){
  290. float temp=pcm[j]*pcm[j]+pcm[j+1]*pcm[j+1];
  291. temp=logfft[(j+1)>>1]=scale_dB+.5f*todB(&temp) + .345; /* +
  292. .345 is a hack; the original todB
  293. estimation used on IEEE 754
  294. compliant machines had a bug that
  295. returned dB values about a third
  296. of a decibel too high. The bug
  297. was harmless because tunings
  298. implicitly took that into
  299. account. However, fixing the bug
  300. in the estimator requires
  301. changing all the tunings as well.
  302. For now, it's easier to sync
  303. things back up here, and
  304. recalibrate the tunings in the
  305. next major model upgrade. */
  306. if(temp>local_ampmax[i])local_ampmax[i]=temp;
  307. }
  308. if(local_ampmax[i]>0.f)local_ampmax[i]=0.f;
  309. if(local_ampmax[i]>global_ampmax)global_ampmax=local_ampmax[i];
  310. #if 0
  311. if(vi->channels==2){
  312. if(i==0){
  313. _analysis_output("fftL",seq,logfft,n/2,1,0,0);
  314. }else{
  315. _analysis_output("fftR",seq,logfft,n/2,1,0,0);
  316. }
  317. }
  318. #endif
  319. }
  320. {
  321. float *noise = _vorbis_block_alloc(vb,n/2*sizeof(*noise));
  322. float *tone = _vorbis_block_alloc(vb,n/2*sizeof(*tone));
  323. for(i=0;i<vi->channels;i++){
  324. /* the encoder setup assumes that all the modes used by any
  325. specific bitrate tweaking use the same floor */
  326. int submap=info->chmuxlist[i];
  327. /* the following makes things clearer to *me* anyway */
  328. float *mdct =gmdct[i];
  329. float *logfft =vb->pcm[i];
  330. float *logmdct =logfft+n/2;
  331. float *logmask =logfft;
  332. vb->mode=modenumber;
  333. floor_posts[i]=_vorbis_block_alloc(vb,PACKETBLOBS*sizeof(**floor_posts));
  334. memset(floor_posts[i],0,sizeof(**floor_posts)*PACKETBLOBS);
  335. for(j=0;j<n/2;j++)
  336. logmdct[j]=todB(mdct+j) + .345; /* + .345 is a hack; the original
  337. todB estimation used on IEEE 754
  338. compliant machines had a bug that
  339. returned dB values about a third
  340. of a decibel too high. The bug
  341. was harmless because tunings
  342. implicitly took that into
  343. account. However, fixing the bug
  344. in the estimator requires
  345. changing all the tunings as well.
  346. For now, it's easier to sync
  347. things back up here, and
  348. recalibrate the tunings in the
  349. next major model upgrade. */
  350. #if 0
  351. if(vi->channels==2){
  352. if(i==0)
  353. _analysis_output("mdctL",seq,logmdct,n/2,1,0,0);
  354. else
  355. _analysis_output("mdctR",seq,logmdct,n/2,1,0,0);
  356. }else{
  357. _analysis_output("mdct",seq,logmdct,n/2,1,0,0);
  358. }
  359. #endif
  360. /* first step; noise masking. Not only does 'noise masking'
  361. give us curves from which we can decide how much resolution
  362. to give noise parts of the spectrum, it also implicitly hands
  363. us a tonality estimate (the larger the value in the
  364. 'noise_depth' vector, the more tonal that area is) */
  365. _vp_noisemask(psy_look,
  366. logmdct,
  367. noise); /* noise does not have by-frequency offset
  368. bias applied yet */
  369. #if 0
  370. if(vi->channels==2){
  371. if(i==0)
  372. _analysis_output("noiseL",seq,noise,n/2,1,0,0);
  373. else
  374. _analysis_output("noiseR",seq,noise,n/2,1,0,0);
  375. }
  376. #endif
  377. /* second step: 'all the other crap'; all the stuff that isn't
  378. computed/fit for bitrate management goes in the second psy
  379. vector. This includes tone masking, peak limiting and ATH */
  380. _vp_tonemask(psy_look,
  381. logfft,
  382. tone,
  383. global_ampmax,
  384. local_ampmax[i]);
  385. #if 0
  386. if(vi->channels==2){
  387. if(i==0)
  388. _analysis_output("toneL",seq,tone,n/2,1,0,0);
  389. else
  390. _analysis_output("toneR",seq,tone,n/2,1,0,0);
  391. }
  392. #endif
  393. /* third step; we offset the noise vectors, overlay tone
  394. masking. We then do a floor1-specific line fit. If we're
  395. performing bitrate management, the line fit is performed
  396. multiple times for up/down tweakage on demand. */
  397. #if 0
  398. {
  399. float aotuv[psy_look->n];
  400. #endif
  401. _vp_offset_and_mix(psy_look,
  402. noise,
  403. tone,
  404. 1,
  405. logmask,
  406. mdct,
  407. logmdct);
  408. #if 0
  409. if(vi->channels==2){
  410. if(i==0)
  411. _analysis_output("aotuvM1_L",seq,aotuv,psy_look->n,1,1,0);
  412. else
  413. _analysis_output("aotuvM1_R",seq,aotuv,psy_look->n,1,1,0);
  414. }
  415. }
  416. #endif
  417. #if 0
  418. if(vi->channels==2){
  419. if(i==0)
  420. _analysis_output("mask1L",seq,logmask,n/2,1,0,0);
  421. else
  422. _analysis_output("mask1R",seq,logmask,n/2,1,0,0);
  423. }
  424. #endif
  425. /* this algorithm is hardwired to floor 1 for now; abort out if
  426. we're *not* floor1. This won't happen unless someone has
  427. broken the encode setup lib. Guard it anyway. */
  428. if(ci->floor_type[info->floorsubmap[submap]]!=1)return(-1);
  429. floor_posts[i][PACKETBLOBS/2]=
  430. floor1_fit(vb,b->flr[info->floorsubmap[submap]],
  431. logmdct,
  432. logmask);
  433. /* are we managing bitrate? If so, perform two more fits for
  434. later rate tweaking (fits represent hi/lo) */
  435. if(vorbis_bitrate_managed(vb) && floor_posts[i][PACKETBLOBS/2]){
  436. /* higher rate by way of lower noise curve */
  437. _vp_offset_and_mix(psy_look,
  438. noise,
  439. tone,
  440. 2,
  441. logmask,
  442. mdct,
  443. logmdct);
  444. #if 0
  445. if(vi->channels==2){
  446. if(i==0)
  447. _analysis_output("mask2L",seq,logmask,n/2,1,0,0);
  448. else
  449. _analysis_output("mask2R",seq,logmask,n/2,1,0,0);
  450. }
  451. #endif
  452. floor_posts[i][PACKETBLOBS-1]=
  453. floor1_fit(vb,b->flr[info->floorsubmap[submap]],
  454. logmdct,
  455. logmask);
  456. /* lower rate by way of higher noise curve */
  457. _vp_offset_and_mix(psy_look,
  458. noise,
  459. tone,
  460. 0,
  461. logmask,
  462. mdct,
  463. logmdct);
  464. #if 0
  465. if(vi->channels==2)
  466. if(i==0)
  467. _analysis_output("mask0L",seq,logmask,n/2,1,0,0);
  468. else
  469. _analysis_output("mask0R",seq,logmask,n/2,1,0,0);
  470. #endif
  471. floor_posts[i][0]=
  472. floor1_fit(vb,b->flr[info->floorsubmap[submap]],
  473. logmdct,
  474. logmask);
  475. /* we also interpolate a range of intermediate curves for
  476. intermediate rates */
  477. for(k=1;k<PACKETBLOBS/2;k++)
  478. floor_posts[i][k]=
  479. floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
  480. floor_posts[i][0],
  481. floor_posts[i][PACKETBLOBS/2],
  482. k*65536/(PACKETBLOBS/2));
  483. for(k=PACKETBLOBS/2+1;k<PACKETBLOBS-1;k++)
  484. floor_posts[i][k]=
  485. floor1_interpolate_fit(vb,b->flr[info->floorsubmap[submap]],
  486. floor_posts[i][PACKETBLOBS/2],
  487. floor_posts[i][PACKETBLOBS-1],
  488. (k-PACKETBLOBS/2)*65536/(PACKETBLOBS/2));
  489. }
  490. }
  491. }
  492. vbi->ampmax=global_ampmax;
  493. /*
  494. the next phases are performed once for vbr-only and PACKETBLOB
  495. times for bitrate managed modes.
  496. 1) encode actual mode being used
  497. 2) encode the floor for each channel, compute coded mask curve/res
  498. 3) normalize and couple.
  499. 4) encode residue
  500. 5) save packet bytes to the packetblob vector
  501. */
  502. /* iterate over the many masking curve fits we've created */
  503. {
  504. float **res_bundle=alloca(sizeof(*res_bundle)*vi->channels);
  505. float **couple_bundle=alloca(sizeof(*couple_bundle)*vi->channels);
  506. int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
  507. int **sortindex=alloca(sizeof(*sortindex)*vi->channels);
  508. float **mag_memo;
  509. int **mag_sort;
  510. if(info->coupling_steps){
  511. mag_memo=_vp_quantize_couple_memo(vb,
  512. &ci->psy_g_param,
  513. psy_look,
  514. info,
  515. gmdct);
  516. mag_sort=_vp_quantize_couple_sort(vb,
  517. psy_look,
  518. info,
  519. mag_memo);
  520. hf_reduction(&ci->psy_g_param,
  521. psy_look,
  522. info,
  523. mag_memo);
  524. }
  525. memset(sortindex,0,sizeof(*sortindex)*vi->channels);
  526. if(psy_look->vi->normal_channel_p){
  527. for(i=0;i<vi->channels;i++){
  528. float *mdct =gmdct[i];
  529. sortindex[i]=alloca(sizeof(**sortindex)*n/2);
  530. _vp_noise_normalize_sort(psy_look,mdct,sortindex[i]);
  531. }
  532. }
  533. for(k=(vorbis_bitrate_managed(vb)?0:PACKETBLOBS/2);
  534. k<=(vorbis_bitrate_managed(vb)?PACKETBLOBS-1:PACKETBLOBS/2);
  535. k++){
  536. oggpack_buffer *opb=vbi->packetblob[k];
  537. /* start out our new packet blob with packet type and mode */
  538. /* Encode the packet type */
  539. oggpack_write(opb,0,1);
  540. /* Encode the modenumber */
  541. /* Encode frame mode, pre,post windowsize, then dispatch */
  542. oggpack_write(opb,modenumber,b->modebits);
  543. if(vb->W){
  544. oggpack_write(opb,vb->lW,1);
  545. oggpack_write(opb,vb->nW,1);
  546. }
  547. /* encode floor, compute masking curve, sep out residue */
  548. for(i=0;i<vi->channels;i++){
  549. int submap=info->chmuxlist[i];
  550. float *mdct =gmdct[i];
  551. float *res =vb->pcm[i];
  552. int *ilogmask=ilogmaskch[i]=
  553. _vorbis_block_alloc(vb,n/2*sizeof(**gmdct));
  554. nonzero[i]=floor1_encode(opb,vb,b->flr[info->floorsubmap[submap]],
  555. floor_posts[i][k],
  556. ilogmask);
  557. #if 0
  558. {
  559. char buf[80];
  560. sprintf(buf,"maskI%c%d",i?'R':'L',k);
  561. float work[n/2];
  562. for(j=0;j<n/2;j++)
  563. work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]];
  564. _analysis_output(buf,seq,work,n/2,1,1,0);
  565. }
  566. #endif
  567. _vp_remove_floor(psy_look,
  568. mdct,
  569. ilogmask,
  570. res,
  571. ci->psy_g_param.sliding_lowpass[vb->W][k]);
  572. _vp_noise_normalize(psy_look,res,res+n/2,sortindex[i]);
  573. #if 0
  574. {
  575. char buf[80];
  576. float work[n/2];
  577. for(j=0;j<n/2;j++)
  578. work[j]=FLOOR1_fromdB_LOOKUP[ilogmask[j]]*(res+n/2)[j];
  579. sprintf(buf,"resI%c%d",i?'R':'L',k);
  580. _analysis_output(buf,seq,work,n/2,1,1,0);
  581. }
  582. #endif
  583. }
  584. /* our iteration is now based on masking curve, not prequant and
  585. coupling. Only one prequant/coupling step */
  586. /* quantize/couple */
  587. /* incomplete implementation that assumes the tree is all depth
  588. one, or no tree at all */
  589. if(info->coupling_steps){
  590. _vp_couple(k,
  591. &ci->psy_g_param,
  592. psy_look,
  593. info,
  594. vb->pcm,
  595. mag_memo,
  596. mag_sort,
  597. ilogmaskch,
  598. nonzero,
  599. ci->psy_g_param.sliding_lowpass[vb->W][k]);
  600. }
  601. /* classify and encode by submap */
  602. for(i=0;i<info->submaps;i++){
  603. int ch_in_bundle=0;
  604. long **classifications;
  605. int resnum=info->residuesubmap[i];
  606. for(j=0;j<vi->channels;j++){
  607. if(info->chmuxlist[j]==i){
  608. zerobundle[ch_in_bundle]=0;
  609. if(nonzero[j])zerobundle[ch_in_bundle]=1;
  610. res_bundle[ch_in_bundle]=vb->pcm[j];
  611. couple_bundle[ch_in_bundle++]=vb->pcm[j]+n/2;
  612. }
  613. }
  614. classifications=_residue_P[ci->residue_type[resnum]]->
  615. class(vb,b->residue[resnum],couple_bundle,zerobundle,ch_in_bundle);
  616. _residue_P[ci->residue_type[resnum]]->
  617. forward(opb,vb,b->residue[resnum],
  618. couple_bundle,NULL,zerobundle,ch_in_bundle,classifications);
  619. }
  620. /* ok, done encoding. Next protopacket. */
  621. }
  622. }
  623. #if 0
  624. seq++;
  625. total+=ci->blocksizes[vb->W]/4+ci->blocksizes[vb->nW]/4;
  626. #endif
  627. return(0);
  628. }
  629. static int mapping0_inverse(vorbis_block *vb,vorbis_info_mapping *l){
  630. vorbis_dsp_state *vd=vb->vd;
  631. vorbis_info *vi=vd->vi;
  632. codec_setup_info *ci=vi->codec_setup;
  633. private_state *b=vd->backend_state;
  634. vorbis_info_mapping0 *info=(vorbis_info_mapping0 *)l;
  635. int hs=ci->halfrate_flag;
  636. int i,j;
  637. long n=vb->pcmend=ci->blocksizes[vb->W];
  638. float **pcmbundle=alloca(sizeof(*pcmbundle)*vi->channels);
  639. int *zerobundle=alloca(sizeof(*zerobundle)*vi->channels);
  640. int *nonzero =alloca(sizeof(*nonzero)*vi->channels);
  641. void **floormemo=alloca(sizeof(*floormemo)*vi->channels);
  642. /* recover the spectral envelope; store it in the PCM vector for now */
  643. for(i=0;i<vi->channels;i++){
  644. int submap=info->chmuxlist[i];
  645. floormemo[i]=_floor_P[ci->floor_type[info->floorsubmap[submap]]]->
  646. inverse1(vb,b->flr[info->floorsubmap[submap]]);
  647. if(floormemo[i])
  648. nonzero[i]=1;
  649. else
  650. nonzero[i]=0;
  651. memset(vb->pcm[i],0,sizeof(*vb->pcm[i])*n/2);
  652. }
  653. /* channel coupling can 'dirty' the nonzero listing */
  654. for(i=0;i<info->coupling_steps;i++){
  655. if(nonzero[info->coupling_mag[i]] ||
  656. nonzero[info->coupling_ang[i]]){
  657. nonzero[info->coupling_mag[i]]=1;
  658. nonzero[info->coupling_ang[i]]=1;
  659. }
  660. }
  661. /* recover the residue into our working vectors */
  662. for(i=0;i<info->submaps;i++){
  663. int ch_in_bundle=0;
  664. for(j=0;j<vi->channels;j++){
  665. if(info->chmuxlist[j]==i){
  666. if(nonzero[j])
  667. zerobundle[ch_in_bundle]=1;
  668. else
  669. zerobundle[ch_in_bundle]=0;
  670. pcmbundle[ch_in_bundle++]=vb->pcm[j];
  671. }
  672. }
  673. _residue_P[ci->residue_type[info->residuesubmap[i]]]->
  674. inverse(vb,b->residue[info->residuesubmap[i]],
  675. pcmbundle,zerobundle,ch_in_bundle);
  676. }
  677. /* channel coupling */
  678. for(i=info->coupling_steps-1;i>=0;i--){
  679. float *pcmM=vb->pcm[info->coupling_mag[i]];
  680. float *pcmA=vb->pcm[info->coupling_ang[i]];
  681. for(j=0;j<n/2;j++){
  682. float mag=pcmM[j];
  683. float ang=pcmA[j];
  684. if(mag>0)
  685. if(ang>0){
  686. pcmM[j]=mag;
  687. pcmA[j]=mag-ang;
  688. }else{
  689. pcmA[j]=mag;
  690. pcmM[j]=mag+ang;
  691. }
  692. else
  693. if(ang>0){
  694. pcmM[j]=mag;
  695. pcmA[j]=mag+ang;
  696. }else{
  697. pcmA[j]=mag;
  698. pcmM[j]=mag-ang;
  699. }
  700. }
  701. }
  702. /* compute and apply spectral envelope */
  703. for(i=0;i<vi->channels;i++){
  704. float *pcm=vb->pcm[i];
  705. int submap=info->chmuxlist[i];
  706. _floor_P[ci->floor_type[info->floorsubmap[submap]]]->
  707. inverse2(vb,b->flr[info->floorsubmap[submap]],
  708. floormemo[i],pcm);
  709. }
  710. /* transform the PCM data; takes PCM vector, vb; modifies PCM vector */
  711. /* only MDCT right now.... */
  712. for(i=0;i<vi->channels;i++){
  713. float *pcm=vb->pcm[i];
  714. mdct_backward(b->transform[vb->W][0],pcm,pcm);
  715. }
  716. /* all done! */
  717. return(0);
  718. }
  719. /* export hooks */
  720. vorbis_func_mapping mapping0_exportbundle={
  721. &mapping0_pack,
  722. &mapping0_unpack,
  723. &mapping0_free_info,
  724. &mapping0_forward,
  725. &mapping0_inverse
  726. };