API tools faq
paste
cr88192

MBlkADPCM1 Test Code

cr88192
Mar 7th, 2022
1,333
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.39 KB | None | 0 0
raw download clone embed print report
  1. #include "tfau_multi.c"
  2.  
  3. static int mblk1_step5idx_table[32]={
  4.        1,    1,    2,     3,     4,     6,     8,    12,
  5.       16,   24,   32,    48,    64,    96,   128,   192,
  6.      256,  384,  512,   768,  1024,  1536,  2048,  3072,
  7.     4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152
  8. };
  9.  
  10. static int mblk1_step6idx_table[64]={
  11.         0,     1,     2,     3,
  12.         4,     5,     6,     7,
  13.         8,    10,    12,    14,
  14.        16,    20,    24,    28,
  15.        32,    40,    48,    56,
  16.        64,    80,    96,   112,
  17.       128,   160,   192,   224,
  18.       256,   320,   384,   448,
  19.       512,   640,   768,   896,
  20.      1024,  1280,  1536,  1792,
  21.      2048,  2560,  3072,  3584,
  22.      4096,  5120,  6144,  7168,
  23.      8192, 10240, 12288, 14436,
  24.     16384, 20480, 24576, 28672,
  25.     32768, 40960, 49152, 57344,
  26.     65536, 81920, 98304, 114688
  27. };
  28.  
  29. //signed char mblk1_stepadj_tab[16] = {
  30. //  -1, -1, -1, 0, 0, 1, 2, 4,
  31. //  -1, -1, -1, 0, 0, 1, 2, 4   };
  32.  
  33. signed char mblk1_stepadj_tab[16] = {
  34.     -1, -1, 0, 0, 1, 2, 4, 8,
  35.     -1, -1, 0, 0, 1, 2, 4, 8    };
  36.  
  37. signed char mblk1_stepscl_tab[16] = {
  38.      1,  3,  5,  7,  9,  11,  13,  15,
  39.     -1, -3, -5, -7, -9, -11, -13, -15
  40. };
  41.  
  42. int MBlk1_DecodeBlkInitSample(u16 head)
  43. {
  44.     int sv, e;
  45.  
  46. #if 0
  47. //  sv=(head>>4)&0x00F8;
  48.     sv=(head>>4)&0x00FC;
  49.     e=(head>>12)&7;
  50.     if(e)
  51.         { sv|=0x0100; e--; }
  52.     sv=sv<<(e+1);
  53.     if(head&0x8000)
  54.         sv=-sv;
  55.     return(sv);
  56. #endif
  57.  
  58. #if 1
  59.     e=(head>>11)&15;
  60.     sv=(head>>6)&0x001F;
  61.     if(e)
  62.         { sv|=0x0020; e--; }
  63.     sv=sv<<e;
  64.     if(head&0x8000)
  65.         sv=-sv;
  66. //      sv=~sv;
  67.     return(sv);
  68. #endif
  69.  
  70. }
  71.  
  72. int MBlk1_DecodeMonoInner(u16 *blk, s32 *samp, int bsz)
  73. {
  74.     u16 *cs, *cse;
  75.     s32 *ct;
  76.     int p, v;
  77.     int stix, stv, sb;
  78.     int i, j, k;
  79.    
  80.     k=blk[0];
  81.     p=MBlk1_DecodeBlkInitSample(k);
  82.     stix=k&63;
  83.    
  84.     p<<=3;
  85.    
  86.     ct=samp;
  87.     cs=blk+1;
  88.     cse=cs+(bsz>>2);
  89.     while(cs<cse)
  90.     {
  91.         sb=*cs++;
  92.         for(i=0; i<4; i++)
  93.         {
  94.             stv=mblk1_step6idx_table[stix];
  95.             j=(sb>>(i*4))&15;
  96. //          k=(mblk1_stepscl_tab[j]*stv)>>3;
  97.             k=(mblk1_stepscl_tab[j]*stv);
  98.             p=p+k;         
  99.             stix+=mblk1_stepadj_tab[j];
  100. //          *ct++=p;
  101.             *ct++=p>>3;
  102.         }
  103.     }
  104.     return(0);
  105. }
  106.  
  107. int MBlk1_DecodeMono(u16 *blk, s16 *samp, int bsz)
  108. {
  109.     s32 ctemp[256];
  110.     int i, k;
  111.    
  112.     MBlk1_DecodeMonoInner(blk, ctemp, bsz);
  113.    
  114.     for(i=0; i<bsz; i++)
  115.     {
  116.         k=ctemp[i];
  117.         if(k<(-32767))k=-32767;
  118.         if(k>( 32767))k= 32767;
  119.         samp[i]=k;
  120.     }
  121.     return(0);
  122. }
  123.  
  124. int MBlk1_DecodeStereo(u16 *blk, s16 *samp, int bsz, int bfl)
  125. {
  126.     s32 ctemp[256], stemp[68];
  127.     u16 *cs, *cse;
  128.     s16 *ct;
  129.     int p, v, pl, pr, pc, ps, ps0, ps1, ps2, ps3;
  130.     int stix, stv, sb;
  131.     int i, j, k;
  132.    
  133.     k=(bsz/4)+1;
  134.     MBlk1_DecodeMonoInner(blk+0, ctemp, bsz);
  135.     MBlk1_DecodeMonoInner(blk+k, stemp+2, bsz/4);
  136.  
  137.     j=blk[k];
  138.     ps1=MBlk1_DecodeBlkInitSample(j);
  139.     ps0=stemp[2];
  140. //  p=(3*ps1-ps0)>>1;
  141.     p=ps1;
  142.    
  143.     k=bsz/4;
  144.     stemp[0]=p; stemp[1]=p;
  145.     ps1=stemp[k+1];
  146.     stemp[k+2]=ps1; stemp[k+3]=ps1;
  147.    
  148.     ct=samp;
  149.     for(i=0; i<bsz; i++)
  150.     {
  151.         pc=ctemp[i];
  152. //      ps=stemp[i>>2];
  153. //      ps=stemp[(i>>2)+2];
  154.  
  155.         j=i+8-2;
  156. //      j=i+8-3;
  157. //      j=i+8-1;
  158.  
  159.         ps0=stemp[(j>>2)+0];
  160.         ps1=stemp[(j>>2)+1];   
  161.         k=(j&3)*2+1;
  162. //      ps=((ps0*(8-k))+(ps1*k))/8;
  163.         ps=((ps0*(8-k))+(ps1*k))>>3;
  164.    
  165. #if 0
  166.         ps2=stemp[(j>>2)-1];
  167.         ps3=stemp[(j>>2)+0];
  168.         k=(j&3)*2+9;
  169.         ps0=((ps2*(8-k))+(ps3*k))>>3;
  170.  
  171.         ps2=stemp[(j>>2)+1];
  172.         ps3=stemp[(j>>2)+2];
  173.         k=(j&3)*2-7;
  174.         ps1=((ps2*(8-k))+(ps3*k))>>3;
  175.  
  176.         k=(j&3)*2+1;
  177.         ps=((ps0*(8-k))+(ps1*k))>>3;
  178. #endif
  179.    
  180.         pl=pc-(ps>>1);
  181.         pr=pl+ps;
  182.  
  183. //      pl=pc-ps;
  184. //      pr=pl+2*ps;
  185.  
  186. //      pl=pc;
  187. //      pr=pc;
  188.  
  189.         if(pl<(-32767))pl=-32767;
  190.         if(pl>( 32767))pl= 32767;
  191.         if(pr<(-32767))pr=-32767;
  192.         if(pr>( 32767))pr= 32767;
  193.        
  194.         if(!i && (bfl&1))
  195.         {
  196.             /* Try to blend block edge. */
  197.             ps0=pl-ct[0];
  198.             ps1=pr-ct[1];
  199. //          ct[0]=pl+(ps0/4);
  200. //          ct[1]=pr+(ps1/4);
  201. //          ct[-2]+=(ps0/4);
  202. //          ct[-1]+=(ps1/4);
  203. //          ct[-4]+=(ps0/8);
  204. //          ct[-3]+=(ps1/8);
  205.  
  206.             ct[0]=pl;
  207.             ct[1]=pr;
  208.             ct[-2]+=(ps0/3);
  209.             ct[-1]+=(ps1/3);
  210.             ct[-4]+=(ps0/8);
  211.             ct[-3]+=(ps1/8);
  212. //          ct[-6]+=(ps0/16);
  213. //          ct[-5]+=(ps1/16);
  214.  
  215.             ct+=2;
  216.             continue;
  217.         }
  218.  
  219.         *ct++=pl;
  220.         *ct++=pr;
  221.     }
  222.  
  223.     if(bfl&2)
  224.     {
  225.         *ct++=pl;
  226.         *ct++=pr;
  227.     }
  228.    
  229.     return(0);
  230. }
  231.  
  232. int MBlk1_EncodeInitSamp(int sval, int stix, int spr)
  233. {
  234.     int sv, sg, se;
  235.     int k;
  236.    
  237.     sv=sval; sg=0; se=0;
  238.     if(sv<0)
  239.         { sv=-sv; sg=1; }
  240. //      { sv=~sv; sg=1; }
  241. //  sv>>=3;
  242. //  if(sv>=32)
  243. //      se++;
  244. //  while(sv>=64)
  245. //      { sv=sv>>1; se++; }
  246.  
  247. #if 0
  248.     sv>>=1;
  249.  
  250. //  sv>>=2;
  251. //  if(sv>=64)
  252.     if(sv>=256)
  253.     {
  254.         se++;
  255.     //  while(sv>=128)
  256.         while(sv>=512)
  257.             { sv=sv>>1; se++; }
  258.     //      { sv=(sv+1)>>1; se++; }
  259.  
  260.         sv=sv+1;
  261.         if(sv>=512)
  262.             { sv=sv>>1; se++; }
  263.     }else
  264.     {
  265.         sv=sv+2;
  266.         if(sv>=256)
  267.             se++;
  268.     }
  269.    
  270.     if(se>=8)
  271.     {
  272.         sv=511;
  273.         se=7;
  274.     }
  275.  
  276.     sv=sv>>2;
  277. //  sv=sv>>3;
  278. //  sv=(sv+2)>>2;
  279.  
  280. //  k=((sv&31)<<7)|(se<<12)|(sg<<15)|(stix&31)|((spr&3)<<5);
  281.     k=((sv&63)<<6)|(se<<12)|(sg<<15)|(stix&63);
  282. #endif
  283.  
  284. #if 1
  285.     sv<<=2;
  286.     if(sv>=128)
  287.     {
  288.         se++;
  289.         while(sv>=256)
  290.             { sv=sv>>1; se++; }
  291.         sv+=1;
  292.         if(sv>=256)
  293.             { sv=sv>>1; se++; }
  294.     }
  295.    
  296.  
  297. //  if(se>=8)
  298.     if(0)
  299.     {
  300.         if(se>=12)
  301.         {
  302.             sv=63;
  303.             se=11;
  304.         }
  305.  
  306.         se-=4;
  307.         sv>>=1;
  308.         k=((sv&63)<<6)|(se<<12)|(sg<<15)|(stix&63);
  309.     }else
  310.     {
  311.         sv>>=2;
  312.         k=((sv&31)<<6)|(se<<11)|(sg<<15)|(stix&63);
  313.     }
  314. #endif
  315.  
  316.     return(k);
  317. }
  318.  
  319. int MBlk1_EncodeMonoInner(u16 *blk, s32 *samp, int bsz, u32 *state)
  320. {
  321.     s32 *cs, *cse;
  322.     u16 *ct;
  323.     int stix, stv, spr, mxe;
  324.     int e0, e1, e2, e3;
  325.     int pa, pb, pc, pd, p0, p1, p2, p3, p, d, sv, sb;
  326.     int i, j, k;
  327.    
  328. //  p=(s16)(*state);
  329.     p=((s32)((*state)<<12))>>12;
  330. //  stix=((*state)>>16)&31;
  331. //  stix=((*state)>>16)&63;
  332.     stix=((*state)>>20)&63;
  333. //  spr=((*state)>>21)&3;
  334. //  spr=((*state)>>22)&3;
  335.    
  336.     spr=0;
  337.    
  338. //  stix=stix+4;
  339. //  if(stix>63)stix=63;
  340.    
  341.     ct=blk;
  342.     k=MBlk1_EncodeInitSamp(p, stix, spr);
  343.     sv=MBlk1_DecodeBlkInitSample(k);
  344.  
  345.     stv=mblk1_step6idx_table[stix];
  346.     while((abs(p-sv)>=stv) && (stix<63))
  347.     {
  348.         stix++;
  349.         k=MBlk1_EncodeInitSamp(p, stix, spr);
  350.         sv=MBlk1_DecodeBlkInitSample(k);
  351.         stv=mblk1_step6idx_table[stix];
  352.     }
  353.  
  354.     *ct++=k;
  355.  
  356.     mxe=192;
  357.     if(abs(p)>16384)
  358.         mxe=384;
  359.     if(abs(p)>32768)
  360.         mxe=768;
  361.  
  362. //  if(abs(p-sv)>=192)
  363. //  if(abs(p-sv)>=384)
  364.     if(abs(p-sv)>=mxe)
  365.         printf("%d %d %d\n", p, sv, p-sv);
  366.  
  367.     e0=0; e1=0; e2=0; e3=0;
  368.     pa=sv;  pb=sv;  pc=sv;  pd=sv;
  369.     p=pa;
  370.    
  371.     pa<<=3;
  372.  
  373.     cs=samp; cse=cs+bsz;
  374.     while(cs<cse)
  375.     {
  376.         sb=0;
  377.         for(i=0; i<4; i++)
  378.         {
  379.             p=pa;
  380.  
  381.             stv=mblk1_step6idx_table[stix];
  382.             sv=*cs++;
  383.             sv<<=3;
  384.  
  385. #if 0
  386.             if(((cs+4)>=cse) || (cs==samp))
  387. //          if(1)
  388.             {
  389.                 k=MBlk1_EncodeInitSamp(sv, stix, spr);
  390.                 sv=MBlk1_DecodeBlkInitSample(k);
  391.             }
  392. #endif
  393.  
  394. //          d=sv-p;
  395.             d=(sv-p)>>3;
  396.             if(!stv)
  397.             {
  398.                 j=(d<0)?15:7;
  399.             }else
  400.                 if(d<0)
  401.             {
  402.                 d=-d;
  403.                 j=(d<<2)/stv;
  404. //              j=(d<<2)/(stv*8);
  405. //              j=(d<<3)/stv;
  406. //              j=(j-1)>>1;
  407.                 if(j>7)j=7;
  408.                 j|=8;
  409.             }else
  410.             {
  411.                 j=(d<<2)/stv;
  412. //              j=(d<<2)/(stv*8);
  413. //              j=(d<<3)/stv;
  414. //              j=(j-1)>>1;
  415.                 if(j>7)j=7;
  416.             }
  417.  
  418.             /* Avoid StepIndex going to 0. */
  419.             if((stix<2) && ((j&7)<4))
  420. //          if((stix<5) && ((j&7)<4))
  421.                 j=(d<0)?12:4;
  422.            
  423.             /* Avoid StepIndex going out of range. */
  424. //          if((stix>62) && ((j&7)>=4))
  425. //              j=(d<0)?11:3;
  426.             while((stix>=56) && ((stix+mblk1_stepadj_tab[j])>63))
  427.                 j--;
  428.            
  429.             if(j<0)j=0;
  430.  
  431. #if 1
  432.             pa=j;
  433.             pb=(j-1)&15;
  434.             pc=(j+1)&15;
  435. //          k=(mblk1_stepscl_tab[j]*stv)>>3;
  436.             k=(mblk1_stepscl_tab[j]*stv);
  437.             p0=p+k;
  438. //          k=(mblk1_stepscl_tab[pb]*stv)>>3;
  439.             k=(mblk1_stepscl_tab[pb]*stv);
  440.             p1=p+k;
  441. //          k=(mblk1_stepscl_tab[pc]*stv)>>3;
  442.             k=(mblk1_stepscl_tab[pc]*stv);
  443.             p2=p+k;
  444.            
  445.             if(abs(sv-p1)<abs(sv-p0))
  446.                 j=pb;
  447.             if(abs(sv-p2)<abs(sv-p0))
  448.                 j=pc;
  449. #endif
  450.  
  451.            
  452.             sb|=j<<(i*4);
  453.  
  454. //          k=(mblk1_stepscl_tab[j]*stv)>>3;
  455.             k=(mblk1_stepscl_tab[j]*stv);
  456.             p=p+k;
  457.             pa=p;
  458.            
  459.             stix+=mblk1_stepadj_tab[j];
  460.             if(stix&(~63))
  461.             {
  462.                 printf("MblkAd Enc, StIx Out of Range\n");
  463.                 if(stix< 0)stix= 0;
  464.                 if(stix>63)stix=63;
  465.             }
  466.         }
  467.         *ct++=sb;
  468.     }
  469.  
  470.     p>>=3;
  471.  
  472.     spr=0;
  473.  
  474. //  printf("%d", spr);
  475.  
  476. //  if(p<(-32767))p=-32767;
  477. //  if(p>( 32767))p= 32767;
  478.  
  479. //  if(p<(-49151))p=-49151;
  480. //  if(p>( 49151))p= 49151;
  481.  
  482.     if(p<(-98304))p=-98304;
  483.     if(p>( 98304))p= 98304;
  484.  
  485.     *state=(p&0xFFFFF)|(stix<<20);
  486.     return(0);
  487. }
  488.  
  489. int MBlk1_EncodeMono(u16 *blk, s16 *samp, int bsz, u32 *state)
  490. {
  491.     s32 ctemp[256];
  492.     int i;
  493.    
  494.     for(i=0; i<bsz; i++)
  495.         ctemp[i]=samp[i];
  496.  
  497.     MBlk1_EncodeMonoInner(blk, ctemp, bsz, state);
  498.     return(0);
  499. }
  500.  
  501. int MBlk1_EncodeStereo(u16 *blk, s16 *samp, int bsz,
  502.     u32 *cstate, u32 *sstate)
  503. {
  504.     s32 ctemp[288], stemp[72];
  505.     int pc0, pc1, pc2, pc3, ps0, ps1, ps2, ps3, pc;
  506.     int pl0, pl1, pl2, pl3, pr0, pr1, pr2, pr3, ps;
  507.     int pl4, pl5, pl6, pl7, pr4, pr5, pr6, pr7;
  508.     int pc4, pc5, pc6, pc7;
  509.     int i, j, k;
  510.    
  511. //  for(i=0; i<(bsz/4); i++)
  512.     for(i=0; i<=(bsz/4); i++)
  513.     {
  514.         pl0=samp[i*8+0];    pr0=samp[i*8+1];
  515.         pl1=samp[i*8+2];    pr1=samp[i*8+3];
  516.         pl2=samp[i*8+4];    pr2=samp[i*8+5];
  517.         pl3=samp[i*8+6];    pr3=samp[i*8+7];
  518.         pc0=(pl0+pr0)/2;    pc1=(pl1+pr1)/2;
  519.         pc2=(pl2+pr2)/2;    pc3=(pl3+pr3)/2;
  520.         ps0=pr0-pl0;        ps1=pr1-pl1;
  521.         ps2=pr2-pl2;        ps3=pr3-pl3;
  522. //      ps0=(pr0-pl0)/2;    ps1=(pr1-pl1)/2;
  523. //      ps2=(pr2-pl2)/2;    ps3=(pr3-pl3)/2;
  524. //      ps0=(pr0-pl0)/4;    ps1=(pr1-pl1)/4;
  525. //      ps2=(pr2-pl2)/4;    ps3=(pr3-pl3)/4;
  526.        
  527.         pc=(pc0+pc1+pc2+pc3)/4;
  528. //      ps=(ps0+ps1+ps2+ps3)/4;
  529.         ps=(ps0+3*ps1+3*ps2+ps3)/8;
  530.    
  531. //      ps=ps/2;
  532. //      ps=0;
  533.  
  534. //      if(ps<(-32767))ps=-32767;
  535. //      if(ps>( 32767))ps= 32767;
  536.  
  537. #if 0
  538.         pl4=pc0-(ps>>1);    pl5=pc1-(ps>>1);
  539.         pl6=pc2-(ps>>1);    pl7=pc3-(ps>>1);
  540.         pr4=pl4+ps;         pr5=pl5+ps;
  541.         pr6=pl6+ps;         pr7=pl7+ps;
  542.  
  543. //      pl4=pc0-ps;     pl5=pc1-ps;
  544. //      pl6=pc2-ps;     pl7=pc3-ps;
  545. //      pr4=pl4+ps*2;   pr5=pl5+ps*2;
  546. //      pr6=pl6+ps*2;   pr7=pl7+ps*2;
  547.    
  548. //      pc4=pc0+(((pl0-pl4)+(pr0-pr4))/2);
  549. //      pc5=pc1+(((pl1-pl5)+(pr1-pr5))/2);
  550. //      pc6=pc2+(((pl2-pl6)+(pr2-pr6))/2);
  551. //      pc7=pc3+(((pl3-pl7)+(pr3-pr7))/2);
  552.        
  553.         pc4=2*pc0-((pl4+pr4)/2);
  554.         pc5=2*pc1-((pl5+pr5)/2);
  555.         pc6=2*pc2-((pl6+pr6)/2);
  556.         pc7=2*pc3-((pl7+pr7)/2);
  557.  
  558.         pc4=pc0;
  559.         pc5=pc1;
  560.         pc6=pc2;
  561.         pc7=pc3;
  562. #endif
  563.  
  564.         ctemp[i*4+0]=pc0;
  565.         ctemp[i*4+1]=pc1;
  566.         ctemp[i*4+2]=pc2;
  567.         ctemp[i*4+3]=pc3;
  568.         stemp[i+2]=ps;
  569.     }
  570.  
  571. #if 0
  572.     j=(s16)(*sstate);
  573.     k=MBlk1_EncodeInitSamp(j, 0, 0);
  574.     j=MBlk1_DecodeBlkInitSample(k);
  575.     stemp[0]=j;
  576.     stemp[1]=j;
  577.  
  578. //  stemp[0]=(s16)(*sstate);
  579. //  stemp[1]=(s16)(*sstate);
  580. //  stemp[(bsz/4)+2]=ps;
  581. //  stemp[(bsz/4)+3]=ps;
  582.  
  583.     for(i=0; i<bsz; i++)
  584.     {
  585.         pl0=samp[i*2+0];    pr0=samp[i*2+1];
  586.         pc=(pl0+pr0)/2;
  587.  
  588.         pc0=ctemp[i];
  589. //      ps=stemp[i>>2];
  590.  
  591.         j=i+8-2;
  592.         ps0=stemp[(j>>2)+0];
  593.         ps1=stemp[(j>>2)+1];
  594.        
  595.         k=(j&3)*2+1;
  596.         ps=((ps0*(8-k))+(ps1*k))/8;
  597.        
  598. //      pl1=pc0-(ps>>1);
  599. //      pr1=pl1+ps;
  600.  
  601.         pl1=pc0-ps;
  602.         pr1=pl1+2*ps;
  603.  
  604.         pc1=2*pc-((pl1+pr1)/2);
  605.         ctemp[i]=pc1;
  606.     }
  607. #endif
  608.  
  609.     MBlk1_EncodeMonoInner(blk+0, ctemp, bsz, cstate);
  610.     MBlk1_EncodeMonoInner(blk+((bsz/4)+1), stemp+2, bsz/4, sstate);
  611.     return(0);
  612. }
  613.  
  614. int main(int argc, char *argv[])
  615. {
  616.     byte *tbuf;
  617.     s16 *ibuf, *obuf;
  618.     char *ifn, *ofn;
  619.     u64 tblk;
  620.     u32 testate, testate2;
  621.     int ilen, irate;
  622.     s64 err;
  623.     s64 e0, e1, e2, e3;
  624.     int d0, d1, d2, d3, bsz;
  625.     int pa, pb, pc, pd, p0, p1, p2, p3;
  626.     int i, j, k;
  627.    
  628.     ifn=NULL;
  629.     ofn=NULL;
  630.    
  631.     for(i=1; i<argc; i++)
  632.     {
  633.         if(argv[i][0]=='-')
  634.         {
  635.             continue;
  636.         }
  637.        
  638.         if(!ifn)
  639.         {
  640.             ifn=argv[i];
  641.             continue;
  642.         }
  643.  
  644.         if(!ofn)
  645.         {
  646.             ofn=argv[i];
  647.             continue;
  648.         }
  649.     }
  650.  
  651. //  irate=32000;
  652.     irate=16000;
  653.    
  654. //  ibuf=BGBMID_LoadWAV_16Mono16(ifn, &ilen);
  655. //  ibuf=BGBMID_LoadWAV_16Stereo16(ifn, &ilen);
  656. //  ibuf=BGBMID_LoadWAV_32Stereo16(ifn, &ilen);
  657.     ibuf=BGBMID_LoadWAV_RateStereo16(ifn, irate, &ilen);
  658.     obuf=malloc((ilen+32)*2*4*sizeof(s16));
  659.    
  660.  
  661.     err=0;
  662.    
  663.     tbuf=malloc(ilen);
  664.  
  665.     pa=ibuf[0]; pb=ibuf[0];
  666.     pc=ibuf[0]; pd=ibuf[0];
  667.     e0=0;   e1=0;
  668.     e2=0;   e3=0;
  669.     for(i=0; i<ilen; i++)
  670.     {
  671.         p0=pa;
  672.         p1=2*pa-pb;
  673. //      p2=3*pa-2*pb;
  674.         p2=(3*pa-pb)/2;
  675. //      p3=9*pa-6*pb-6*pc+4*pd;
  676.         p3=(9*pa-3*pb-3*pc+pd)/4;
  677.         k=ibuf[i];
  678.        
  679.         pd=pc; pc=pb; pb=pa; pa=k;
  680.        
  681.         d0=k-p0;    d1=k-p1;
  682.         d2=k-p2;    d3=k-p3;
  683. //      e0+=d0*d0;
  684. //      e1+=d1*d1;
  685. //      e2+=d2*d2;
  686. //      e3+=d3*d3;
  687.  
  688.         e0+=d0^(d0>>31);
  689.         e1+=d1^(d1>>31);
  690.         e2+=d2^(d2>>31);
  691.         e3+=d3^(d3>>31);
  692.     }
  693.  
  694.     d0=(e0/ilen);
  695.     d1=(e1/ilen);
  696.     d2=(e2/ilen);
  697.     d3=(e3/ilen);
  698.    
  699. //  d0=sqrt(e0/ilen);
  700. //  d1=sqrt(e1/ilen);
  701. //  d2=sqrt(e2/ilen);
  702. //  d3=sqrt(e3/ilen);
  703.     printf("%d %d %d %d\n", d0, d1, d2, d3);
  704.  
  705. //  printf("%lld %lld %lld %lld\n", e0, e1, e2, e3);
  706.    
  707.     bsz=256;
  708. //  bsz=64;
  709.     ilen=(ilen/bsz)*bsz;
  710. //  ilen=(ilen/1024)*1024;
  711.    
  712.     BGBMID_StoreWAV("mblk0_tr.wav", (byte *)ibuf, 2, irate, 16, ilen);
  713.    
  714.     testate=0;
  715.     testate2=0;
  716. //  for(i=0; i<(ilen/1024); i++)
  717.     for(i=0; i<(ilen/bsz); i++)
  718.     {
  719. //      MBlk1_EncodeMono((u16 *)(tbuf+(i*17*2)), ibuf+(i*64), 64, &testate);
  720. //      MBlk1_EncodeMono((u16 *)(tbuf+(i*257*2)), ibuf+(i*1024), 1024, &testate);
  721.  
  722.         MBlk1_EncodeStereo(
  723.             (u16 *)(tbuf+(i*(bsz/4+bsz/16+2)*2)),
  724.             ibuf+(i*bsz*2), bsz, &testate, &testate2);
  725.     }
  726.  
  727. //  for(i=0; i<(ilen/1024); i++)
  728.     for(i=0; i<(ilen/bsz); i++)
  729.     {
  730. //      MBlk1_DecodeMono((u16 *)(tbuf+(i*17*2)), obuf+(i*64), 64);
  731. //      MBlk1_DecodeMono((u16 *)(tbuf+(i*257*2)), obuf+(i*1024), 1024);
  732.         MBlk1_DecodeStereo(
  733.             (u16 *)(tbuf+(i*(bsz/4+bsz/16+2)*2)),
  734.             obuf+(i*bsz*2), bsz, 2|(i>0));
  735.     }
  736.  
  737.  
  738. //  BGBMID_StoreWAV("mblk0_ts0.wav", (byte *)obuf, 1, 16000, 16, ilen);
  739.     BGBMID_StoreWAV("mblk0_ts1.wav", (byte *)obuf, 2, irate, 16, ilen);
  740.  
  741.     e0=0; e1=0; e2=0;
  742.     for(i=0; i<ilen; i++)
  743.     {
  744.         p0=obuf[i*2+0];     p1=ibuf[i*2+0];
  745.         p2=obuf[i*2+1];     p3=ibuf[i*2+1];
  746.         j=p0-p1;
  747.         k=p2-p3;
  748.         e0+=j*j;
  749.         e1+=k*k;
  750.  
  751.         k=((p0+p2)/2)-((p1+p3)/2);
  752.         e2+=k*k;
  753.     }
  754.     printf("E=%f %f %f\n", sqrt(e0/ilen), sqrt(e1/ilen), sqrt(e2/ilen));
  755.  
  756.     return(0);
  757. }
  758.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!