API tools faq
paste
Advertisement
cr88192

Experimental Block Audio Codec 2

cr88192
Apr 28th, 2013
205
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 29.84 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!