API tools faq
paste
cr88192

BTAC1C Basic Impl

cr88192
Dec 15th, 2016
445
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 29.02 KB | None | 0 0
raw download clone embed print report
  1. /* Header stuff */
  2.  
  3. /*
  4.  
  5. typedef struct btac1c_idxstate_s btac1c_idxstate;
  6.  
  7. struct btac1c_idxstate_s {
  8. u16 idx;                    //step index values
  9. s16 lpred;                  //left/center predictor value
  10. s16 rpred;                  //right/side predictor value
  11. byte tag;                   //last (or forced) block type
  12. byte bcfcn;                 //center function
  13. byte bsfcn;                 //side function
  14. byte usefx;                 //number of FIR filters to use
  15. s16 firfx[4][8];            //FIR filter coeffs (8.8)
  16. };
  17.  
  18. */
  19.  
  20.  
  21. /* Common */
  22.  
  23. static int btac1c_index_table[16] = {
  24.   -1, -1, -1, -1, 2, 4, 6, 8,
  25.   -1, -1, -1, -1, 2, 4, 6, 8
  26. };
  27.  
  28. //static int btac1c_step_table[89] = {
  29. static int btac1c_step_table[128] = {
  30.      7,     8,     9,    10,    11,    12,    13,    14,    16,    17,
  31.     19,    21,    23,    25,    28,    31,    34,    37,    41,    45,
  32.     50,    55,    60,    66,    73,    80,    88,    97,   107,   118,
  33.    130,   143,   157,   173,   190,   209,   230,   253,   279,   307,
  34.    337,   371,   408,   449,   494,   544,   598,   658,   724,   796,
  35.    876,   963,  1060,  1166,  1282,  1411,  1552,  1707,  1878,  2066,
  36.   2272,  2499,  2749,  3024,  3327,  3660,  4026,  4428,  4871,  5358,
  37.   5894,  6484,  7132,  7845,  8630,  9493, 10442, 11487, 12635, 13899,
  38.  15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
  39. };
  40.  
  41. int BGBDT_SndBTAC1C2_PredictSample(
  42.     int *psamp, int idx, int pfcn,
  43.     btac1c_idxstate *ridx)
  44. {
  45.     int pred, p0, p1;
  46.     int i;
  47.    
  48.     i=idx;
  49.  
  50.     switch(pfcn)
  51.     {
  52.     case 0:
  53.         pred=psamp[(i-1)&7];
  54.         break;
  55.     case 1:
  56.         pred=2*psamp[(i-1)&7]-psamp[(i-2)&7];
  57.         break;
  58.     case 2:
  59.         pred=(3*psamp[(i-1)&7]-psamp[(i-2)&7])>>1;
  60.         break;
  61.     case 3:
  62.         pred=(5*psamp[(i-1)&7]-psamp[(i-2)&7])>>2;
  63.         break;
  64.     case 4:
  65.         p0=(psamp[(i-1)&7]+psamp[(i-2)&7]);
  66.         p1=(psamp[(i-2)&7]+psamp[(i-3)&7]);
  67.         pred=p0-(p1>>1);
  68.         break;
  69.     case 5:
  70.         p0=(psamp[(i-1)&7]+psamp[(i-2)&7]);
  71.         p1=(psamp[(i-2)&7]+psamp[(i-3)&7]);
  72.         pred=(3*p0-p1)>>2;
  73.         break;
  74.     case 6:
  75.         p0=(psamp[(i-1)&7]+psamp[(i-2)&7]);
  76.         p1=(psamp[(i-2)&7]+psamp[(i-3)&7]);
  77.         pred=(5*p0-p1)>>3;
  78.         break;
  79.     case 7:
  80.         pred=(  18*psamp[(i-1)&7]-4*psamp[(i-2)&7]+
  81.                  3*psamp[(i-3)&7]-2*psamp[(i-4)&7]+
  82.                  1*psamp[(i-5)&7])/16;
  83.         break;
  84.     case 8:
  85.         pred=(  72*psamp[(i-1)&7]-16*psamp[(i-2)&7]+
  86.                 12*psamp[(i-3)&7]- 8*psamp[(i-4)&7]+
  87.                  5*psamp[(i-5)&7]- 3*psamp[(i-6)&7]+
  88.                  3*psamp[(i-7)&7]- 1*psamp[(i-8)&7])/64;
  89.         break;
  90.     case 9:
  91.         pred=(  76*psamp[(i-1)&7]-17*psamp[(i-2)&7]+
  92.                 10*psamp[(i-3)&7]- 7*psamp[(i-4)&7]+
  93.                  5*psamp[(i-5)&7]- 4*psamp[(i-6)&7]+
  94.                  4*psamp[(i-7)&7]- 3*psamp[(i-8)&7])/64;
  95.         break;
  96.     case 10:
  97.         p0=(psamp[(i-1)&7]+psamp[(i-2)&7]+psamp[(i-3)&7]+psamp[(i-4)&7]);
  98.         p1=(psamp[(i-5)&7]+psamp[(i-6)&7]+psamp[(i-7)&7]+psamp[(i-8)&7]);
  99.         pred=(5*p0-p1)>>4;
  100.         break;
  101.     case 11:
  102.         p0=(psamp[(i-1)&7]+psamp[(i-2)&7]+psamp[(i-3)&7]+psamp[(i-4)&7]);
  103.         p1=(psamp[(i-5)&7]+psamp[(i-6)&7]+psamp[(i-7)&7]+psamp[(i-8)&7]);
  104.         pred=(p0+p1)>>3;
  105.         break;
  106.  
  107.     case 12:    case 13:
  108.     case 14:    case 15:
  109.         pred=(
  110.             ridx->firfx[pfcn-12][0]*psamp[(i-1)&7]+
  111.             ridx->firfx[pfcn-12][1]*psamp[(i-2)&7]+
  112.             ridx->firfx[pfcn-12][2]*psamp[(i-3)&7]+
  113.             ridx->firfx[pfcn-12][3]*psamp[(i-4)&7]+
  114.             ridx->firfx[pfcn-12][4]*psamp[(i-5)&7]+
  115.             ridx->firfx[pfcn-12][5]*psamp[(i-6)&7]+
  116.             ridx->firfx[pfcn-12][6]*psamp[(i-7)&7]+
  117.             ridx->firfx[pfcn-12][7]*psamp[(i-8)&7])/256;
  118.         break;
  119.  
  120.     default:
  121.         pred=0;
  122.         break;
  123.     }
  124.     return(pred);
  125. }
  126.  
  127. BTEIFGL_API void btac1c_initstate(btac1c_idxstate *ridx)
  128. {
  129.     memset(ridx, 0, sizeof(btac1c_idxstate));
  130. }
  131.  
  132.  
  133. /* Decoder */
  134.  
  135. BTEIFGL_API void BGBDT_SndBTAC1C2_DecodeBlockMono(
  136.     byte *ibuf, s16 *obuf, int len, btac1c_idxstate *ridx)
  137. {
  138.     int psamp[8];
  139. //  int p0, p1, p2, p3;
  140.     int pred, pfcn, index, step, diff, uni, sni;
  141.     int i, j;
  142.    
  143.     pred=(s16)(ibuf[0]+(ibuf[1]<<8));
  144.     index=ibuf[2]&127;
  145.     pfcn=ibuf[3]&15;
  146.    
  147.     psamp[0]=pred;  psamp[1]=pred;  psamp[2]=pred;  psamp[3]=pred;
  148.     psamp[4]=pred;  psamp[5]=pred;  psamp[6]=pred;  psamp[7]=pred;
  149.    
  150.     step=btac1c_step_table[index&127];
  151.  
  152.     for(i=0; i<len; i++)
  153.     {
  154.         j=(ibuf[4+(i>>1)]>>((i&1)*4))&15;
  155.         uni=j;
  156.         sni=(j&8)?(-(j&7)):(j&7);
  157.  
  158.         if(pfcn)
  159.             { pred=BGBDT_SndBTAC1C2_PredictSample(psamp, i, pfcn, ridx); }
  160.  
  161.         index=index+btac1c_index_table[uni];
  162.         index=(index<0)?0:((index>88)?88:index);
  163.         diff=((2*(uni&7)+1)*step)/8;
  164.         if(uni&8)diff=-diff;
  165.         pred=pred+diff;
  166.         step=btac1c_step_table[index];
  167.  
  168.         pred=(pred<(-32768))?(-32768):((pred>32767)?32767:pred);
  169.         obuf[i]=pred;
  170.         psamp[i&7]=pred;
  171.     }
  172. }
  173.  
  174. void BGBDT_SndBTAC1C2_DecodeMonoBlockStereo(
  175.     byte *ibuf, s16 *obuf, int len,
  176.     btac1c_idxstate *ridx)
  177. {
  178.     int psamp[8];
  179.     int pred, index, step, diff, uni, sni, ofs;
  180.     int lpred, rpred;
  181.     int pfcn;
  182.     int lp, rp, itr;
  183.     int i, j, k, l;
  184.    
  185.     pred=(s16)(ibuf[0]+(ibuf[1]<<8));
  186.     index=ibuf[2]&127;
  187.     ofs=(s16)(ibuf[4]+(ibuf[5]<<8));
  188.     pfcn=ibuf[3]&15;
  189.     itr=ibuf[7]&3;
  190.    
  191.     psamp[0]=pred;  psamp[1]=pred;
  192.     psamp[2]=pred;  psamp[3]=pred;
  193.     psamp[4]=pred;  psamp[5]=pred;
  194.     psamp[6]=pred;  psamp[7]=pred;
  195.    
  196.     step=btac1c_step_table[index&127];
  197.  
  198.     for(i=0; i<len; i++)
  199.     {
  200.         uni=(ibuf[8+(i>>1)]>>((i&1)*4))&15;
  201.  
  202.         if(pfcn)
  203.             { pred=BGBDT_SndBTAC1C2_PredictSample(psamp, i, pfcn, ridx); }
  204.  
  205.         index=index+btac1c_index_table[uni];
  206.         index=(index<0)?0:((index>88)?88:index);
  207.         diff=((2*(uni&7)+1)*step)/8;
  208.         if(uni&8)diff=-diff;
  209.         pred=pred+diff;
  210.         step=btac1c_step_table[index];
  211.  
  212.         pred=(pred<(-32768))?(-32768):((pred>32767)?32767:pred);
  213.         psamp[i&7]=pred;
  214.  
  215.         lp=pred+ofs; rp=lp-(ofs<<1);
  216. //      rp=(pred<<1)-ofs;
  217. //      lp=rp+ofs;
  218.  
  219.         lp=(lp<(-32768))?(-32768):((lp>32767)?32767:lp);
  220.         rp=(rp<(-32768))?(-32768):((rp>32767)?32767:rp);
  221.         obuf[i*2+0]=lp;
  222.         obuf[i*2+1]=rp;
  223.     }
  224.  
  225. //  if(itr==3)
  226.     if(itr)
  227.     {
  228.         l=len-2;
  229.         for(i=0; i<l; i+=2)
  230.         {
  231.             lp=(obuf[(i+0)*2+0]+obuf[(i+2)*2+0])>>1;
  232.             obuf[(i+1)*2+0]=lp;
  233.         }
  234.         for(i=1; i<l; i+=2)
  235.         {
  236.             rp=(obuf[(i+0)*2+1]+obuf[(i+2)*2+1])>>1;
  237.             obuf[(i+1)*2+1]=rp;
  238.         }
  239.     }
  240. }
  241.  
  242. void BGBDT_SndBTAC1C2_DecodeJointBlockStereo(
  243.     byte *ibuf, s16 *obuf, int len,
  244.     btac1c_idxstate *ridx)
  245. {
  246.     int psamp[8];
  247.     int pred, index, step, diff, uni, sni, ofs;
  248.     int lp, rp, pfcn, ispf;
  249.     int p0, p1, p2, p3;
  250.     int i, j, k, l;
  251.    
  252.     /* decode center channel */
  253.     pred=(s16)(ibuf[0]+(ibuf[1]<<8));
  254.     index=ibuf[2]&127;
  255.     pfcn=ibuf[3]&15;
  256.     step=btac1c_step_table[index&127]; 
  257.     psamp[0]=pred;  psamp[1]=pred;
  258.     psamp[2]=pred;  psamp[3]=pred;
  259.     psamp[4]=pred;  psamp[5]=pred;
  260.     psamp[6]=pred;  psamp[7]=pred;
  261.    
  262.     ispf=(ibuf[3]!=0)|(ibuf[7]!=0);
  263.    
  264.     for(i=0; i<len; i++)
  265.     {
  266.         k=ibuf[8+(i>>2)*2+0]|((ibuf[8+(i>>2)*2+1])<<8);
  267.         j=(k>>((i&3)*3))&7;
  268.         uni=j<<1;
  269. //      uni|=(uni>>2)&1;
  270.         uni|=((uni&6)==6)&ispf;
  271.  
  272.         if(pfcn)
  273.             { pred=BGBDT_SndBTAC1C2_PredictSample(psamp, i, pfcn, ridx); }
  274.  
  275.         index=index+btac1c_index_table[uni];
  276.         index=(index<0)?0:((index>88)?88:index);
  277.         diff=((2*(uni&7)+1)*step)/8;
  278.         if(uni&8)diff=-diff;
  279.         pred=pred+diff;
  280.         step=btac1c_step_table[index];
  281.  
  282.         pred=(pred<(-32768))?(-32768):((pred>32767)?32767:pred);
  283.         obuf[i*2+0]=pred;
  284.         psamp[i&7]=pred;
  285.     }
  286.    
  287.     l=len>>2;
  288.  
  289.     /* decode side channel */
  290.     pred=(s16)(ibuf[4]+(ibuf[5]<<8));
  291.     index=ibuf[6]&127;
  292.     pfcn=ibuf[7]&15;
  293.     step=btac1c_step_table[index&127];
  294.     psamp[0]=pred;  psamp[1]=pred;
  295.     psamp[2]=pred;  psamp[3]=pred;
  296.     psamp[4]=pred;  psamp[5]=pred;
  297.     psamp[6]=pred;  psamp[7]=pred;
  298.    
  299.     for(i=0; i<l; i++)
  300.     {
  301.         k=ibuf[8+i*2+0]|((ibuf[8+i*2+1])<<8);
  302.         uni=(k>>12)&15;
  303.  
  304.         if(pfcn)
  305.             { pred=BGBDT_SndBTAC1C2_PredictSample(psamp, i, pfcn, ridx); }
  306.  
  307.         index=index+btac1c_index_table[uni];
  308.         index=(index<0)?0:((index>88)?88:index);
  309.         diff=((2*(uni&7)+1)*step)/8;
  310.         if(uni&8)diff=-diff;
  311.         pred=pred+diff;
  312.         step=btac1c_step_table[index];
  313.  
  314.         pred=(pred<(-32768))?(-32768):((pred>32767)?32767:pred);
  315.         obuf[i*8+1]=pred;
  316.         psamp[i&7]=pred;
  317.     }
  318.  
  319.     /* center/side -> stereo */
  320.     for(i=0; i<l; i++)
  321.     {
  322.         ofs=obuf[i*8+1];
  323.         for(j=0; j<4; j++)
  324.         {
  325.             k=(i*4+j)*2;
  326.             pred=obuf[k+0];
  327.             lp=pred+ofs; rp=lp-(ofs<<1);
  328.             lp=(lp<(-32768))?(-32768):((lp>32767)?32767:lp);
  329.             rp=(rp<(-32768))?(-32768):((rp>32767)?32767:rp);
  330.             obuf[k+0]=lp; obuf[k+1]=rp;
  331.         }
  332.     }
  333. }
  334.  
  335. void BGBDT_SndBTAC1C2_DecodeStereoBlockStereoI(
  336.     byte *ibuf, s16 *obuf, int len, btac1c_idxstate *ridx)
  337. {
  338.     int plsamp[8], prsamp[8];
  339.     int lpred, lindex, lstep, ldiff, luni, lsni;
  340.     int rpred, rindex, rstep, rdiff, runi, rsni;
  341.     int pfcn;
  342.     int i, j, k;
  343.    
  344.     lpred=(s16)(ibuf[0]+(ibuf[1]<<8));
  345.     rpred=(s16)(ibuf[4]+(ibuf[5]<<8));
  346.     lindex=ibuf[2];
  347.     rindex=ibuf[6];
  348.     pfcn=ibuf[3]&15;
  349.  
  350.     lstep=btac1c_step_table[lindex&127];
  351.     rstep=btac1c_step_table[rindex&127];
  352.  
  353.     plsamp[0]=lpred;    plsamp[1]=lpred;
  354.     plsamp[2]=lpred;    plsamp[3]=lpred;
  355.     plsamp[4]=lpred;    plsamp[5]=lpred;
  356.     plsamp[6]=lpred;    plsamp[7]=lpred;
  357.     prsamp[0]=rpred;    prsamp[1]=rpred;
  358.     prsamp[2]=rpred;    prsamp[3]=rpred;
  359.     prsamp[4]=rpred;    prsamp[5]=rpred;
  360.     prsamp[6]=rpred;    prsamp[7]=rpred;
  361.  
  362.     for(i=0; i<len; i++)
  363.     {
  364.         k=((i>>3)*8)+((i&7)>>1);
  365.         luni=(ibuf[ 8+k]>>((i&1)*4))&15;
  366.         runi=(ibuf[12+k]>>((i&1)*4))&15;
  367.  
  368.         if(pfcn)
  369.         {
  370.             lpred=BGBDT_SndBTAC1C2_PredictSample(plsamp, i, pfcn, ridx);
  371.             rpred=BGBDT_SndBTAC1C2_PredictSample(prsamp, i, pfcn, ridx);
  372.         }
  373.  
  374.         lindex=lindex+btac1c_index_table[luni];
  375.         lindex=(lindex<0)?0:((lindex>88)?88:lindex);
  376.         ldiff=((2*(luni&7)+1)*lstep)/8;
  377.         if(luni&8)ldiff=-ldiff;
  378.         lpred=lpred+ldiff;
  379.         lstep=btac1c_step_table[lindex];
  380.  
  381.         rindex=rindex+btac1c_index_table[runi];
  382.         rindex=(rindex<0)?0:((rindex>88)?88:rindex);
  383.         rdiff=((2*(runi&7)+1)*rstep)/8;
  384.         if(runi&8)rdiff=-rdiff;
  385.         rpred=rpred+rdiff;
  386.         rstep=btac1c_step_table[rindex];
  387.  
  388.         lpred=(lpred<(-32768))?(-32768):((lpred>32767)?32767:lpred);
  389.         rpred=(rpred<(-32768))?(-32768):((rpred>32767)?32767:rpred);
  390.        
  391.         obuf[i*2+0]=lpred;
  392.         obuf[i*2+1]=rpred;
  393.         plsamp[i&7]=lpred;
  394.         prsamp[i&7]=rpred;
  395.     }
  396.     obuf[i*2+0]=lpred;
  397.     obuf[i*2+1]=rpred;
  398. }
  399.  
  400. void BGBDT_SndBTAC1C2_DecodeStereoBlockStereo(
  401.     byte *ibuf, s16 *obuf, int len, btac1c_idxstate *ridx)
  402. {
  403.     int p0, p1, p2, p3;
  404.     int p4, p5, p6, p7;
  405.     int i0, i1, i2, i3;
  406.     int m0, m1;
  407.     int itr;
  408.     int i, j, k, l;
  409.  
  410.     BGBDT_SndBTAC1C2_DecodeStereoBlockStereoI(ibuf, obuf, len>>1, ridx);
  411.  
  412.     itr=ibuf[7]&3;
  413.  
  414. #if 1
  415.     if(itr==3)
  416.     {
  417.         l=len>>1;
  418.         for(i=len-1; i>0; i--)
  419.         {
  420.             i0=(i+0)>>1;    i1=(i+1)>>1;
  421.             i2=(i+0)>>1;    i3=(i-1)>>1;
  422.             obuf[i*2+0]=(obuf[i0*2+0]+obuf[i1*2+0])>>1;
  423.             obuf[i*2+1]=(obuf[i2*2+1]+obuf[i3*2+1])>>1;
  424.         }
  425.     }else if(itr==0)
  426.     {
  427.         l=len>>1;
  428.         for(i=len-1; i>0; i--)
  429.         {
  430.             j=i>>1;
  431.             obuf[i*2+0]=obuf[j*2+0];
  432.             obuf[i*2+1]=obuf[j*2+1];
  433.         }
  434.     }else
  435.     {
  436.         l=len>>1;
  437.         for(i=len-1; i>0; i--)
  438.         {
  439.             i0=(i+0)>>1; i1=(i+((itr==1)*2-1))>>1;
  440.             obuf[i*2+0]=(obuf[i0*2+0]+obuf[i1*2+0])>>1;
  441.             obuf[i*2+1]=(obuf[i0*2+1]+obuf[i1*2+1])>>1;
  442.         }
  443.     }
  444. #endif
  445. }
  446.  
  447. BTEIFGL_API void BGBDT_SndBTAC1C2_DecodeBlockStereo(
  448.     byte *ibuf, s16 *obuf, int len, btac1c_idxstate *ridx)
  449. {
  450.     int i;
  451.    
  452.     i=ibuf[6];
  453.  
  454.     if(i<89)
  455.     {
  456.         BGBDT_SndBTAC1C2_DecodeStereoBlockStereo(ibuf, obuf, len, ridx);
  457.         return;
  458.     }
  459.  
  460.     if(i==89)
  461.     {
  462.         BGBDT_SndBTAC1C2_DecodeMonoBlockStereo(ibuf, obuf, len, ridx);
  463.         return;
  464.     }
  465.  
  466.     if((i>=128) && (i<217))
  467.     {
  468.         BGBDT_SndBTAC1C2_DecodeJointBlockStereo(ibuf, obuf, len, ridx);
  469.         return;
  470.     }
  471.  
  472.     for(i=0; i<len; i++)
  473.     {
  474.         obuf[i*2+0]=0;
  475.         obuf[i*2+1]=0;
  476.     }
  477. }
  478.  
  479. BTEIFGL_API void BGBDT_SndBTAC1C2_DecodeBlockStereoLg2(
  480.     byte *ibuf, s16 *obuf, int lg2, btac1c_idxstate *ridx)
  481. {
  482.     int i, j, k, l;
  483.  
  484.     BGBDT_SndBTAC1C2_DecodeBlockStereo(ibuf, obuf, (1<<lg2)-16, ridx);
  485.    
  486.     l=1<<lg2;
  487.     for(i=l-1; i>0; i--)
  488.     {
  489.         j=(i+1)>>(lg2-4);
  490.         k=(i+0)>>(lg2-4);
  491. //      obuf[i*2+0]=obuf[(i-j)*2+0];
  492. //      obuf[i*2+1]=obuf[(i-j)*2+1];
  493.         obuf[i*2+0]=(obuf[(i-j)*2+0]+obuf[(i-k)*2+0])>>1;
  494.         obuf[i*2+1]=(obuf[(i-j)*2+1]+obuf[(i-k)*2+1])>>1;
  495.     }
  496. }
  497.  
  498. BTEIFGL_API void BGBDT_SndBTAC1C2_DecodeBlockMonoLg2(
  499.     byte *ibuf, s16 *obuf, int lg2, btac1c_idxstate *ridx)
  500. {
  501.     int i, j, k, l;
  502.  
  503.     BGBDT_SndBTAC1C2_DecodeBlockMono(ibuf, obuf, (1<<lg2)-8, ridx);
  504.  
  505. #if 0
  506.     l=1<<lg2;
  507.     for(i=l-1; i>0; i--)
  508.     {
  509.         j=(i+1)>>(lg2-3);
  510.         obuf[i]=obuf[i-j];
  511.     }
  512. #endif
  513.  
  514. #if 1
  515.     l=1<<lg2;
  516.  
  517.     i=l-1;
  518.     j=(i+1)>>(lg2-3);
  519.     obuf[i]=obuf[i-j];
  520.  
  521.     for(i=l-2; i>0; i--)
  522.     {
  523.         j=(i+1)>>(lg2-3);   k=(i+0)>>(lg2-3);
  524.         obuf[i]=(obuf[i-j]+obuf[i-k])>>1;
  525.     }
  526. #endif
  527. }
  528.  
  529.  
  530. /* Encoder */
  531.  
  532. BTEIFGL_API int BGBDT_SndBTAC1C2_EncodeQuantUni(
  533.     int tgt, int pred, int step, int lsbit)
  534. {
  535.     int uni, sni, diff;
  536.  
  537.     diff=tgt-pred;
  538.  
  539.     if(diff>=0)
  540.     {
  541.         sni=(diff*8-1)/(step*2);
  542.         uni=(sni>7)?7:sni;
  543.     }else
  544.     {
  545.         sni=(-diff*8-1)/(step*2);
  546.         uni=(sni>7)?15:(8|sni);
  547.     }
  548.  
  549.     uni=BGBDT_SndBTAC1C2_EncodeQuantUni3(uni, step, pred, tgt, lsbit);
  550.     return(uni);
  551. }
  552.  
  553. BTEIFGL_API int BGBDT_SndBTAC1C2_EncodeQuantUni3(
  554.     int uni, int step, int pred, int tgt, int lsbit)
  555. {
  556.     int uni1, uni2;
  557.     int diff, p0, p1, p2, d0, d1, d2;
  558.  
  559.     uni1=uni+1;
  560.     uni2=uni-1;
  561.  
  562.     if((uni^uni1)&(~7))uni1=uni;
  563.     if((uni^uni2)&(~7))uni2=uni;
  564.  
  565.     if(lsbit)
  566.     {
  567.         if(lsbit==4)
  568.         {
  569.             uni&=~1;
  570.             uni1&=~1;
  571.             uni2&=~1;
  572.             uni|=((uni&6)==6);
  573.             uni1|=((uni1&6)==6);
  574.             uni2|=((uni2&6)==6);
  575.         }else if(lsbit&1)
  576.             { uni|=1; uni1|=1; uni2|=1; }
  577.         else
  578.             { uni&=~1; uni1&=~1; uni2&=~1; }
  579.     }
  580.  
  581.     diff=((2*(uni&7)+1)*step)/8;
  582.     if(uni&8)diff=-diff;
  583.     p0=pred+diff; d0=tgt-p0;
  584.     d0=d0^(d0>>31);
  585.  
  586.     diff=((2*(uni1&7)+1)*step)/8;
  587.     if(uni1&8)diff=-diff;
  588.     p1=pred+diff; d1=tgt-p1;
  589.     d1=d1^(d1>>31);
  590.  
  591.     diff=((2*(uni2&7)+1)*step)/8;
  592.     if(uni2&8)diff=-diff;
  593.     p2=pred+diff; d2=tgt-p2;
  594.     d2=d2^(d2>>31);
  595.  
  596.     if((p0<-32767) || (p0>32767))
  597.         d0+=65536;
  598.     if((p1<-32767) || (p1>32767))
  599.         d1+=65536;
  600.     if((p2<-32767) || (p2>32767))
  601.         d2+=65536;
  602.    
  603.     if(d1<d0)uni=uni1;
  604.     if(d2<d0)uni=uni2;
  605.  
  606.     return(uni);
  607. }
  608.  
  609. void BGBDT_SndBTAC1C2_PredictSampleMulti(
  610.     int *psamp, int idx, btac1c_idxstate *ridx,
  611.     int *prvec)
  612. {
  613.     int fcn;
  614.     for(fcn=0; fcn<(12+ridx->usefx); fcn++)
  615.     {
  616.         prvec[fcn]=BGBDT_SndBTAC1C2_PredictSample(
  617.             psamp, idx, fcn, ridx);
  618.     }
  619. }
  620.  
  621. int BGBDT_SndBTAC1C2_SelectFilterBlockMono(
  622.     s16 *ibuf, int len, btac1c_idxstate *ridx)
  623. {
  624.     int psamp[8];
  625.     int prvec[16];
  626.     s64 evec[16];
  627.     int p0, p1, p2, d0, d1, d2, uni1, uni2;
  628.     int lsbt, lsbit, npf;
  629.     int pred, index, step, diff, uni, sni;
  630.     int i, j, k;
  631.    
  632.     pred=(ibuf[0]+ibuf[1]+ibuf[2]+ibuf[3])>>2;
  633.    
  634.     psamp[0]=pred;  psamp[1]=pred;
  635.     psamp[2]=pred;  psamp[3]=pred;
  636.     psamp[4]=pred;  psamp[5]=pred;
  637.     psamp[6]=pred;  psamp[7]=pred;
  638.  
  639.     npf=12+ridx->usefx;
  640.     for(i=0; i<npf; i++)
  641.         { evec[i]=0; }
  642.  
  643.     for(i=0; i<len; i++)
  644.     {
  645.         BGBDT_SndBTAC1C2_PredictSampleMulti(psamp, i, ridx, prvec);
  646.  
  647.         p0=ibuf[i];
  648.  
  649.         for(j=0; j<npf; j++)
  650.         {
  651.             d0=p0-prvec[j];
  652.             d1=d0*d0;
  653.             if(d1<0)d1=1999999999;
  654.             evec[j]+=d1;
  655.         }
  656.  
  657.         pred=p0;
  658.         psamp[i&7]=pred;
  659.     }
  660.    
  661.     uni=7;
  662.     for(i=0; i<npf; i++)
  663.     {
  664.         if(evec[i]<evec[uni])
  665.             uni=i;
  666.     }
  667.     return(uni);
  668. }
  669.  
  670. int BGBDT_SndBTAC1C2_SelectFilterBlockStereo(
  671.     s16 *ibuf, int len, btac1c_idxstate *ridx,
  672.     int *rpcfcn, int *rpsfcn)
  673. {
  674.     int pcsamp[8], pssamp[8];
  675.     int prcvec[16];
  676.     int prsvec[16];
  677.     s64 ecvec[16], esvec[16];
  678.     int p0, p1, p2, p3, d0, d1, d2, uni1, uni2;
  679.     int lsbt, lsbit, npf;
  680.     int cpred, spred, index, step, diff, uni, sni;
  681.     int i, j, k;
  682.    
  683.     cpred=(ibuf[0]+ibuf[1]+ibuf[2]+ibuf[3])>>2;
  684.     spred=((ibuf[0]+ibuf[2])/2)-((ibuf[1]+ibuf[3])/2);
  685.    
  686.     pcsamp[0]=cpred; pcsamp[1]=cpred; pcsamp[2]=cpred; pcsamp[3]=cpred;
  687.     pcsamp[4]=cpred; pcsamp[5]=cpred; pcsamp[6]=cpred; pcsamp[7]=cpred;
  688.     pssamp[0]=spred; pssamp[1]=spred; pssamp[2]=spred; pssamp[3]=spred;
  689.     pssamp[4]=spred; pssamp[5]=spred; pssamp[6]=spred; pssamp[7]=spred;
  690.  
  691.     npf=12+ridx->usefx;
  692.     for(i=0; i<npf; i++)
  693.         { ecvec[i]=0; esvec[i]=0; }
  694.  
  695.     for(i=0; i<len; i++)
  696.     {
  697.         BGBDT_SndBTAC1C2_PredictSampleMulti(pcsamp, i, ridx, prcvec);
  698.         BGBDT_SndBTAC1C2_PredictSampleMulti(pssamp, i, ridx, prsvec);
  699.  
  700.         p0=ibuf[i*2+0];
  701.         p1=ibuf[i*2+1];
  702.  
  703.         p2=(p0+p1)/2;
  704.         p3=p0-p1;
  705.  
  706.         for(j=0; j<npf; j++)
  707.         {
  708.             d0=p2-prcvec[j];
  709.             d1=d0*d0;
  710.             if(d1<0)d1=1999999999;
  711.             ecvec[j]+=d1;
  712.  
  713.             d0=p2-prsvec[j];
  714.             d1=d0*d0;
  715.             if(d1<0)d1=1999999999;
  716.             esvec[j]+=d1;
  717.         }
  718.  
  719.         cpred=p2;
  720.         spred=p3;
  721.  
  722.         pcsamp[i&7]=cpred;
  723.         pssamp[i&7]=spred;
  724.     }
  725.    
  726.     uni=7; sni=7;
  727.     for(i=0; i<npf; i++)
  728.     {
  729.         if(ecvec[i]<ecvec[uni])
  730.             uni=i;
  731.         if(esvec[i]<esvec[sni])
  732.             sni=i;
  733.     }
  734.    
  735.     *rpcfcn=uni;
  736.     *rpsfcn=sni;
  737.     return(uni);
  738. }
  739.  
  740. BTEIFGL_API void BGBDT_SndBTAC1C2_EncodeBlockMonoPfcn(
  741.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx, int pfcn)
  742. {
  743.     int psamp[8];
  744.     int p0, p1, p2, d0, d1, d2, uni1, uni2;
  745.     int lsbt, lsbit;
  746.     int pred, index, step, diff, uni, sni;
  747.     int i, j, k;
  748.    
  749.     if(ridx && (ridx->tag==3))
  750.         { pred=ridx->lpred; }
  751.     else
  752.         { pred=(ibuf[0]+ibuf[1])>>1; }
  753.  
  754.     index=ridx?(ridx->idx):0;
  755.     index&=127;
  756.     if(index>88)
  757.         index=0;
  758.    
  759.     obuf[0]=pred&255;
  760.     obuf[1]=(pred>>8)&255;
  761.     obuf[2]=index;
  762.     obuf[3]=pfcn;
  763.    
  764.     memset(obuf+4, 0, (len+1)/2);
  765.    
  766.     step=btac1c_step_table[index&127];
  767.     lsbt=0;
  768.  
  769.     psamp[0]=pred;  psamp[1]=pred;  psamp[2]=pred;  psamp[3]=pred;
  770.     psamp[4]=pred;  psamp[5]=pred;  psamp[6]=pred;  psamp[7]=pred;
  771.  
  772.     for(i=0; i<len; i++)
  773.     {
  774.         if(pfcn)
  775.             { pred=BGBDT_SndBTAC1C2_PredictSample(psamp, i, pfcn, ridx); }
  776.         uni=BGBDT_SndBTAC1C2_EncodeQuantUni(ibuf[i], pred, step, 0);
  777.    
  778.         index=index+btac1c_index_table[uni];
  779.         index=(index<0)?0:((index>88)?88:index);
  780.         diff=((2*(uni&7)+1)*step)/8;
  781.         if(uni&8)diff=-diff;
  782.         pred=pred+diff;
  783.         step=btac1c_step_table[index];
  784.  
  785.         pred=(pred<(-32768))?(-32768):((pred>32767)?32767:pred);
  786.        
  787.         obuf[4+(i>>1)]|=uni<<((i&1)*4);
  788.         psamp[i&7]=pred;
  789.     }
  790.  
  791.     if(ridx)
  792.     {
  793. //      *ridx=index;
  794.         ridx->idx=index;
  795.         ridx->lpred=pred;
  796.         ridx->tag=3;
  797.     }
  798. }
  799.  
  800. BTEIFGL_API void BGBDT_SndBTAC1C2_EncodeBlockMono(
  801.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx)
  802. {
  803.     int fcn;
  804.    
  805.     if(ridx->bcfcn&0x40)
  806.     {
  807.         BGBDT_SndBTAC1C2_EncodeBlockMonoPfcn(
  808.             ibuf, obuf, len, ridx, (ridx->bcfcn)&15);
  809.         return;
  810.     }
  811.    
  812.     fcn=BGBDT_SndBTAC1C2_SelectFilterBlockMono(ibuf, len, ridx);
  813.     BGBDT_SndBTAC1C2_EncodeBlockMonoPfcn(ibuf, obuf, len, ridx, fcn);
  814. }
  815.  
  816. BTEIFGL_API void BGBDT_SndBTAC1C2_DumpStatBlocks(
  817.     byte *buf, int bsz, int nblks)
  818. {
  819.     int cnt[16];
  820.     int i, j, k;
  821.    
  822.     for(i=0; i<16; i++)
  823.     {
  824.         cnt[i]=0;
  825.     }
  826.  
  827.     for(i=0; i<nblks; i++)
  828.     {
  829.         j=buf[i*bsz+3];
  830.         cnt[j&15]++;
  831.     }
  832.    
  833.     for(i=0; i<4; i++)
  834.     {
  835.         printf("%2d: ", i*4);
  836.         for(j=0; j<4; j++)
  837.         {
  838.             k=i*4+j;
  839.             printf("%6d(%2.2f%%) ", cnt[k], (100.0*cnt[k])/(nblks+1));
  840.         }
  841.         printf("\n");
  842.     }
  843.     printf("\n");
  844. }
  845.  
  846.  
  847. BTEIFGL_API void BGBDT_SndBTAC1C2_DumpStereoStatBlocks(
  848.     byte *buf, int bsz, int nblks)
  849. {
  850.     int ccnt[16], scnt[16];
  851.     int tcnt[4];
  852.     int i, j, k;
  853.  
  854.     for(i=0; i<4; i++)
  855.         { tcnt[i]=0; }
  856.    
  857.     for(i=0; i<16; i++)
  858.     {
  859.         ccnt[i]=0;
  860.         scnt[i]=0;
  861.     }
  862.  
  863.     for(i=0; i<nblks; i++)
  864.     {
  865.         j=buf[i*bsz+3];
  866.         k=buf[i*bsz+7];
  867.        
  868.         if(buf[i*bsz+6]<89)
  869.         {
  870.             k=j;
  871.             tcnt[0]++;
  872.         }else if((buf[i*bsz+6]&127)<89)
  873.         {
  874.             tcnt[1]++;
  875.         }else if(buf[i*bsz+6]==89)
  876.         {
  877.             tcnt[2]++;
  878.         }else
  879.         {
  880.             tcnt[3]++;
  881.         }
  882.        
  883.         ccnt[j&15]++;
  884.         scnt[k&15]++;
  885.     }
  886.    
  887.     printf("SS=%d(%2.2f%%) JS=%d(%2.2f%%) MS=%d(%2.2f%%) Other=%d(%2.2f%%)\n",
  888.         tcnt[0], (100.0*tcnt[0])/(nblks+1),
  889.         tcnt[1], (100.0*tcnt[1])/(nblks+1),
  890.         tcnt[2], (100.0*tcnt[2])/(nblks+1),
  891.         tcnt[3], (100.0*tcnt[3])/(nblks+1));
  892.    
  893.     printf("Center/Left:\n");
  894.     for(i=0; i<4; i++)
  895.     {
  896.         printf("%2d: ", i*4);
  897.         for(j=0; j<4; j++)
  898.         {
  899.             k=i*4+j;
  900.             printf("%6d(%2.2f%%) ", ccnt[k], (100.0*ccnt[k])/(nblks+1));
  901.         }
  902.         printf("\n");
  903.     }
  904.     printf("Side/Right:\n");
  905.     for(i=0; i<4; i++)
  906.     {
  907.         printf("%2d: ", i*4);
  908.         for(j=0; j<4; j++)
  909.         {
  910.             k=i*4+j;
  911.             printf("%6d(%2.2f%%) ", scnt[k], (100.0*scnt[k])/(nblks+1));
  912.         }
  913.         printf("\n");
  914.     }
  915.     printf("\n");
  916. }
  917.  
  918. void BGBDT_SndBTAC1C2_EncodeBlockStereoJS_Pfcn(
  919.     s16 *ibuf, byte *obuf, int len,
  920.     btac1c_idxstate *ridx, int pcfcn, int psfcn)
  921. {
  922.     int pcsamp[8], pssamp[8];
  923.     int p0, p1, p2, p3, d0, d1, d2, uni1, uni2;
  924.     int lsbt, lsbit, ispf;
  925.     int cv, sv, len2;
  926.     int cpred, spred, cindex, sindex, cstep, sstep, usblk;
  927.     int tpred, tindex, tstep;
  928.     int diff, uni, sni;
  929.     int i, j, k;
  930.  
  931.     if(ridx && (ridx->tag==1))
  932.     {
  933.         cpred=ridx->lpred;
  934.         spred=ridx->rpred;
  935.  
  936.         cindex=(ridx->idx)&127;
  937.         sindex=((ridx->idx)>>8)&127;
  938.     }else if(ridx && (ridx->tag==2))
  939.     {
  940.         p0=ridx->lpred;
  941.         p1=ridx->rpred;
  942.         cpred=(p0+p1)>>1;
  943.         spred=(p0-p1);
  944.  
  945.         p2=(ridx->idx)&127;
  946.         p3=((ridx->idx)>>8)&127;
  947.         cindex=(p2+p3)>>1;
  948.         sindex=cindex;
  949.     }else
  950.     {
  951.         p0=(ibuf[0*2+0]+ibuf[1*2+0])>>1;
  952.         p1=(ibuf[0*2+1]+ibuf[1*2+1])>>1;
  953.  
  954.         p2=(ibuf[(0*4+0)*2+0]+ibuf[(0*4+1)*2+0]+
  955.             ibuf[(0*4+2)*2+0]+ibuf[(0*4+3)*2+0]+
  956.             ibuf[(0*4+4)*2+0]+ibuf[(0*4+5)*2+0]+
  957.             ibuf[(0*4+6)*2+0]+ibuf[(0*4+7)*2+0])>>2;
  958.         p3=(ibuf[(0*4+0)*2+1]+ibuf[(0*4+1)*2+1]+
  959.             ibuf[(0*4+2)*2+1]+ibuf[(0*4+3)*2+1]+
  960.             ibuf[(0*4+4)*2+1]+ibuf[(0*4+5)*2+1]+
  961.             ibuf[(0*4+6)*2+1]+ibuf[(0*4+7)*2+1])>>2;
  962.  
  963.         cpred=(p0+p1)>>1;
  964.  
  965.         cv=(p2+p3)>>1;
  966.         spred=p2-cv;
  967.        
  968.         cindex=0;
  969.         sindex=0;
  970.     }
  971.  
  972.     obuf[0]=cpred&255;
  973.     obuf[1]=(cpred>>8)&255;
  974.     obuf[2]=cindex;
  975.     obuf[3]=pcfcn;
  976.     obuf[4]=spred&255;
  977.     obuf[5]=(spred>>8)&255;
  978.     obuf[6]=0x80|sindex;
  979.     obuf[7]=psfcn;
  980.    
  981.     memset(obuf+8, 0, 2*((len+3)/4));
  982.    
  983.     pcsamp[0]=cpred;    pcsamp[1]=cpred;
  984.     pcsamp[2]=cpred;    pcsamp[3]=cpred;
  985.     pcsamp[4]=cpred;    pcsamp[5]=cpred;
  986.     pcsamp[6]=cpred;    pcsamp[7]=cpred;
  987.  
  988.     pssamp[0]=spred;    pssamp[1]=spred;
  989.     pssamp[2]=spred;    pssamp[3]=spred;
  990.     pssamp[4]=spred;    pssamp[5]=spred;
  991.     pssamp[6]=spred;    pssamp[7]=spred;
  992.  
  993.     ispf=(obuf[3]!=0)|(obuf[7]!=0);
  994.  
  995.     cstep=btac1c_step_table[cindex&127];
  996.     sstep=btac1c_step_table[sindex&127];
  997.  
  998.     len2=len/4;
  999.     for(i=0; i<len2; i++)
  1000.     {
  1001.         usblk=0;
  1002.         for(j=0; j<4; j++)
  1003.         {
  1004.             if(pcfcn)
  1005.             {
  1006.                 cpred=BGBDT_SndBTAC1C2_PredictSample(
  1007.                     pcsamp, i*4+j, pcfcn, ridx);
  1008.             }
  1009.  
  1010.             p0=ibuf[(i*4+j)*2+0];
  1011.             p1=ibuf[(i*4+j)*2+1];
  1012.  
  1013.             cv=(p0+p1)>>1;
  1014.             uni=BGBDT_SndBTAC1C2_EncodeQuantUni(cv, cpred, cstep, ispf?4:2);
  1015.  
  1016.             cindex=cindex+btac1c_index_table[uni];
  1017.             cindex=(cindex<0)?0:((cindex>88)?88:cindex);
  1018.             diff=((2*(uni&7)+1)*cstep)/8;
  1019.             if(uni&8)diff=-diff;
  1020.             cpred=cpred+diff;
  1021.             cstep=btac1c_step_table[cindex];
  1022.            
  1023.             usblk|=(uni>>1)<<(j*3);
  1024.             pcsamp[(i*4+j)&7]=cpred;
  1025.         }
  1026.  
  1027.         if(1)
  1028.         {
  1029.             if(psfcn)
  1030.             {
  1031.                 spred=BGBDT_SndBTAC1C2_PredictSample(
  1032.                     pssamp, i, psfcn, ridx);
  1033.             }
  1034.  
  1035.             p0=(ibuf[(i*4+0)*2+0]+ibuf[(i*4+1)*2+0]+
  1036.                 ibuf[(i*4+2)*2+0]+ibuf[(i*4+3)*2+0])>>2;
  1037.             p1=(ibuf[(i*4+0)*2+1]+ibuf[(i*4+1)*2+1]+
  1038.                 ibuf[(i*4+2)*2+1]+ibuf[(i*4+3)*2+1])>>2;
  1039.  
  1040.             cv=(p0+p1)>>1;
  1041.             sv=p0-cv;
  1042.             uni=BGBDT_SndBTAC1C2_EncodeQuantUni(sv, spred, sstep, 0);
  1043.  
  1044.             sindex=sindex+btac1c_index_table[uni];
  1045.             sindex=(sindex<0)?0:((sindex>88)?88:sindex);
  1046.             diff=((2*(uni&7)+1)*sstep)/8;
  1047.             if(uni&8)diff=-diff;
  1048.             spred=spred+diff;
  1049.             sstep=btac1c_step_table[sindex];
  1050.            
  1051.             usblk|=uni<<12;
  1052.             pssamp[i&7]=spred;
  1053.         }
  1054.  
  1055.         obuf[8+i*2+0]=usblk;
  1056.         obuf[8+i*2+1]=usblk>>8;
  1057.     }
  1058.  
  1059.     if(ridx)
  1060.     {
  1061.         ridx->idx=cindex|(sindex<<8);
  1062.         ridx->lpred=cpred;
  1063.         ridx->rpred=spred;
  1064.         ridx->tag=1;
  1065.     }
  1066. }
  1067.  
  1068. BTEIFGL_API int BGBDT_SndBTAC1C2_StereoBlockSizeFromSamples(int len)
  1069. {
  1070.     return(8+((len+1)/2));
  1071. }
  1072.  
  1073. void BGBDT_SndBTAC1C2_EncodeBlockStereoJS(
  1074.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx)
  1075. {
  1076.     byte tbuf[1024];
  1077.     s16 stbuf[4096];
  1078.     int e0, e1, be, bsz, fcn, utag, bcfcn, bsfcn;
  1079.     btac1c_idxstate idx, iidx;
  1080.  
  1081.     bsz=BGBDT_SndBTAC1C2_StereoBlockSizeFromSamples(len);
  1082.     iidx=*ridx;
  1083.  
  1084.     bcfcn=ridx->bcfcn&15;
  1085.     bsfcn=ridx->bsfcn&15;
  1086.     utag=ridx->tag;
  1087.  
  1088. #if 1
  1089.     idx=iidx;
  1090.     if(ridx->bcfcn&0x40)
  1091.     {
  1092.         switch(utag)
  1093.         {
  1094.         case 1:
  1095.             BGBDT_SndBTAC1C2_EncodeBlockStereoJS_Pfcn(
  1096.                 ibuf, tbuf, len, &idx, bcfcn, bsfcn);
  1097.             break;
  1098.         case 2:
  1099.             BGBDT_SndBTAC1C2_EncodeStereoBlockStereo2Pfcn(
  1100.                 ibuf, tbuf, len, &idx, bcfcn);
  1101.             break;
  1102.         case 3:
  1103.             BGBDT_SndBTAC1C2_EncodeMonoBlockStereoPfcn(
  1104.                 ibuf, tbuf, len, &idx, bcfcn);
  1105.             break;
  1106.         default:
  1107.             break;
  1108.         }
  1109.         memcpy(obuf, tbuf, bsz);
  1110.         *ridx=idx;
  1111.         return;
  1112.     }else
  1113.     {
  1114.         BGBDT_SndBTAC1C2_SelectFilterBlockStereo(
  1115.             ibuf, len, &idx, &bcfcn, &bsfcn);
  1116.     }
  1117.  
  1118.     be=1999999999;
  1119.  
  1120.     idx=iidx;
  1121.     BGBDT_SndBTAC1C2_EncodeBlockStereoJS_Pfcn(
  1122.         ibuf, tbuf, len, &idx, bcfcn, bsfcn);
  1123.     BGBDT_SndBTAC1C2_DecodeJointBlockStereo(tbuf, stbuf, len, &idx);
  1124.     e0=BGBDT_SndBTAC1C1_ErrorBlockStereoSamples(ibuf, stbuf, len);
  1125.     if(e0<be)
  1126.     {
  1127.         memcpy(obuf, tbuf, bsz);
  1128.         *ridx=idx;
  1129.         bcfcn=fcn;
  1130.         be=e0;
  1131.     }
  1132.  
  1133.     idx=iidx;
  1134.     BGBDT_SndBTAC1C2_EncodeStereoBlockStereo2Pfcn(
  1135.         ibuf, tbuf, len, &idx, bcfcn);
  1136.     BGBDT_SndBTAC1C2_DecodeBlockStereo(tbuf, stbuf, len, &idx);
  1137.     e0=BGBDT_SndBTAC1C1_ErrorBlockStereoSamples(ibuf, stbuf, len);
  1138.     if(e0<be)
  1139.     {
  1140.         memcpy(obuf, tbuf, bsz);
  1141.         *ridx=idx;
  1142.         bcfcn=fcn;
  1143.         be=e0;
  1144.     }
  1145.  
  1146.     idx=iidx;
  1147.     BGBDT_SndBTAC1C2_EncodeMonoBlockStereoPfcn(
  1148.         ibuf, tbuf, len, &idx, bcfcn);
  1149.     BGBDT_SndBTAC1C2_DecodeBlockStereo(tbuf, stbuf, len, &idx);
  1150.     e0=BGBDT_SndBTAC1C1_ErrorBlockStereoSamples(ibuf, stbuf, len);
  1151.     if(e0<be)
  1152.     {
  1153.         memcpy(obuf, tbuf, bsz);
  1154.         *ridx=idx;
  1155.         bcfcn=fcn;
  1156.         be=e0;
  1157.     }
  1158. #endif
  1159.  
  1160.     ridx->bcfcn=bcfcn;
  1161.     ridx->bsfcn=bsfcn;
  1162. }
  1163.  
  1164.  
  1165. void BGBDT_SndBTAC1C2_EncodeStereoBlockStereoI(
  1166.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx, int pfcn)
  1167. {
  1168.     int plsamp[8], prsamp[8];
  1169.     int lpred, lindex, lstep, ldiff, luni, lsni;
  1170.     int rpred, rindex, rstep, rdiff, runi, rsni;
  1171.     int i, j, k;
  1172.    
  1173.     if(ridx && (ridx->tag==2))
  1174.     {
  1175.         lpred=ridx->lpred;
  1176.         rpred=ridx->rpred;
  1177.         lindex=(ridx->idx   )&127;
  1178.         rindex=(ridx->idx>>8)&127;
  1179.     }else if(ridx && (ridx->tag==1))
  1180.     {
  1181.         i=ridx->lpred;
  1182.         j=ridx->rpred;
  1183.         lpred=i+(j>>1);
  1184.         rpred=i-(j>>1);
  1185.         lindex=(ridx->idx   )&127;
  1186.         rindex=lindex;
  1187.     }else
  1188.     {
  1189.         lpred=(ibuf[0]+ibuf[2])>>1;
  1190.         rpred=(ibuf[1]+ibuf[3])>>1;
  1191.         lindex=0;
  1192.         rindex=0;
  1193.     }
  1194.  
  1195.     memset(obuf, 0, 8+((len+7)/8)*8);
  1196.    
  1197.     obuf[0]=lpred&255;
  1198.     obuf[1]=(lpred>>8)&255;
  1199.     obuf[2]=lindex;
  1200.     obuf[3]=pfcn;
  1201.  
  1202.     obuf[4]=rpred&255;
  1203.     obuf[5]=(rpred>>8)&255;
  1204.     obuf[6]=rindex;
  1205.     obuf[7]=pfcn>>8;
  1206.    
  1207.     pfcn=pfcn&15;
  1208.    
  1209.     lstep=btac1c_step_table[lindex&127];
  1210.     rstep=btac1c_step_table[rindex&127];
  1211.     plsamp[0]=lpred; plsamp[1]=lpred; plsamp[2]=lpred; plsamp[3]=lpred;
  1212.     plsamp[4]=lpred; plsamp[5]=lpred; plsamp[6]=lpred; plsamp[7]=lpred;
  1213.     prsamp[0]=rpred; prsamp[1]=rpred; prsamp[2]=rpred; prsamp[3]=rpred;
  1214.     prsamp[4]=rpred; prsamp[5]=rpred; prsamp[6]=rpred; prsamp[7]=rpred;
  1215.  
  1216.     for(i=0; i<len; i++)
  1217.     {
  1218.         if(pfcn)
  1219.         {
  1220.             lpred=BGBDT_SndBTAC1C2_PredictSample(plsamp, i, pfcn, ridx);
  1221.             rpred=BGBDT_SndBTAC1C2_PredictSample(prsamp, i, pfcn, ridx);
  1222.         }
  1223.  
  1224.         luni=BGBDT_SndBTAC1C2_EncodeQuantUni(ibuf[i*2+0], lpred, lstep, 0);
  1225.         runi=BGBDT_SndBTAC1C2_EncodeQuantUni(ibuf[i*2+1], rpred, rstep, 0);
  1226.  
  1227.         lindex=lindex+btac1c_index_table[luni];
  1228.         lindex=(lindex<0)?0:((lindex>88)?88:lindex);
  1229.         ldiff=((2*(luni&7)+1)*lstep)/8;
  1230.         if(luni&8)ldiff=-ldiff;
  1231.         lpred=lpred+ldiff;
  1232.         lstep=btac1c_step_table[lindex];
  1233.  
  1234.         rindex=rindex+btac1c_index_table[runi];
  1235.         rindex=(rindex<0)?0:((rindex>88)?88:rindex);
  1236.         rdiff=((2*(runi&7)+1)*rstep)/8;
  1237.         if(runi&8)rdiff=-rdiff;
  1238.         rpred=rpred+rdiff;
  1239.         rstep=btac1c_step_table[rindex];
  1240.  
  1241.         lpred=(lpred<(-32768))?(-32768):((lpred>32767)?32767:lpred);
  1242.         rpred=(rpred<(-32768))?(-32768):((rpred>32767)?32767:rpred);
  1243.  
  1244.         k=((i>>3)*8)+((i&7)>>1);
  1245.         obuf[ 8+k]|=luni<<((i&1)*4);
  1246.         obuf[12+k]|=runi<<((i&1)*4);
  1247.         plsamp[i&7]=lpred;
  1248.         prsamp[i&7]=rpred;
  1249.     }
  1250.    
  1251.     ridx->idx=lindex|(rindex<<8);
  1252.     ridx->lpred=lpred;
  1253.     ridx->rpred=rpred;
  1254.     ridx->tag=2;
  1255. }
  1256.  
  1257. void BGBDT_SndBTAC1C2_EncodeStereoBlockStereo2Pfcn(
  1258.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx, int pfcn)
  1259. {
  1260.     s16 stbuf[4096];
  1261.     int l, e, be, tag, iidx, idx, bsz;
  1262.     int i, j, k;
  1263.  
  1264.     l=len>>1;
  1265.     for(i=0; i<l; i++)
  1266.     {
  1267. //      stbuf[i*2+0]=(ibuf[i*4+0]+ibuf[i*4+2])>>1;
  1268. //      stbuf[i*2+1]=(ibuf[i*4+1]+ibuf[i*4+3])>>1;
  1269.         stbuf[i*2+0]=ibuf[i*4+0];
  1270.         stbuf[i*2+1]=ibuf[i*4+3];
  1271.     }
  1272.    
  1273.     pfcn|=0x0300;
  1274.     BGBDT_SndBTAC1C2_EncodeStereoBlockStereoI(stbuf, obuf, l, ridx, pfcn);
  1275. }
  1276.  
  1277. void BGBDT_SndBTAC1C2_EncodeMonoBlockStereoPfcn(
  1278.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx, int pfcn)
  1279. {
  1280.     s16 stbuf[4096];
  1281.     int l, e, be, tag, bsz;
  1282.     int cl, cr, tl, tr, ofs, intr;
  1283.     int i, j, k;
  1284.  
  1285.     if(1)
  1286.     {
  1287.         intr=0;
  1288.         ofs=0;
  1289.         for(i=0; i<len; i++)
  1290.         {
  1291.             cl=ibuf[i*2+0];     cr=ibuf[i*2+1];
  1292.             stbuf[i]=(cl+cr)>>1;
  1293.             ofs+=(cl-cr);
  1294.         }
  1295.         ofs=ofs/len;
  1296.         ofs=ofs/2;
  1297.     }
  1298.  
  1299. //  k=ofs^(ofs>>31);
  1300. //  if(1)
  1301.     if(0)
  1302. //  if(k<4096)
  1303.     {
  1304.         intr=3;
  1305.  
  1306.         l=len>>1;
  1307.         for(i=0; i<l; i++)
  1308.         {
  1309.             cl=ibuf[i*4+0];
  1310.             cr=ibuf[i*4+3];
  1311.             cl-=ofs>>1;     cr+=ofs>>1;
  1312.             cl=(cl+stbuf[i*2+0])>>1;
  1313.             cr=(cr+stbuf[i*2+1])>>1;
  1314.             stbuf[i*2+0]=cl;
  1315.             stbuf[i*2+1]=cr;
  1316.         }
  1317.     }
  1318.    
  1319.     BGBDT_SndBTAC1C2_EncodeBlockMonoPfcn(stbuf, obuf, len, ridx, pfcn);
  1320.    
  1321.     l=(len+7)/8;
  1322.     for(i=l-1; i>=0; i--)
  1323.         { *(u32 *)(obuf+8+i*4)=*(u32 *)(obuf+4+i*4); }
  1324.     obuf[4]=ofs;
  1325.     obuf[5]=ofs>>8;
  1326.     obuf[6]=89;
  1327.     obuf[7]=intr;
  1328. }
  1329.  
  1330. void BGBDT_SndBTAC1C2_EncodeBlockStereo(
  1331.     s16 *ibuf, byte *obuf, int len, btac1c_idxstate *ridx)
  1332. {
  1333.     BGBDT_SndBTAC1C2_EncodeBlockStereoJS(ibuf, obuf, len, ridx);
  1334. }
  1335.  
  1336. BTEIFGL_API void BGBDT_SndBTAC1C2_EncodeBlockStereoLg2(
  1337.     s16 *ibuf, byte *obuf, int lg2, btac1c_idxstate *ridx)
  1338. {
  1339.     s16 stbuf[2048];
  1340.     int len, len2;
  1341.     int i, j, k;
  1342.    
  1343.     len2=(1<<lg2);
  1344.     len=len2-16;
  1345.    
  1346.     for(i=0; i<len2; i++)
  1347.     {
  1348.         j=i>>(lg2-4);
  1349.         stbuf[(i-j)*2+0]=ibuf[i*2+0];
  1350.         stbuf[(i-j)*2+1]=ibuf[i*2+1];
  1351.     }
  1352.    
  1353.     BGBDT_SndBTAC1C2_EncodeBlockStereo(stbuf, obuf, len, ridx);
  1354. }
  1355.  
  1356. BTEIFGL_API void BGBDT_SndBTAC1C2_EncodeBlockMonoLg2(
  1357.     s16 *ibuf, byte *obuf, int lg2, btac1c_idxstate *ridx)
  1358. {
  1359.     s16 stbuf[2048];
  1360.     int len, len2;
  1361.     int i, j, k;
  1362.    
  1363.     len2=(1<<lg2);
  1364.     len=len2-8;
  1365.    
  1366.     for(i=0; i<len2; i++)
  1367.     {
  1368.         j=i>>(lg2-3);
  1369.         stbuf[i-j]=ibuf[i];
  1370.     }
  1371.    
  1372.     BGBDT_SndBTAC1C2_EncodeBlockMono(stbuf, obuf, len, ridx);
  1373. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!