Want more features on Pastebin? Sign Up, it's FREE!
Guest

Experimental Block Audio Codec 2

By: cr88192 on Apr 28th, 2013  |  syntax: C  |  size: 29.84 KB  |  views: 14  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. /*
  2. Copyright (C) 2013 by Brendan G Bohannon
  3. Email: cr88192@gmail.com
  4. Copying: http://pastebin.com/iJxtZHm6
  5.  */
  6.  
  7. #include <bgbtac.h>
  8.  
  9. /*
  10. Experimental block-based audio codec.
  11. Encodes blocks of 64 samples into 256 bits (32 bytes).
  12. At 44.1kHz this is 176kbps.
  13. It can encode stereo using a "naive joint stereo" encoding.
  14.  
  15. Most block formats will encode a single center channel and will offset it for the left/right channel.
  16.  
  17. Basic Format 0:
  18.         4 bit: Block-Mode (0)
  19.     currently unused (12 bits, zeroed)
  20.     16 bit min sample (center)
  21.     16 bit max sample (center)
  22.     8 bit left-center min (ssqrt)
  23.     8 bit left-center max (ssqrt)
  24.     64 Samples, 1 bits/sample (64 bits)
  25.     16x 4-bit min (64 bits)
  26.     16x 4-bit max (64 bits)
  27.  
  28. The 4-bit values interpolate between the full min/max for the block.
  29. The 1-bit samples select between the min and max value for each sample.
  30.  
  31. Note: Interpolated values are linear, thus 0=0/15, 1=1/15, 2=2/15, ..., 14=14/15, 15=15/15
  32.  
  33. Bit packing is in low-high order, and multibyte values are little-endian.
  34.  
  35. Basic Format 1:
  36.         4 bit: Block-Mode (1)
  37.         currently unused (12 bits, zeroed)
  38.         16 bit min sample (center)
  39.         16 bit max sample (center)
  40.         8 bit left-center min (ssqrt)
  41.         8 bit left-center max (ssqrt)
  42.         32x 2-bit sample (64 bits)
  43.         32x 4-bit sample (128 bits)
  44.  
  45. This directly codes all samples, with the 4-bit values encoding even samples, and the 2-bit values encoding odd samples.
  46.  
  47. The 4-bit samples are encoded between the block min/max values, and the 2-bit samples between the prior/next sample.
  48.  
  49. Sample interpolation (2 bit samples):
  50. 0=prior sample, 1=next sample, 2=average, 3=quadratic interpolated value.
  51.  
  52. Basic Format 2:
  53.         4 bit: Block-Mode (2)
  54.         currently unused (12 bits, zeroed)
  55.         16 bit min sample (center)
  56.         16 bit max sample (center)
  57.         8 bit left-center min (ssqrt)
  58.         8 bit left-center max (ssqrt)
  59.         32x 6-bit samples (192 bits)
  60.  
  61. This directly codes samples, with the 6-bit values encoding samples.
  62. The 6-bit samples are encoded between the block min/max values.
  63.  
  64. This mode encodes even samples, with odd-samples being interpolated (quadratic).
  65. The last sample is extrapolated.
  66.  
  67. Stereo Format 3:
  68.         4 bit: Block-Mode (3)
  69.         currently unused (12 bits, zeroed)
  70.         16 bit min sample (center)
  71.         16 bit max sample (center)
  72.         8 bit left-center min (ssqrt)
  73.         8 bit left-center max (ssqrt)
  74.         32x 2-bit pan (64 bits)
  75.         32x 4-bit sample (128 bits)
  76.  
  77. This directly codes samples, with the 4-bit values encoding even samples.
  78. The 2-bit pan value encodes the relative pan of the sample.
  79.  
  80. The 4-bit samples are encoded between the block min/max values.
  81.  
  82. The 2-bit samples represent values as:
  83. 0=center pan (offset):
  84.         The sample will be offset for left/right channels.
  85. 1=center-pan (duplicate):
  86.         The sample will be the same (center) value for both channels.
  87. 2=left-pan:
  88.         The sample will be panned towards the left.
  89. 3=right pan:
  90.         The sample will be panned towards the right.
  91.  
  92. This mode encodes even samples, with odd-samples being interpolated (quadratic).
  93.  
  94. Basic Format 4:
  95.         4 bit: Block-Mode (4)
  96.         currently unused (12 bits, zeroed)
  97.         16 bit min sample (center)
  98.         16 bit max sample (center)
  99.         8 bit left-center min (ssqrt)
  100.         8 bit left-center max (ssqrt)
  101.         8x 4-bit min (32 bits)
  102.         8x 4-bit max (32 bits)
  103.         64x 2-bit sample (128 bits)
  104.  
  105. The 4-bit values interpolate between the full min/max for the block.
  106. The 2-bit samples interpolate between the min and max values for each sub-block (0=min, 1=1/3, 2=2/3, 3=max).
  107.  
  108.  */
  109.  
  110. int bgbtac_ssqrti(int v)
  111. {
  112.         int i;
  113.         double f;
  114.         f=(v>=0)?sqrt(v):-sqrt(-v);
  115.         i=(int)(f+0.5);
  116.         return(i);
  117. }
  118.  
  119. int bgbtac_ssqri(int v)
  120. {
  121.         return((v>=0)?(v*v):(-v*v));
  122. }
  123.  
  124. int bgbtac_spowi(int v, float e)
  125. {
  126.         int i;
  127.         double f;
  128.         f=(v>=0)?pow(v, e):-pow(-v, e);
  129.         i=(int)(f+0.5);
  130.         return(i);
  131. }
  132.  
  133. void BGBTAC_EncodeBlockHeaderS16(
  134.         s16 *iblk, byte *oblk, s16 *tcblk,
  135.         int *rcm, int *rcn, int flags)
  136. {
  137.         int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  138.         int cm2, cn2, ca2, ba;
  139.         int p0, p1, p2, p3;
  140.         int s0, s1;
  141.         int i, j, k;
  142.  
  143. #if 1
  144.         lm= 99999; rm= 99999; cm= 99999;
  145.         ln=-99999; rn=-99999; cn=-99999;
  146.        
  147.         ba=0;
  148.         for(i=0; i<64; i++)
  149.         {
  150.                 if(flags&BGBTAC_EFL_HALFMONO)
  151.                         { tl=iblk[i*2+0]; tr=tl; }
  152.                 else if(flags&BGBTAC_EFL_STEREO)
  153.                         { tl=iblk[i*2+0]; tr=iblk[i*2+1]; }
  154.                 else
  155.                         { tl=iblk[i]; tr=tl; }
  156.                 k=(tl+tr)>>1;
  157.                 tcblk[i]=k;
  158.                 ba+=tl-k;
  159.                 if(k<cm) { lm=tl; rm=tr; cm=k; }
  160.                 if(k>cn) { ln=tl; rn=tr; cn=k; }
  161.         }
  162.  
  163.         ba/=64;
  164.        
  165.         if(flags&BGBTAC_EFL_MIDSTREAM)
  166.         {
  167.                 ba=0;
  168.                 for(i=-64; i<128; i++)
  169.                 {
  170.                         if(flags&BGBTAC_EFL_HALFMONO)
  171.                                 { tl=iblk[i*2+0]; tr=tl; }
  172.                         else if(flags&BGBTAC_EFL_STEREO)
  173.                                 { tl=iblk[i*2+0]; tr=iblk[i*2+1]; }
  174.                         else
  175.                                 { tl=iblk[i]; tr=tl; }
  176.                         k=(tl+tr)>>1;
  177.                         ba+=tl-k;
  178.                 }
  179.                 ba/=192;
  180.         }
  181.        
  182.         for(i=0; i<32; i++)
  183.                 { oblk[i]=0; }
  184.  
  185.         p0=lm-cm;
  186.         p1=ln-cn;
  187.         p2=ba;
  188.  
  189.         p0=(5*p0+11*p2)>>4;
  190.         p1=(5*p1+11*p2)>>4;
  191. //      p0=p2; p1=p2;
  192.  
  193.         if(flags&(BGBTAC_EFL_CENTERMONO|BGBTAC_EFL_HALFMONO))
  194.                 { p0=0; p1=0; }
  195.  
  196. //      p0/=2;  p1/=2;
  197.         p0=bgbtac_spowi(p0, 0.73);
  198.         p1=bgbtac_spowi(p1, 0.73);
  199.  
  200. //      p0=bgbtac_spowi(p0, 0.90);
  201. //      p1=bgbtac_spowi(p1, 0.90);
  202.  
  203. //      p0=bgbtac_spowi(p0, 0.80);
  204. //      p1=bgbtac_spowi(p1, 0.80);
  205.  
  206.         p0=bgbtac_ssqrti(p0);
  207.         p1=bgbtac_ssqrti(p1);
  208.  
  209.         p0=(p0<(-128))?(-128):((p0<128)?p0:127);
  210.         p1=(p1<(-128))?(-128):((p1<128)?p1:127);
  211.        
  212.         oblk[0]=0x00;
  213.         oblk[1]=0x00;
  214.  
  215.         oblk[2]=cm&0xFF;
  216.         oblk[3]=(cm>>8)&0xFF;
  217.         oblk[4]=cn&0xFF;
  218.         oblk[5]=(cn>>8)&0xFF;
  219.         oblk[6]=p0&0xFF;
  220.         oblk[7]=p1&0xFF;
  221. #endif
  222.  
  223.         *rcm=cm;
  224.         *rcn=cn;
  225. }
  226.  
  227. void BGBTAC_EncodeBlockHeaderPanS16(
  228.         s16 *iblk, byte *oblk,
  229.         s16 *tcblk, s16 *tcpan,
  230.         int *rcm, int *rcn,
  231.         int *rlm, int *rln,
  232.         int *rrm, int *rrn,
  233.         int flags)
  234. {
  235.         int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  236.         int cm2, cn2, ca2, ba;
  237.         int p0, p1, p2, p3;
  238.         int s0, s1;
  239.         int i, j, k;
  240.  
  241. #if 1
  242.         lm= 99999; rm= 99999; cm= 99999;
  243.         ln=-99999; rn=-99999; cn=-99999;
  244.        
  245.         ba=0;
  246.         for(i=0; i<64; i++)
  247.         {
  248.                 if(flags&BGBTAC_EFL_HALFMONO)
  249.                 {
  250.                         tl=iblk[i*2+0];
  251.                         tr=tl;
  252.                 }else if(flags&BGBTAC_EFL_STEREO)
  253.                 {
  254.                         tl=iblk[i*2+0];
  255.                         tr=iblk[i*2+1];
  256.                 }else
  257.                 {
  258.                         tl=iblk[i];
  259.                         tr=tl;
  260.                 }
  261.                 k=(tl+tr)>>1;
  262.                 tcblk[i]=k;
  263.                 tcpan[i]=tl-k;
  264.                 ba+=tl-k;
  265.                 if(k<cm) { lm=tl; rm=tr; cm=k; }
  266.                 if(k>cn) { ln=tl; rn=tr; cn=k; }
  267.         }
  268.  
  269.         ba/=64;
  270.        
  271.         for(i=0; i<32; i++)
  272.                 { oblk[i]=0; }
  273.  
  274.         p0=lm-cm;
  275.         p1=ln-cn;
  276.         p2=ba;
  277.  
  278.         p0=(5*p0+11*p2)>>4;
  279.         p1=(5*p1+11*p2)>>4;
  280. //      p0=p2; p1=p2;
  281.  
  282.         if((flags&BGBTAC_EFL_CENTERMONO) || (flags&BGBTAC_EFL_HALFMONO))
  283.                 { p0=0; p1=0; }
  284.  
  285. //      p0/=2;  p1/=2;
  286.         p0=bgbtac_spowi(p0, 0.73);
  287.         p1=bgbtac_spowi(p1, 0.73);
  288.  
  289. //      p0=bgbtac_spowi(p0, 0.90);
  290. //      p1=bgbtac_spowi(p1, 0.90);
  291.  
  292. //      p0=bgbtac_spowi(p0, 0.80);
  293. //      p1=bgbtac_spowi(p1, 0.80);
  294.  
  295.         p0=bgbtac_ssqrti(p0);
  296.         p1=bgbtac_ssqrti(p1);
  297.  
  298.         p0=(p0<(-128))?(-128):((p0<128)?p0:127);
  299.         p1=(p1<(-128))?(-128):((p1<128)?p1:127);
  300.        
  301.         oblk[0]=0x00;
  302.         oblk[1]=0x00;
  303.  
  304.         oblk[2]=cm&0xFF;
  305.         oblk[3]=(cm>>8)&0xFF;
  306.         oblk[4]=cn&0xFF;
  307.         oblk[5]=(cn>>8)&0xFF;
  308.         oblk[6]=p0&0xFF;
  309.         oblk[7]=p1&0xFF;
  310. #endif
  311.  
  312.         *rcm=cm;
  313.         *rcn=cn;
  314.         if(rlm && rln) { *rlm=lm; *rln=ln; }
  315.         if(rrm && rrn) { *rrm=rm; *rrn=rn; }
  316. }
  317.  
  318. #if 1
  319. void BGBTAC_EncodeBlock8S16(s16 *iblk, byte *oblk, int flags)
  320. {
  321.         s16 tcblk[64];
  322.         int tcma[16], tcna[16];
  323.         int tcmb[16], tcnb[16];
  324. //      int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  325.         int cm, cn, tc;
  326.         int cm2, cn2, ca2, ba;
  327.         int p0, p1, p2, p3;
  328.         int s0, s1;
  329.         int i, j, k;
  330.  
  331.         BGBTAC_EncodeBlockHeaderS16(iblk, oblk, tcblk, &cm, &cn, flags);
  332.  
  333.         for(i=0; i<16; i++)
  334.         {
  335.                 cm2= 99999; cn2=-99999;
  336.                 for(j=0; j<4; j++)
  337.                 {
  338.                         tc=tcblk[i*4+j];
  339.                         if(tc<cm2) { cm2=tc; }
  340.                         if(tc>cn2) { cn2=tc; }
  341.                 }
  342.  
  343.                 if(cn!=cm)
  344.                         { s0=268435456/(cn-cm); }
  345.                 else { s0=0; }
  346.  
  347.                 p0=(s0*(cm2-cm)+8388608)>>24;
  348.                 p1=(s0*(cn2-cm)+8388608)>>24;
  349.  
  350.                 p0=(p0<0)?0:((p0<16)?p0:15);
  351.                 p1=(p1<0)?0:((p1<16)?p1:15);
  352.                
  353.                 tcma[i]=p0;
  354.                 tcna[i]=p1;
  355.  
  356.                 s1=(cn-cm);
  357.                 cm2=((s1*p0+8)>>4)+cm;
  358.                 cn2=((s1*p1+8)>>4)+cm;
  359.  
  360.                 tcmb[i]=cm2;
  361.                 tcnb[i]=cn2;
  362.         }
  363.  
  364.         for(i=0; i<16; i++)
  365.         {
  366.                 oblk[16+(i>>1)]|=tcma[i]<<((i&1)*4);
  367.                 oblk[24+(i>>1)]|=tcna[i]<<((i&1)*4);
  368.         }
  369.        
  370.         for(i=0; i<16; i++)
  371.         {
  372.                 ca2=(tcmb[i]+tcnb[i])>>1;
  373.        
  374.                 for(j=0; j<4; j++)
  375.                 {
  376.                         k=i*4+j;
  377.                         tc=tcblk[k];
  378.                         if(tc>=ca2)
  379.                                 { oblk[8+(k>>3)]|=1<<(k&7); }
  380.                         else
  381.                                 { oblk[8+(k>>3)]&=~(1<<(k&7)); }
  382.                 }
  383.         }      
  384. }
  385.  
  386. void BGBTAC_DecodeBlockHeader(byte *iblk, int flags,
  387.         int *rcm, int *rcn, int *rca,
  388.         int *rlm, int *rln, int *rla,
  389.         int *rrm, int *rrn, int *rra)
  390. {
  391.         int cm, cn, ca;
  392.         int lm, ln, la;
  393.         int rm, rn, ra;
  394.         int i, j;
  395.  
  396.         cm=(s16)(iblk[2]+(iblk[3]<<8));
  397.         cn=(s16)(iblk[4]+(iblk[5]<<8));
  398.         ca=(cm+cn)>>1;
  399.  
  400.         i=bgbtac_ssqri((s8)iblk[6]);
  401.         j=bgbtac_ssqri((s8)iblk[7]);
  402.  
  403.         lm=cm+i; rm=cm-i;
  404.         ln=cn+j; rn=cn-j;
  405.         la=(lm+ln)>>1;
  406.         ra=(rm+rn)>>1;
  407.  
  408.         lm=(lm<(-32768))?(-32768):((lm<32768)?lm:32767);
  409.         ln=(ln<(-32768))?(-32768):((ln<32768)?ln:32767);
  410.         rm=(rm<(-32768))?(-32768):((rm<32768)?rm:32767);
  411.         rn=(rn<(-32768))?(-32768):((rn<32768)?rn:32767);
  412.        
  413.         *rcm=cm; *rcn=cn; *rca=ca;
  414.         *rlm=lm; *rln=ln; *rla=la;
  415.         *rrm=rm; *rrn=rn; *rra=ra;
  416. }
  417.  
  418. void BGBTAC_DecodeBlock8S16(byte *iblk, s16 *oblk, int flags)
  419. {
  420.         int p0, p1, p2, p3;
  421.         int s0, s1;
  422.         int cm, cn, ca;
  423.         int lm, ln, la;
  424.         int rm, rn, ra;
  425.         int cm2, cn2, ca2;
  426.         int lm2, ln2, la2;
  427.         int rm2, rn2, ra2;
  428.         int i, j, k;
  429.  
  430.         BGBTAC_DecodeBlockHeader(iblk, flags,
  431.                 &cm, &cn, &ca, &lm, &ln, &la, &rm, &rn, &ra);
  432.  
  433.         for(i=0; i<16; i++)
  434.         {
  435.                 p0=(iblk[16+(i>>1)]>>((i&1)*4))&15;
  436.                 p1=(iblk[24+(i>>1)]>>((i&1)*4))&15;
  437.  
  438.                 if(flags&(BGBTAC_EFL_STEREO|BGBTAC_EFL_HALFMONO))
  439.                 {
  440.                         s0=(ln-lm);
  441.                         s1=(rn-rm);
  442.                         lm2=((s0*p0+8)>>4)+lm;
  443.                         ln2=((s0*p1+8)>>4)+lm;
  444.                         rm2=((s1*p0+8)>>4)+rm;
  445.                         rn2=((s1*p1+8)>>4)+rm;
  446.                         la2=(lm2+ln2)>>1;
  447.                         ra2=(rm2+rn2)>>1;
  448.  
  449.                         lm2=(13*lm2+3*la2+8)>>4;
  450.                         ln2=(13*ln2+3*la2+8)>>4;
  451.                         rm2=(13*rm2+3*ra2+8)>>4;
  452.                         rn2=(13*rn2+3*ra2+8)>>4;
  453.  
  454.                         lm2=(lm2<lm)?lm:((lm2<ln)?lm2:ln);
  455.                         ln2=(ln2<lm)?lm:((ln2<ln)?ln2:ln);
  456.                         rm2=(rm2<rm)?rm:((rm2<rn)?rm2:rn);
  457.                         rn2=(rn2<rm)?rm:((rn2<rn)?rn2:rn);
  458.                 }else
  459.                 {
  460.                         cm2=((s1*p0+8)>>4)+cm;
  461.                         cn2=((s1*p1+8)>>4)+cm;
  462.                         ca2=(cm2+cn2)>>1;
  463.  
  464.                         cm2=(13*cm2+3*ca2+8)>>4;
  465.                         cn2=(13*cn2+3*ca2+8)>>4;
  466.  
  467.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  468.                         cn2=(cn2<cm)?cm:((cn2<cn)?cn2:cn);
  469.                 }
  470.  
  471.                 for(j=0; j<4; j++)
  472.                 {
  473.                         k=i*4+j;
  474.                
  475.                         p0=(iblk[8+(k>>3)]&(1<<(k&7)));
  476.                         if(flags&BGBTAC_EFL_HALFMONO)
  477.                                 { oblk[k*2+0]=p0?ln2:lm2; }
  478.                         else if(flags&BGBTAC_EFL_STEREO)
  479.                         {
  480.                                 oblk[k*2+0]=p0?ln2:lm2;
  481.                                 oblk[k*2+1]=p0?rn2:rm2;
  482.                         }else
  483.                         {
  484.                                 oblk[k]=p0?cn2:cm2;
  485.                         }
  486.                 }
  487.         }
  488. }
  489. #endif
  490.  
  491. void BGBTAC_EncodeBlock9S16(s16 *iblk, byte *oblk, int flags)
  492. {
  493.         s16 tcblk[64];
  494.         int tcma[32];
  495.         int tcmb[32];
  496. //      int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  497.         int cm, cn, tc;
  498.         int cm2, cn2, ca2, ba;
  499.         int p0, p1, p2, p3;
  500.         int s0, s1, s2, s3;
  501.         int i, j, k;
  502.  
  503.         BGBTAC_EncodeBlockHeaderS16(iblk, oblk, tcblk, &cm, &cn, flags);
  504.  
  505.         oblk[0]=0x01;
  506.         oblk[1]=0x00;
  507.        
  508.         for(i=0; i<32; i++)
  509.         {
  510.                 cm2= 99999; cn2=-99999;
  511.                 tc=tcblk[i*2+0];
  512.  
  513.                 if(cn!=cm)
  514.                         { s0=268435456/(cn-cm); }
  515.                 else { s0=0; }
  516.                 p0=(s0*(tc-cm)+8388608)>>24;
  517.                 p0=(p0<0)?0:((p0<16)?p0:15);
  518.                 tcma[i]=p0;
  519.  
  520.                 s1=(cn-cm);
  521.                 p1=((s1*p0+8)>>4)+cm;
  522.  
  523.                 tcmb[i]=p1;
  524.         }
  525.  
  526.         for(i=0; i<32; i++)
  527.                 { oblk[16+(i>>1)]|=tcma[i]<<((i&1)*4); }
  528.  
  529. #if 1
  530.         for(i=0; i<32; i++)
  531.         {
  532.                 p0=tcmb[i];
  533. //              p1=tcmb[(i+1)&31];
  534. //              p2=tcmb[(i-1)&31];
  535. //              p3=tcmb[(i+2)&31];
  536.                 p1=(i<31)?tcmb[(i+1)&31]:p0;
  537.                 p2=(i>0)?tcmb[(i-1)&31]:p0;
  538.                 p3=(i<30)?tcmb[(i+2)&31]:p1;
  539.                 ca2=(p0+p1)>>1;
  540.        
  541.                 tc=tcblk[i*2+1];
  542.  
  543.                 k=0; s0=abs(tc-p0);
  544.                 s1=abs(tc-p1);
  545.                 if(s1<s0) { k=1; s0=s1; }
  546.                 s2=(p0+p1)>>1;
  547.                 s1=abs(tc-s2);
  548.                 if(s1<s0) { k=2; s0=s1; }
  549.  
  550.                 s2=(3*p0+3*p1-p2-p3+2)>>2;
  551.                 s1=abs(tc-s2);
  552.                 if(s1<s0) { k=3; s0=s1; }
  553.  
  554.                 oblk[8+(i>>2)]|=k<<((i&3)*2);
  555.         }
  556. #endif
  557. }
  558.  
  559. void BGBTAC_DecodeBlock9S16(byte *iblk, s16 *oblk, int flags)
  560. {
  561.         int p0, p1, p2, p3;
  562.         int s0, s1;
  563.         int cm, cn, ca;
  564.         int lm, ln, la;
  565.         int rm, rn, ra;
  566.         int cm2, cn2, ca2;
  567.         int lm2, ln2, la2;
  568.         int rm2, rn2, ra2;
  569.         int i, j, k;
  570.  
  571.         BGBTAC_DecodeBlockHeader(iblk, flags,
  572.                 &cm, &cn, &ca, &lm, &ln, &la, &rm, &rn, &ra);
  573.  
  574.         for(i=0; i<32; i++)
  575.         {
  576.                 p0=(iblk[16+(i>>1)]>>((i&1)*4))&15;
  577.        
  578.                 if(flags&BGBTAC_EFL_HALFMONO)
  579.                 {
  580.                         s0=(cn-cm);
  581.                         cm2=((s0*p0+8)>>4)+cm;
  582.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  583.                         oblk[i*4+0]=cm2;
  584.                 }
  585.                 else if(flags&BGBTAC_EFL_STEREO)
  586.                 {
  587.                         s0=(ln-lm);
  588.                         s1=(rn-rm);
  589.                         lm2=((s0*p0+8)>>4)+lm;
  590.                         rm2=((s1*p0+8)>>4)+rm;
  591.  
  592.                         lm2=(lm2<lm)?lm:((lm2<ln)?lm2:ln);
  593.                         rm2=(rm2<rm)?rm:((rm2<rn)?rm2:rn);
  594.  
  595.                         oblk[i*4+0]=lm2;
  596.                         oblk[i*4+1]=rm2;
  597.                 }else
  598.                 {
  599.                         s0=(cn-cm);
  600.                         cm2=((s0*p0+8)>>4)+cm;
  601.  
  602.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  603.  
  604.                         oblk[i*2+0]=cm2;
  605.                 }
  606.         }
  607.  
  608. #if 1
  609.         if(flags&BGBTAC_EFL_HALFMONO)
  610.         {
  611.                 for(i=0; i<32; i++)
  612.                 {
  613.                         p1=oblk[i*4+0];
  614.                         p0=(i>0)?oblk[i*4-4]:p1;
  615.                         p2=(i<31)?oblk[i*4+4]:p1;
  616.                         p3=(i<30)?oblk[i*4+8]:p2;
  617.  
  618.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  619.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  620.  
  621.                         oblk[i*4+2]=p3;
  622.                 }
  623.         }else if(flags&BGBTAC_EFL_STEREO)
  624.         {
  625.                 for(i=0; i<32; i++)
  626.                         for(j=0; j<2; j++)
  627.                 {
  628.                         p1=oblk[i*4+0+j];
  629.                         p0=(i>0)?oblk[i*4-4+j]:p1;
  630.                         p2=(i<31)?oblk[i*4+4+j]:p1;
  631.                         p3=(i<30)?oblk[i*4+8+j]:p2;
  632.  
  633.                         s0=(iblk[8+(i>>2)]>>((i&3)*2))&3;
  634.                        
  635.                         switch(s0)
  636.                         {
  637.                         case 0:
  638.                                 p3=p1;
  639.                                 break;
  640.                         case 1:
  641.                                 p3=p2;
  642.                                 break;
  643.                         case 2:
  644.                                 p3=(p1+p2)>>1;
  645.                                 break;
  646.                         case 3:
  647.                                 p3=(3*p1+3*p2-p0-p3+2)>>2;
  648.                                 p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  649.                                 break;
  650.                         default:
  651.                                 p3=(p1+p2)>>1;
  652.                                 break;
  653.                         }
  654.  
  655.                         oblk[i*4+2+j]=p3;
  656.                 }
  657.         }else
  658.         {
  659.                 for(i=0; i<32; i++)
  660.                 {
  661.                         p1=oblk[i*2+0];
  662.                         p0=(i>0)?oblk[i*2-2]:p1;
  663.                         p2=(i<31)?oblk[i*2+2]:p1;
  664.                         p3=(i<30)?oblk[i*2+4]:p2;
  665.  
  666.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  667.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  668.  
  669.                         oblk[i*2+1]=p3;
  670.                 }
  671.         }
  672. #endif
  673. }
  674.  
  675. void BGBTAC_EncodeBlock10S16(s16 *iblk, byte *oblk, int flags)
  676. {
  677.         s16 tcblk[64];
  678.         int tcma[32];
  679.         int tcmb[32];
  680. //      int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  681.         int cm, cn, tc;
  682.         int cm2, cn2, ca2, ba;
  683.         int p0, p1, p2, p3;
  684.         int s0, s1;
  685.         int i, j, k;
  686.  
  687.         BGBTAC_EncodeBlockHeaderS16(iblk, oblk, tcblk, &cm, &cn, flags);
  688.  
  689.         oblk[0]=0x02;
  690.         oblk[1]=0x00;
  691.  
  692.         for(i=0; i<32; i++)
  693.         {
  694.                 cm2= 99999; cn2=-99999;
  695.                 tc=tcblk[i*2+0];
  696.  
  697.                 if(cn!=cm)
  698.                         { s0=268435456/(cn-cm); }
  699.                 else { s0=0; }
  700.                 p0=(s0*(tc-cm)+2097152)>>22;
  701.                 p0=(p0<0)?0:((p0<64)?p0:63);
  702.                 tcma[i]=p0;
  703.         }
  704.  
  705.         for(i=0; i<32; i++)
  706.         {
  707.                 j=i*6;
  708.                 k=tcma[i]<<(j&7);
  709.  
  710.                 oblk[8+(j>>3)+0]|=k;
  711.                 oblk[8+(j>>3)+1]|=k>>8;
  712.         }
  713. }
  714.  
  715. void BGBTAC_DecodeBlock10S16(byte *iblk, s16 *oblk, int flags)
  716. {
  717.         int p0, p1, p2, p3;
  718.         int s0, s1;
  719.         int cm, cn, ca;
  720.         int lm, ln, la;
  721.         int rm, rn, ra;
  722.         int cm2, cn2, ca2;
  723.         int lm2, ln2, la2;
  724.         int rm2, rn2, ra2;
  725.         int i, j, k;
  726.  
  727.         BGBTAC_DecodeBlockHeader(iblk, flags,
  728.                 &cm, &cn, &ca, &lm, &ln, &la, &rm, &rn, &ra);
  729.  
  730.         for(i=0; i<32; i++)
  731.         {
  732.                 j=i*6;
  733.                
  734.                 k=iblk[8+(j>>3)+0] | (iblk[8+(j>>3)+1]<<8);
  735.                 p0=(k>>(j&7))&63;
  736.                
  737.                 if(flags&BGBTAC_EFL_HALFMONO)
  738.                 {
  739.                         s0=(ln-lm);
  740.                         lm2=((s0*p0+32)>>6)+lm;
  741.  
  742.                         lm2=(lm2<lm)?lm:((lm2<ln)?lm2:ln);
  743.  
  744.                         oblk[i*4+0]=lm2;
  745.                         oblk[i*4+2]=lm2;
  746.                 }else if(flags&BGBTAC_EFL_STEREO)
  747.                 {
  748.                         s0=(ln-lm);
  749.                         s1=(rn-rm);
  750.                         lm2=((s0*p0+32)>>6)+lm;
  751.                         rm2=((s1*p0+32)>>6)+rm;
  752.  
  753.                         lm2=(lm2<lm)?lm:((lm2<ln)?lm2:ln);
  754.                         rm2=(rm2<rm)?rm:((rm2<rn)?rm2:rn);
  755.  
  756.                         oblk[i*4+0]=lm2;
  757.                         oblk[i*4+1]=rm2;
  758.                         oblk[i*4+2]=lm2;
  759.                         oblk[i*4+3]=rm2;
  760.                 }else
  761.                 {
  762.                         s0=(cn-cm);
  763.                         cm2=((s0*p0+32)>>6)+cm;
  764.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  765.  
  766.                         oblk[i*2+0]=cm2;
  767.                         oblk[i*2+1]=cm2;
  768.                 }
  769.         }
  770.  
  771. #if 1
  772.         if(flags&BGBTAC_EFL_HALFMONO)
  773.         {
  774.                 for(i=0; i<32; i++)
  775.                 {
  776.                         p1=oblk[i*4+0];
  777.                         p0=(i>0)?oblk[i*4-4]:p1;
  778.                         p2=(i<31)?oblk[i*4+4]:p1;
  779.                         p3=(i<30)?oblk[i*4+8]:p2;
  780.  
  781.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  782.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  783.  
  784.                         oblk[i*4+2]=p3;
  785.                 }
  786.         }else
  787.         if(flags&BGBTAC_EFL_STEREO)
  788.         {
  789.                 for(i=0; i<32; i++)
  790.                         for(j=0; j<2; j++)
  791.                 {
  792.                         p1=oblk[i*4+0+j];
  793.                         p0=(i>0)?oblk[i*4-4+j]:p1;
  794.                         p2=(i<31)?oblk[i*4+4+j]:p1;
  795.                         p3=(i<30)?oblk[i*4+8+j]:p2;
  796.  
  797.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  798.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  799.  
  800.                         oblk[i*4+2+j]=p3;
  801.                 }
  802.         }else
  803.         {
  804.                 for(i=0; i<32; i++)
  805.                 {
  806.                         p1=oblk[i*2+0];
  807.                         p0=(i>0)?oblk[i*2-2]:p1;
  808.                         p2=(i<31)?oblk[i*2+2]:p1;
  809.                         p3=(i<30)?oblk[i*2+4]:p2;
  810.  
  811.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  812.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  813.  
  814.                         oblk[i*2+1]=p3;
  815.                 }
  816.         }
  817. #endif
  818. }
  819.  
  820. void BGBTAC_EncodeBlock12S16(s16 *iblk, byte *oblk, int flags)
  821. {
  822.         s16 tcblk[64], tcpan[64];
  823.         int tcma[32];
  824.         int tcmb[32];
  825.         int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  826.         int cm2, cn2, ca2, ba;
  827.         int p0, p1, p2, p3;
  828.         int s0, s1;
  829.         int i, j, k;
  830.  
  831.         BGBTAC_EncodeBlockHeaderPanS16(
  832.                 iblk, oblk, tcblk, tcpan,
  833.                 &cm, &cn, &lm, &ln, &rm, &rn,
  834.                 flags);
  835.  
  836.         oblk[0]=0x03;
  837.         oblk[1]=0x00;
  838.        
  839.         for(i=0; i<32; i++)
  840.         {
  841.                 cm2= 99999; cn2=-99999;
  842.                 tc=tcblk[i*2+0];
  843.  
  844. #if 0
  845.                 if(cn!=cm)
  846.                         { s0=16777216/(cn-cm); }
  847.                 else { s0=0; }
  848.  
  849.                 p0=(s0*(tc-cm)+524288)>>20;
  850.                 p0=(p0<0)?0:((p0<16)?p0:15);
  851.                 tcma[i]=p0;
  852. #endif
  853.  
  854. #if 1
  855.                 if(cn!=cm)
  856.                         { s0=268435456/(cn-cm); }
  857.                 else { s0=0; }
  858.                 p0=(s0*(tc-cm)+8388608)>>24;
  859.                 p0=(p0<0)?0:((p0<16)?p0:15);
  860.                 tcma[i]=p0;
  861. #endif
  862.  
  863.                 s1=(cn-cm);
  864.                 p1=((s1*p0+8)>>4)+cm;
  865.  
  866.                 tcmb[i]=p1;
  867.         }
  868.  
  869.         for(i=0; i<32; i++)
  870.                 { oblk[16+(i>>1)]|=tcma[i]<<((i&1)*4); }
  871.  
  872. #if 1
  873.         tl=abs(ln-cn);
  874.         tr=-abs(rn-cn);
  875.  
  876.         for(i=0; i<32; i++)
  877.         {
  878.                 tc=tcpan[i*2+0];
  879.  
  880.                 p2=0;
  881.  
  882. #if 1
  883.                 if(tc>tl)
  884.                         { p2=2; }
  885.                 else if(tc<tr)
  886.                         { p2=3; }
  887.                 else if(abs(tc)<(tl>>2))
  888.                         { p2=1; }
  889.                 else
  890.                         { p2=0; }
  891. #endif
  892.  
  893.                 oblk[8+(i>>2)]|=p2<<((i&3)*2);
  894.         }
  895. #endif
  896. }
  897.  
  898. void BGBTAC_DecodeBlock12S16(byte *iblk, s16 *oblk, int flags)
  899. {
  900.         int p0, p1, p2, p3;
  901.         int s0, s1, s2;
  902.         int cm, cn, ca;
  903.         int lm, ln, la;
  904.         int rm, rn, ra;
  905.         int cm2, cn2, ca2;
  906.         int lm2, ln2, la2;
  907.         int rm2, rn2, ra2;
  908.         int lm3, rm3;
  909.         int i, j, k;
  910.  
  911.         BGBTAC_DecodeBlockHeader(iblk, flags,
  912.                 &cm, &cn, &ca, &lm, &ln, &la, &rm, &rn, &ra);
  913.  
  914.         for(i=0; i<32; i++)
  915.         {
  916.                 p0=(iblk[16+(i>>1)]>>((i&1)*4))&15;
  917.                 p1=(iblk[8+(i>>2)]>>((i&3)*2))&3;
  918.        
  919.                 if(flags&BGBTAC_EFL_HALFMONO)
  920.                 {
  921.                         s0=(cn-cm);
  922.                         cm2=((s0*p0+8)>>4)+cm;
  923.  
  924.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  925.  
  926.                         oblk[i*4+0]=cm2;
  927.                         oblk[i*4+2]=cm2;
  928.                 }else if(flags&BGBTAC_EFL_STEREO)
  929.                 {
  930.                         s0=(ln-lm);
  931.                         s1=(rn-rm);
  932.                         s2=(cn-cm);
  933.                         lm2=((s0*p0+8)>>4)+lm;
  934.                         rm2=((s1*p0+8)>>4)+rm;
  935.                         cm2=((s2*p0+8)>>4)+cm;
  936.  
  937.                         lm2=(lm2<lm)?lm:((lm2<ln)?lm2:ln);
  938.                         rm2=(rm2<rm)?rm:((rm2<rn)?rm2:rn);
  939.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  940.  
  941.                         switch(p1)
  942.                         {
  943.                         case 0:
  944.                                 oblk[i*4+0]=lm2;
  945.                                 oblk[i*4+1]=rm2;
  946.                                 break;
  947.                         case 1:
  948.                                 oblk[i*4+0]=cm2;
  949.                                 oblk[i*4+1]=cm2;
  950.                                 break;
  951.                         case 2:
  952.                                 lm3=max(lm2, cm2);
  953.                                 rm3=min(rm2, cm2);
  954.                                 oblk[i*4+0]=lm3;
  955.                                 oblk[i*4+1]=rm3;
  956.                                 break;
  957.                         case 3:
  958.                                 lm3=min(lm2, cm2);
  959.                                 rm3=max(rm2, cm2);
  960.                                 oblk[i*4+0]=lm3;
  961.                                 oblk[i*4+1]=rm3;
  962.                                 break;
  963.                         }
  964.                 }else
  965.                 {
  966.                         s0=(cn-cm);
  967.                         cm2=((s0*p0+8)>>4)+cm;
  968.  
  969.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  970.  
  971.                         oblk[i*2+0]=cm2;
  972.                 }
  973.         }
  974.  
  975. #if 1
  976.         if(flags&BGBTAC_EFL_HALFMONO)
  977.         {
  978.                 for(i=0; i<32; i++)
  979.                 {
  980.                         p1=oblk[i*4+0];
  981.                         p0=(i>0)?oblk[i*4-4]:p1;
  982.                         p2=(i<31)?oblk[i*4+4]:p1;
  983.                         p3=(i<30)?oblk[i*4+8]:p2;
  984.  
  985.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  986.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  987.  
  988.                         oblk[i*4+2]=p3;
  989.                 }
  990.         }else if(flags&BGBTAC_EFL_STEREO)
  991.         {
  992.                 for(i=0; i<32; i++)
  993.                         for(j=0; j<2; j++)
  994.                 {
  995.                         p1=oblk[i*4+0+j];
  996.                         p0=(i>0)?oblk[i*4-4+j]:p1;
  997.                         p2=(i<31)?oblk[i*4+4+j]:p1;
  998.                         p3=(i<30)?oblk[i*4+8+j]:p2;
  999.  
  1000.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  1001.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  1002.  
  1003.                         oblk[i*4+2+j]=p3;
  1004.                 }
  1005.         }else
  1006.         {
  1007.                 for(i=0; i<32; i++)
  1008.                 {
  1009.                         p1=oblk[i*2+0];
  1010.                         p0=(i>0)?oblk[i*2-2]:p1;
  1011.                         p2=(i<31)?oblk[i*2+2]:p1;
  1012.                         p3=(i<30)?oblk[i*2+4]:p2;
  1013.  
  1014.                         p3=(3*p1+3*p2-p0-p3+2)>>2;
  1015.                         p3=(p3<(-32768))?(-32768):((p3<32768)?p3:32767);
  1016.  
  1017.                         oblk[i*2+1]=p3;
  1018.                 }
  1019.         }
  1020. #endif
  1021. }
  1022.  
  1023. #if 1
  1024. void BGBTAC_EncodeBlock13S16(s16 *iblk, byte *oblk, int flags)
  1025. {
  1026.         s16 tcblk[64];
  1027.         int tcma[16], tcna[16];
  1028.         int tcmb[16], tcnb[16];
  1029. //      int lm, ln, cm, rm, rn, cn, tl, tr, tc;
  1030.         int cm, cn, tc;
  1031.         int cm2, cn2, ca2, ba, cm2a, cn2a;
  1032.         int p0, p1, p2, p3;
  1033.         int s0, s1;
  1034.         int i, j, k;
  1035.  
  1036.         BGBTAC_EncodeBlockHeaderS16(iblk, oblk, tcblk, &cm, &cn, flags);
  1037.  
  1038.         oblk[0]=0x04;
  1039.         oblk[1]=0x00;
  1040.  
  1041.         for(i=0; i<8; i++)
  1042.         {
  1043.                 cm2= 99999; cn2=-99999;
  1044.                 for(j=0; j<8; j++)
  1045.                 {
  1046.                         tc=tcblk[i*8+j];
  1047.                         if(tc<cm2) { cm2=tc; }
  1048.                         if(tc>cn2) { cn2=tc; }
  1049.                 }
  1050.  
  1051. #if 1
  1052.                 if(cn!=cm)
  1053.                         { s0=268435456/(cn-cm); }
  1054.                 else { s0=0; }
  1055.  
  1056.                 p0=(s0*(cm2-cm)+8388608)>>24;
  1057.                 p1=(s0*(cn2-cm)+8388608)>>24;
  1058. #endif
  1059.  
  1060.                 p0=(p0<0)?0:((p0<16)?p0:15);
  1061.                 p1=(p1<0)?0:((p1<16)?p1:15);
  1062.                
  1063.                 tcma[i]=p0;
  1064.                 tcna[i]=p1;
  1065.  
  1066.                 s1=(cn-cm);
  1067.                 cm2=((s1*p0+8)>>4)+cm;
  1068.                 cn2=((s1*p1+8)>>4)+cm;
  1069.                 ca2=(cm2+cn2)>>1;
  1070.  
  1071.                 cm2=(13*cm2+3*ca2+8)>>4;
  1072.                 cn2=(13*cn2+3*ca2+8)>>4;
  1073.  
  1074.                 tcmb[i]=cm2;
  1075.                 tcnb[i]=cn2;
  1076.         }
  1077.  
  1078.         for(i=0; i<8; i++)
  1079.         {
  1080.                 oblk[ 8+(i>>1)]|=tcma[i]<<((i&1)*4);
  1081.                 oblk[12+(i>>1)]|=tcna[i]<<((i&1)*4);
  1082.         }
  1083.        
  1084.         for(i=0; i<8; i++)
  1085.         {
  1086.                 cm2=tcmb[i];
  1087.                 cn2=tcnb[i];
  1088.                 ca2=(cm2+cn2)>>1;
  1089.  
  1090. //              cm2a=(11*cm2+5*cn2+8)>>4;
  1091. //              cn2a=(11*cn2+5*cm2+8)>>4;
  1092.  
  1093.                 s0=cn2-cm2;
  1094.                 cm2a=((22*s0*1+32)>>6)+cm2;
  1095.                 cn2a=((22*s0*2+32)>>6)+cm2;
  1096.  
  1097.                 for(j=0; j<8; j++)
  1098.                 {
  1099.                         k=i*8+j;
  1100.                         tc=tcblk[k];
  1101.                        
  1102. //                      p0=0; s0=abs(tc-cm2);
  1103. //                      s1=abs(tc-cn2);
  1104. //                      if(s1<s0) { p0=1; s0=s1; }
  1105. //                      s1=abs(tc-ca2);
  1106. //                      if(s1<s0) { p0=2; s0=s1; }
  1107.  
  1108.                         p0=0; s0=abs(tc-cm2);
  1109.                         s1=abs(tc-cn2);
  1110.                         if(s1<s0) { p0=3; s0=s1; }
  1111.                         s1=abs(tc-cm2a);
  1112.                         if(s1<s0) { p0=1; s0=s1; }
  1113.                         s1=abs(tc-cn2a);
  1114.                         if(s1<s0) { p0=2; s0=s1; }
  1115.                        
  1116.                         oblk[16+(k>>2)]|=p0<<((k&3)*2);
  1117.                 }
  1118.         }      
  1119. }
  1120.  
  1121. void BGBTAC_DecodeBlock13S16(byte *iblk, s16 *oblk, int flags)
  1122. {
  1123.         int p0, p1, p2, p3;
  1124.         int s0, s1;
  1125.         int cm, cn, ca;
  1126.         int lm, ln, la;
  1127.         int rm, rn, ra;
  1128.         int cm2, cn2, ca2;
  1129.         int lm2, ln2, la2;
  1130.         int rm2, rn2, ra2;
  1131.         int i, j, k;
  1132.  
  1133.         BGBTAC_DecodeBlockHeader(iblk, flags,
  1134.                 &cm, &cn, &ca, &lm, &ln, &la, &rm, &rn, &ra);
  1135.  
  1136.         for(i=0; i<8; i++)
  1137.         {
  1138.                 p0=(iblk[ 8+(i>>1)]>>((i&1)*4))&15;
  1139.                 p1=(iblk[12+(i>>1)]>>((i&1)*4))&15;
  1140.        
  1141.                 if(flags&(BGBTAC_EFL_STEREO|BGBTAC_EFL_HALFMONO))
  1142.                 {
  1143.                         s0=(ln-lm);
  1144.                         s1=(rn-rm);
  1145.                         lm2=((s0*p0+8)>>4)+lm;
  1146.                         ln2=((s0*p1+8)>>4)+lm;
  1147.                         rm2=((s1*p0+8)>>4)+rm;
  1148.                         rn2=((s1*p1+8)>>4)+rm;
  1149.                         la2=(lm2+ln2)>>1;
  1150.                         ra2=(rm2+rn2)>>1;
  1151.  
  1152.                         lm2=(13*lm2+3*la2+8)>>4;
  1153.                         ln2=(13*ln2+3*la2+8)>>4;
  1154.                         rm2=(13*rm2+3*ra2+8)>>4;
  1155.                         rn2=(13*rn2+3*ra2+8)>>4;
  1156.  
  1157.                         lm2=(lm2<lm)?lm:((lm2<ln)?lm2:ln);
  1158.                         ln2=(ln2<lm)?lm:((ln2<ln)?ln2:ln);
  1159.                         rm2=(rm2<rm)?rm:((rm2<rn)?rm2:rn);
  1160.                         rn2=(rn2<rm)?rm:((rn2<rn)?rn2:rn);
  1161.                 }else
  1162.                 {
  1163.                         cm2=((s1*p0+8)>>4)+cm;
  1164.                         cn2=((s1*p1+8)>>4)+cm;
  1165.                         ca2=(cm2+cn2)>>1;
  1166.  
  1167.                         cm2=(13*cm2+3*ca2+8)>>4;
  1168.                         cn2=(13*cn2+3*ca2+8)>>4;
  1169.  
  1170.                         cm2=(cm2<cm)?cm:((cm2<cn)?cm2:cn);
  1171.                         cn2=(cn2<cm)?cm:((cn2<cn)?cn2:cn);
  1172.                 }
  1173.  
  1174.                 if(flags&BGBTAC_EFL_HALFMONO)
  1175.                 {
  1176.                         for(j=0; j<8; j++)
  1177.                         {
  1178.                                 k=i*8+j;
  1179.                
  1180.                                 p0=(iblk[16+(k>>2)]>>((k&3)*2))&3;
  1181.  
  1182.                                 s0=ln2-lm2;
  1183.                                 p1=((22*s0*p0+32)>>6)+lm2;
  1184.                                 oblk[k*2+0]=p1;
  1185.                         }
  1186.                 }else if(flags&BGBTAC_EFL_STEREO)
  1187.                 {
  1188.                         for(j=0; j<8; j++)
  1189.                         {
  1190.                                 k=i*8+j;
  1191.                
  1192.                                 p0=(iblk[16+(k>>2)]>>((k&3)*2))&3;
  1193.  
  1194.                                 s0=ln2-lm2;
  1195.                                 s1=rn2-rm2;
  1196.                                 p1=((22*s0*p0+32)>>6)+lm2;
  1197.                                 p2=((22*s1*p0+32)>>6)+rm2;
  1198.                                 oblk[k*2+0]=p1;
  1199.                                 oblk[k*2+1]=p2;
  1200.                         }
  1201.                 }else
  1202.                 {
  1203.                         for(j=0; j<8; j++)
  1204.                         {
  1205.                                 k=i*8+j;
  1206.                
  1207.                                 p0=(iblk[16+(k>>2)]>>((k&3)*2))&3;
  1208.  
  1209.                                 s0=cn2-cm2;
  1210.                                 p1=((22*s0*p0+32)>>6)+cm2;
  1211.                                 oblk[k]=p1;
  1212.                         }
  1213.                 }
  1214.         }
  1215. }
  1216. #endif
  1217.  
  1218.  
  1219. BTAC_API void BGBTAC_FilterStreamMonoS16(s16 *buf, int len)
  1220. {
  1221.         int ta[2];
  1222.         int a, b, c, n;
  1223.         int i, j, k;
  1224.        
  1225.         a=0;
  1226.        
  1227. //      for(i=8; i<(len-8); i++)
  1228.         for(i=0; i<len; i++)
  1229.         {
  1230.                 b=buf[i];
  1231. //              c=(a*5+b*11+8)>>4;
  1232. //              c=(a*3+b*13+8)>>4;
  1233.  
  1234. //              c=(a*80+b*176+128)>>8;
  1235.                 c=(a*48+b*208+128)>>8;
  1236.                 buf[i]=c;
  1237.                
  1238.                 a=(b*128+a*128+128)>>8;
  1239. //              a=(b*96+a*160+128)>>8;
  1240. //              a=(b*80+a*176+128)>>8;
  1241. //              a=(b*48+a*208+128)>>8;
  1242.         }
  1243. }
  1244.  
  1245. BTAC_API void BGBTAC_DeblockStreamMonoS16(s16 *oblk, int len)
  1246. {
  1247.         int p0, p1, p2, p3;
  1248.         int q0, q1, q2, q3;
  1249.         float f, g;
  1250.         int i, j, k, n;
  1251.  
  1252.         n=(len+63)/64;
  1253.  
  1254. #if 1
  1255.         //deblocking...
  1256.         for(i=1; i<(n-1); i++)
  1257.         {
  1258. #if 1
  1259.                 p0=oblk[i*64-2];
  1260.                 p1=oblk[i*64-1];
  1261.                 p2=oblk[i*64+0];
  1262.                 p3=oblk[i*64+1];
  1263.  
  1264.                 q0=(128*p0+ 64*p1+ 48*p2+ 16*p3)>>8;
  1265.                 q1=( 48*p0+128*p1+ 48*p2+ 32*p3)>>8;
  1266.                 q2=( 32*p0+ 48*p1+128*p2+ 48*p3)>>8;
  1267.                 q3=( 16*p0+ 48*p1+ 64*p2+128*p3)>>8;
  1268.                
  1269.                 oblk[i*64-2]=q0;
  1270.                 oblk[i*64-1]=q1;
  1271.                 oblk[i*64+0]=q2;
  1272.                 oblk[i*64+1]=q3;
  1273. #endif
  1274.         }
  1275. #endif
  1276. }
  1277.  
  1278. BTAC_API void BGBTAC_FilterStreamS16(s16 *buf, int len)
  1279. {
  1280.         int ta[2];
  1281.         int a, b, c, n;
  1282.         int i, j, k;
  1283.        
  1284.         ta[0]=0; ta[1]=0;
  1285.        
  1286. //      for(i=8; i<(len-8); i++)
  1287.         for(i=0; i<len; i++)
  1288.                 for(j=0; j<2; j++)
  1289.         {
  1290.                 a=ta[j];
  1291.                
  1292.                 b=buf[i*2+j];
  1293. //              c=(a*5+b*11+8)>>4;
  1294. //              c=(a*3+b*13+8)>>4;
  1295.  
  1296. //              c=(a*80+b*176+128)>>8;
  1297.                 c=(a*48+b*208+128)>>8;
  1298.                 buf[i*2+j]=c;
  1299.                
  1300.                 a=(b*128+a*128+128)>>8;
  1301. //              a=(b*96+a*160+128)>>8;
  1302. //              a=(b*80+a*176+128)>>8;
  1303. //              a=(b*48+a*208+128)>>8;
  1304.                 ta[j]=a;
  1305.         }
  1306. }
  1307.  
  1308. BTAC_API void BGBTAC_DeblockStreamS16(
  1309.         s16 *oblk, int len)
  1310. {
  1311.         int p0, p1, p2, p3;
  1312.         int q0, q1, q2, q3;
  1313.         float f, g;
  1314.         int i, j, k, n;
  1315.  
  1316.         n=(len+63)/64;
  1317.  
  1318. #if 1
  1319.         //deblocking...
  1320.         for(i=1; i<(n-1); i++)
  1321.                 for(j=0; j<2; j++)
  1322.         {
  1323. #if 0
  1324.                 p0=oblk[i*64*2-2];
  1325.                 p1=oblk[i*64*2-1];
  1326.                 p2=oblk[i*64*2+0];
  1327.                 p3=oblk[i*64*2+1];
  1328.  
  1329.                 q0=(11*p0+5*p2)>>4;
  1330.                 q1=(11*p1+5*p3)>>4;
  1331.                 q2=(11*p2+5*p0)>>4;
  1332.                 q3=(11*p3+5*p1)>>4;
  1333.                
  1334.                 oblk[i*64*2-2]=q0;
  1335.                 oblk[i*64*2-1]=q1;
  1336.                 oblk[i*64*2+0]=q2;
  1337.                 oblk[i*64*2+1]=q3;
  1338. #endif
  1339.  
  1340. #if 1
  1341.                 p0=oblk[i*64*2-4+j];
  1342.                 p1=oblk[i*64*2-2+j];
  1343.                 p2=oblk[i*64*2+0+j];
  1344.                 p3=oblk[i*64*2+2+j];
  1345.  
  1346.                 q0=(128*p0+ 64*p1+ 48*p2+ 16*p3)>>8;
  1347.                 q1=( 48*p0+128*p1+ 48*p2+ 32*p3)>>8;
  1348.                 q2=( 32*p0+ 48*p1+128*p2+ 48*p3)>>8;
  1349.                 q3=( 16*p0+ 48*p1+ 64*p2+128*p3)>>8;
  1350.                
  1351.                 oblk[i*64*2-4+j]=q0;
  1352.                 oblk[i*64*2-2+j]=q1;
  1353.                 oblk[i*64*2+0+j]=q2;
  1354.                 oblk[i*64*2+2+j]=q3;
  1355. #endif
  1356.         }
  1357. #endif
  1358. }
  1359.  
  1360. void BGBTAC_EncodeBlockTagS16(s16 *iblk, byte *oblk,
  1361.         int tag, int flags)
  1362. {
  1363.         switch(tag)
  1364.         {
  1365.         case 0:
  1366.                 BGBTAC_EncodeBlock8S16(iblk, oblk, flags);
  1367.                 break;
  1368.         case 1:
  1369.                 BGBTAC_EncodeBlock9S16(iblk, oblk, flags);
  1370.                 break;
  1371.         case 2:
  1372.                 BGBTAC_EncodeBlock10S16(iblk, oblk, flags);
  1373.                 break;
  1374.         case 3:
  1375.                 BGBTAC_EncodeBlock12S16(iblk, oblk, flags);
  1376.                 break;
  1377.         case 4:
  1378.                 BGBTAC_EncodeBlock13S16(iblk, oblk, flags);
  1379.                 break;
  1380.         }
  1381. }
  1382.  
  1383. void BGBTAC_DecodeBlockTagS16(byte *iblk, s16 *oblk, int flags)
  1384. {
  1385.         switch(iblk[0]&15)
  1386.         {
  1387.         case 0:
  1388.                 BGBTAC_DecodeBlock8S16(iblk, oblk, flags);
  1389.                 break;
  1390.         case 1:
  1391.                 BGBTAC_DecodeBlock9S16(iblk, oblk, flags);
  1392.                 break;
  1393.         case 2:
  1394.                 BGBTAC_DecodeBlock10S16(iblk, oblk, flags);
  1395.                 break;
  1396.         case 3:
  1397.                 BGBTAC_DecodeBlock12S16(iblk, oblk, flags);
  1398.                 break;
  1399.         case 4:
  1400.                 BGBTAC_DecodeBlock13S16(iblk, oblk, flags);
  1401.                 break;
  1402.         }
  1403. }
  1404.  
  1405. BTAC_API int BGBTAC_CalcBlockErrorS16(
  1406.         s16 *iblk, s16 *tblk, int flags)
  1407. {
  1408.         double e;
  1409.         int ld, rd, cd, c0, c1;
  1410.         int i;
  1411.  
  1412.         if(flags&BGBTAC_EFL_HALFMONO)
  1413.         {
  1414.                 e=0;
  1415.                 for(i=0; i<64; i++)
  1416.                 {
  1417.                         ld=iblk[i*2+0]-tblk[i*2+0];
  1418.                         e+=ld*ld;
  1419.                 }
  1420.        
  1421.                 i=sqrt(e/64);
  1422.                 return(i);
  1423.         }else if(flags&BGBTAC_EFL_STEREO)
  1424.         {
  1425.                 e=0;
  1426.                 for(i=0; i<64; i++)
  1427.                 {
  1428.                         ld=iblk[i*2+0]-tblk[i*2+0];
  1429.                         rd=iblk[i*2+1]-tblk[i*2+1];
  1430.                         c0=(iblk[i*2+0]+iblk[i*2+1])>>1;
  1431.                         c1=(tblk[i*2+0]+tblk[i*2+1])>>1;
  1432.                         cd=c1-c0;
  1433.                         e+=ld*ld;       e+=rd*rd;
  1434.                         e+=cd*cd;       e+=cd*cd;
  1435.                 }
  1436.        
  1437.                 i=sqrt(e/64);
  1438.                 return(i);
  1439.         }else
  1440.         {
  1441.                 e=0;
  1442.                 for(i=0; i<64; i++)
  1443.                 {
  1444.                         ld=iblk[i]-tblk[i];
  1445.                         e+=ld*ld;
  1446.                 }
  1447.        
  1448.                 i=sqrt(e/64);
  1449.                 return(i);
  1450.         }
  1451. }
  1452.  
  1453. BTAC_API int BGBTAC_CheckBlockBestS16(s16 *iblk, int flags)
  1454. {
  1455.         s16 eblk[128];
  1456.         byte tblk[32];
  1457.         int bn, be, te;
  1458.         int i;
  1459.        
  1460.         bn=0; be=999999999;
  1461.         for(i=0; i<5; i++)
  1462.         {
  1463.                 BGBTAC_EncodeBlockTagS16(iblk, tblk, i, flags);
  1464.                 BGBTAC_DecodeBlockTagS16(tblk, eblk, flags);
  1465.                 te=BGBTAC_CalcBlockErrorS16(iblk, eblk, flags);
  1466.                 if(te<be) { bn=i; be=te; }
  1467.         }
  1468.        
  1469.         return(bn);
  1470. }
  1471.  
  1472.  
  1473. BTAC_API void BGBTAC_EncodeStreamS16(
  1474.         s16 *iblk, byte *oblk, int len, int flags)
  1475. {
  1476.         int tcnt[16];
  1477.         int i, j, n, tag, ltag, rtag, fl2;
  1478.        
  1479.         for(i=0; i<16; i++)
  1480.                 { tcnt[i]=0; }
  1481.        
  1482.         n=(len+63)/64;
  1483.         for(i=0; i<n; i++)
  1484.         {
  1485.                 fl2=flags;
  1486.                 if((i>0) && i<(n-1))
  1487.                         fl2|=BGBTAC_EFL_MIDSTREAM;
  1488.  
  1489.                 if((flags&BGBTAC_EFL_STEREO) && (flags&BGBTAC_EFL_HALFMONO))
  1490.                 {
  1491. //                      tag=0;
  1492. //                      tag=2;  //2, 3
  1493. //                      tag=BGBTAC_CheckBlockBestS16(
  1494. //                              iblk+i*2*64+0, flags&(~BGBTAC_EFL_HALFMONO));
  1495.  
  1496.                         ltag=BGBTAC_CheckBlockBestS16(iblk+i*2*64+0, flags);
  1497.                         rtag=BGBTAC_CheckBlockBestS16(iblk+i*2*64+1, flags);
  1498.  
  1499.                         BGBTAC_EncodeBlockTagS16(
  1500.                                 iblk+i*2*64+0, oblk+i*64+ 0, ltag, fl2);
  1501.                         BGBTAC_EncodeBlockTagS16(
  1502.                                 iblk+i*2*64+1, oblk+i*64+32, rtag, fl2);
  1503. //                      tcnt[tag]++;
  1504.  
  1505.                         tcnt[ltag]++;
  1506.                         tcnt[rtag]++;
  1507.                 }else if(flags&BGBTAC_EFL_STEREO)
  1508.                 {
  1509. //                      tag=0;
  1510. //                      tag=1;
  1511. //                      tag=4;
  1512.                         tag=BGBTAC_CheckBlockBestS16(iblk+i*2*64, flags);
  1513. //                      BGBTAC_EncodeBlockTagS16(iblk+i*2*64,
  1514. //                              oblk+i*32, tag, flags);
  1515.                         BGBTAC_EncodeBlockTagS16(iblk+i*2*64, oblk+i*32, tag, fl2);
  1516.                
  1517. //                      printf("%d", tag);
  1518.                         tcnt[tag]++;
  1519.                 }else
  1520.                 {
  1521.                         tag=BGBTAC_CheckBlockBestS16(iblk+i*64, flags);
  1522.                         BGBTAC_EncodeBlockTagS16(iblk+i*64, oblk+i*32, tag, fl2);
  1523.                         tcnt[tag]++;
  1524.                 }
  1525.         }
  1526.  
  1527. //      printf("\n");
  1528.        
  1529.         printf("Encode %d: ", n);
  1530.         for(i=0; i<16; i++)
  1531.                 printf("%d ", tcnt[i]);
  1532.         printf("\n");
  1533. }
  1534.  
  1535. BTAC_API void BGBTAC_DecodeStreamS16(
  1536.         byte *iblk, s16 *oblk, int len, int flags)
  1537. {
  1538.         int p0, p1, p2, p3;
  1539.         int q0, q1, q2, q3;
  1540.         float f, g;
  1541.         int i, j, k, n;
  1542.        
  1543.         n=(len+63)/64;
  1544.         for(i=0; i<n; i++)
  1545.         {
  1546.                 if((flags&BGBTAC_EFL_STEREO) && (flags&BGBTAC_EFL_HALFMONO))
  1547.                 {
  1548.                         BGBTAC_DecodeBlockTagS16(
  1549.                                 iblk+i*64+ 0, oblk+i*2*64+0, flags);
  1550.                         BGBTAC_DecodeBlockTagS16(
  1551.                                 iblk+i*64+32, oblk+i*2*64+1, flags);
  1552.                 }else if(flags&BGBTAC_EFL_STEREO)
  1553.                 {
  1554.                         BGBTAC_DecodeBlockTagS16(iblk+i*32, oblk+i*2*64, flags);
  1555.                 }else
  1556.                 {
  1557.                         BGBTAC_DecodeBlockTagS16(iblk+i*32, oblk+i*64, flags);
  1558.                 }
  1559.         }
  1560.  
  1561.         if((flags&BGBTAC_EFL_STEREO) && (flags&BGBTAC_EFL_HALFMONO))
  1562.         {
  1563.                 BGBTAC_DeblockStreamS16(oblk, len);
  1564.                 BGBTAC_FilterStreamS16(oblk, len);
  1565.         }else if(flags&BGBTAC_EFL_STEREO)
  1566.         {
  1567.                 BGBTAC_DeblockStreamS16(oblk, len);
  1568.                 BGBTAC_FilterStreamS16(oblk, len);
  1569.         }else
  1570.         {
  1571.                 BGBTAC_DeblockStreamMonoS16(oblk, len);
  1572.                 BGBTAC_FilterStreamMonoS16(oblk, len);
  1573.         }
  1574. }
clone this paste RAW Paste Data