cr88192

Small Block Audio / UAB2 Enc/Dec 0 (C)

Jun 20th, 2021
720
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. int sblk0_enc(int v)
  2. {
  3.     int e, v0, v1;
  4.  
  5.     if(v<0)
  6.     {
  7.         v1=sblk0_enc(-v);
  8.         return(0x80|v1);
  9.     }
  10.    
  11.     if(v>=256)
  12.     {
  13.         e=0;
  14.         v0=v>>3;
  15.  
  16.         if(v0&(~31))    { v0=v0>>1; e++; }
  17.         if(v0&(~31))    { v0=v0>>1; e++; }
  18. #if 1
  19.         if(v0&(~31))    { v0=v0>>1; e++; }
  20.         if(v0&(~31))    { v0=v0>>1; e++; }
  21.         if(v0&(~31))    { v0=v0>>1; e++; }
  22.         if(v0&(~31))    { v0=v0>>1; e++; }
  23.         if(v0&(~31))    { v0=v0>>1; e++; }
  24. #endif
  25.  
  26.         v1=(e<<4)|(v0&15);
  27.         if(v0&(~31))    { v1=0x7F; }
  28.     }else
  29.     {
  30.         v1=v>>4;
  31.     }
  32.    
  33.     return(v1);
  34. }
  35.  
  36. int sblk0_dec(int v)
  37. {
  38.     int e, v0, v1;
  39.    
  40.     if(v&0x70)
  41.     {
  42.         e=((v>>4)&7)+3;
  43.         v0=(v&15)|16;
  44.         v1=v0<<e;
  45.     }else
  46.     {
  47.         e=4;
  48.         v0=v&15;
  49.         v1=v0<<e;
  50.     }
  51.     if(v&0x80)
  52.         v1=-v1;
  53.     return(v1);
  54. }
  55.  
  56. #if 1
  57.  
  58. s64 stat_avga, stat_avgb, stat_avgd, stat_avge, stat_cnt;
  59.  
  60. u64 ublk1_enc(s16 *samp_i)
  61. {
  62.     s16 samp[16];
  63.     int avg, hi, lo, me, hicnt, locnt;
  64.     int avga, avgb, avgp, avge, avgf;
  65.     int bits, d, pb;
  66.     s64 e;
  67.     u64 blk;
  68.     int i, j, k;
  69.  
  70.     for(i=0; i<16; i++)
  71.     {
  72.         d=samp_i[i];
  73.         if(d<-32600)    d=-32600;
  74.         if(d> 32600)    d= 32600;
  75.         samp[i]=d;
  76.     }
  77.  
  78.    
  79.     avg=0;
  80.     for(i=0; i<16; i++)
  81.         { avg+=samp[i]; }
  82.     avg/=16;
  83.  
  84. #if 1
  85.     avga=0; avgb=0;
  86.     for(i=0; i<8; i++)
  87.         { avga+=samp[0+i]; avgb+=samp[8+i]; }
  88.     for(i=0; i<4; i++)
  89.         { avga+=samp[0+i]; avgb+=samp[12+i]; }
  90.  
  91.     for(i=0; i<2; i++)
  92.         { avga+=samp[0+i]; avgb+=samp[14+i]; }
  93.  
  94.     for(i=0; i<4; i++)
  95.         { avga-=samp[12+i]; avgb-=samp[0+i]; }
  96.     avga/=10;
  97.     avgb/=10;
  98.  
  99. #endif
  100.  
  101.     lo=sblk0_enc(avga);
  102.     hi=sblk0_enc(avgb);
  103.     avga=sblk0_dec(lo);
  104.     avgb=sblk0_dec(hi);
  105.  
  106.     e=0; avge=0;
  107.     for(i=0; i<16; i++)
  108.     {
  109.         avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
  110.         d=samp[i]-avgp;
  111.  
  112.         if(d<0)d=-d;
  113.         avge+=d;
  114.     }
  115.    
  116.     avge=avge/16;
  117. //  avge=sqrt(e/16.0);
  118.  
  119.     avge*=1.5;
  120.     avgf=avge*0.667;
  121.  
  122.     me=sblk0_enc(avge);
  123.     avge=sblk0_dec(me);
  124.  
  125.     bits=0;
  126.     for(i=0; i<16; i++)
  127.     {
  128.         avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
  129.         d=samp[i]-avgp;
  130.         pb=(d>0)?2:0;
  131.  
  132.         if(d<0)d=-d;
  133.         if(d>avgf)
  134.             pb|=1;
  135.            
  136.         while(1)
  137.         {
  138.             switch(pb)
  139.             {
  140.                 case 0: d=avgp-(0.3333*avge); break;
  141.                 case 1: d=avgp-(1.0000*avge); break;
  142.                 case 2: d=avgp+(0.3333*avge); break;
  143.                 case 3: d=avgp+(1.0000*avge); break;
  144.             }
  145.            
  146. //          if((d<-32600) || (d>32600))
  147.             if((d<-32690) || (d>32690))
  148.             {
  149.                 switch(pb)
  150.                 {
  151.                     case 0: pb=2; break;
  152.                     case 1: pb=0; break;
  153.                     case 2: pb=0; break;
  154.                     case 3: pb=2; break;
  155.                 }
  156.                 continue;
  157.             }
  158.            
  159.             break;
  160.         }
  161.  
  162.         bits|=(pb<<(i*2));
  163.     }
  164.  
  165.     d=avga-avgb;
  166.     if(d<0)d=-d;
  167.     stat_avga+=avga;
  168.     stat_avgb+=avgb;
  169.     stat_avge+=avge;
  170.     stat_avgd+=d;
  171.     stat_cnt++;
  172.    
  173.     lo=sblk0_enc(avga);
  174.     hi=sblk0_enc(avgb);
  175.  
  176.     me=sblk0_enc(avge);
  177.    
  178.     blk=lo|(hi<<8)|(me<<16)|(((u64)bits)<<32);
  179.     return(blk);
  180. }
  181.  
  182. int ublk1_dec(s16 *samp, u64 blk)
  183. {
  184.     int avga, avgb, avge, avgp, p, phi, plo, bits;
  185.     int i, j, k;
  186.    
  187.     avga=(blk>> 0)&0xFF;
  188.     avgb=(blk>> 8)&0xFF;
  189.     avge=(blk>>16)&0xFF;
  190.  
  191.     bits=blk>>32;
  192.  
  193.     avga=sblk0_dec(avga);
  194.     avgb=sblk0_dec(avgb);
  195.     avge=sblk0_dec(avge);
  196.  
  197.     for(i=0; i<16; i++)
  198.     {
  199.         j=bits>>(i*2);
  200.    
  201.         avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
  202.        
  203.         if(j&1)
  204.         {
  205.             phi=avgp+avge;
  206.             plo=avgp-avge;
  207.         }else
  208.         {
  209.             phi=avgp+avge*0.333;
  210.             plo=avgp-avge*0.333;
  211.         }
  212.        
  213.         k=(j&2)?phi:plo;
  214.         samp[i]=k;
  215.     }
  216.     return(0);
  217. }
  218.  
  219. #endif
  220.  
  221. #if 1
  222. u64 ublk1_enc_stereo(s16 *samp_i)
  223. {
  224.     s16 samp_l[16];
  225.     s16 samp_r[16];
  226.     s16 samp[16];
  227.     int avg, hi, lo, me, hicnt, locnt;
  228.     int avga, avgb, avgp, avge, avgf;
  229.     int avgl, avgr, avglr, ml;
  230.     int bits, d, dl, dr, pb, n;
  231.     s64 e;
  232.     u64 blk;
  233.     int i, j, k;
  234.  
  235.     for(i=0; i<16; i++)
  236.     {
  237.         dl=samp_i[i*2+0];
  238.         if(dl<-32600)   dl=-32600;
  239.         if(dl> 32600)   dl= 32600;
  240.         samp_l[i]=dl;
  241.  
  242.         dr=samp_i[i*2+1];
  243.         if(dr<-32600)   dr=-32600;
  244.         if(dr> 32600)   dr= 32600;
  245.         samp_r[i]=dr;
  246.        
  247.         samp[i]=(dl+dr)/2;
  248.     }
  249.  
  250.    
  251.     avg=0; avgl=0; avgr=0;
  252.     for(i=0; i<16; i++)
  253.     {
  254.         avg+=samp[i];
  255.         avgl+=samp_l[i];
  256.         avgr+=samp_r[i];
  257.     }
  258.     avg/=16;
  259.     avgl/=16;
  260.     avgr/=16;
  261.  
  262. #if 1
  263.     avga=0; avgb=0;
  264.     for(i=0; i<8; i++)
  265.         { avga+=samp[0+i]; avgb+=samp[8+i]; }
  266.     for(i=0; i<4; i++)
  267.         { avga+=samp[0+i]; avgb+=samp[12+i]; }
  268.  
  269.     for(i=0; i<2; i++)
  270.         { avga+=samp[0+i]; avgb+=samp[14+i]; }
  271.  
  272.     for(i=0; i<4; i++)
  273.         { avga-=samp[12+i]; avgb-=samp[0+i]; }
  274.     avga/=10;
  275.     avgb/=10;
  276.  
  277. #endif
  278.  
  279.     lo=sblk0_enc(avga);
  280.     hi=sblk0_enc(avgb);
  281.     avga=sblk0_dec(lo);
  282.     avgb=sblk0_dec(hi);
  283.  
  284.     avglr=(avgl-avgr)/2;
  285.     ml=sblk0_enc(avglr);
  286.     avglr=sblk0_dec(ml);
  287.    
  288. //  avglr=0;
  289.  
  290.     e=0; avge=0;
  291.     for(i=0; i<16; i++)
  292.     {
  293.         avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
  294.         d=samp[i]-avgp;
  295.  
  296.         if(d<0)d=-d;
  297.         avge+=d;
  298.     }
  299.    
  300.     avge=avge/16;
  301. //  avge=sqrt(e/16.0);
  302.  
  303.     avge*=1.5;
  304.     avgf=avge*0.667;
  305.  
  306.     me=sblk0_enc(avge);
  307.     avge=sblk0_dec(me);
  308.  
  309.     bits=0;
  310.     for(i=0; i<16; i++)
  311.     {
  312.         avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
  313.         d=samp[i]-avgp;
  314.         pb=(d>0)?2:0;
  315.  
  316.         if(d<0)d=-d;
  317.         if(d>avgf)
  318.             pb|=1;
  319.        
  320.        
  321.         n=8;
  322.         while(n--)
  323.         {
  324.             switch(pb)
  325.             {
  326.                 case 0: d=avgp-(0.3333*avge); break;
  327.                 case 1: d=avgp-(1.0000*avge); break;
  328.                 case 2: d=avgp+(0.3333*avge); break;
  329.                 case 3: d=avgp+(1.0000*avge); break;
  330.             }
  331.            
  332.             dl=d+avglr;
  333.             dr=d-avglr;
  334.            
  335. //          if((d<-32600) || (d>32600))
  336.             if( (dl<-32690) || (dl>32690) ||
  337.                 (dr<-32690) || (dr>32690))
  338.             {
  339.                 switch(pb)
  340.                 {
  341.                     case 0: pb=2; break;
  342.                     case 1: pb=0; break;
  343.                     case 2: pb=0; break;
  344.                     case 3: pb=2; break;
  345.                 }
  346.                 continue;
  347.             }
  348.            
  349.             break;
  350.         }
  351.        
  352.         if(n<=0)
  353.         {
  354.             if(avglr!=0)
  355.             {
  356.                 avglr=0;
  357.                 bits=0;
  358.                 i=0;
  359.                 continue;
  360.             }
  361.         }
  362.  
  363.         bits|=(pb<<(i*2));
  364.     }
  365.  
  366.     d=avga-avgb;
  367.     if(d<0)d=-d;
  368.     stat_avga+=avga;
  369.     stat_avgb+=avgb;
  370.     stat_avge+=avge;
  371.     stat_avgd+=d;
  372.     stat_cnt++;
  373.    
  374.     lo=sblk0_enc(avga);
  375.     hi=sblk0_enc(avgb);
  376.  
  377.     me=sblk0_enc(avge);
  378.     ml=sblk0_enc(avglr);
  379.    
  380.     blk=lo|(hi<<8)|(me<<16)|(((u64)ml)<<24)|(((u64)bits)<<32);
  381.     return(blk);
  382. }
  383.  
  384. int ublk1_dec_stereo(s16 *samp, u64 blk)
  385. {
  386.     int avga, avgb, avge, avgp, avgl, p, phi, plo, bits;
  387.     int i, j, k;
  388.    
  389.     avga=(blk>> 0)&0xFF;
  390.     avgb=(blk>> 8)&0xFF;
  391.     avge=(blk>>16)&0xFF;
  392.     avgl=(blk>>24)&0xFF;
  393.  
  394.     bits=blk>>32;
  395.  
  396.     avga=sblk0_dec(avga);
  397.     avgb=sblk0_dec(avgb);
  398.     avge=sblk0_dec(avge);
  399.     avgl=sblk0_dec(avgl);
  400.    
  401.     for(i=0; i<16; i++)
  402.     {
  403.         j=bits>>(i*2);
  404.    
  405.         avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
  406.        
  407.         if(j&1)
  408.         {
  409.             phi=avgp+avge;
  410.             plo=avgp-avge;
  411.         }else
  412.         {
  413.             phi=avgp+avge*0.333;
  414.             plo=avgp-avge*0.333;
  415.         }
  416.  
  417.         k=(j&2)?phi:plo;
  418.  
  419.         samp[i*2+0]=k+avgl;
  420.         samp[i*2+1]=k-avgl;
  421.     }
  422.     return(0);
  423. }
  424. #endif
  425.  
RAW Paste Data