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

int sblk0_enc(int v)
{
    int e, v0, v1;

    if(v<0)
    {
        v1=sblk0_enc(-v);
        return(0x80|v1);
    }

    if(v>=256)
    {
        e=0;
        v0=v>>3;

        if(v0&(~31))    { v0=v0>>1; e++; }
        if(v0&(~31))    { v0=v0>>1; e++; }
#if 1
        if(v0&(~31))    { v0=v0>>1; e++; }
        if(v0&(~31))    { v0=v0>>1; e++; }
        if(v0&(~31))    { v0=v0>>1; e++; }
        if(v0&(~31))    { v0=v0>>1; e++; }
        if(v0&(~31))    { v0=v0>>1; e++; }
#endif

        v1=(e<<4)|(v0&15);
        if(v0&(~31))    { v1=0x7F; }
    }else
    {
        v1=v>>4;
    }

    return(v1);
}

int sblk0_dec(int v)
{
    int e, v0, v1;

    if(v&0x70)
    {
        e=((v>>4)&7)+3;
        v0=(v&15)|16;
        v1=v0<<e;
    }else
    {
        e=4;
        v0=v&15;
        v1=v0<<e;
    }
    if(v&0x80)
        v1=-v1;
    return(v1);
}

#if 1

s64 stat_avga, stat_avgb, stat_avgd, stat_avge, stat_cnt;

u64 ublk1_enc(s16 *samp_i)
{
    s16 samp[16];
    int avg, hi, lo, me, hicnt, locnt;
    int avga, avgb, avgp, avge, avgf;
    int bits, d, pb;
    s64 e;
    u64 blk;
    int i, j, k;

    for(i=0; i<16; i++)
    {
        d=samp_i[i];
        if(d<-32600)    d=-32600;
        if(d> 32600)    d= 32600;
        samp[i]=d;
    }


    avg=0;
    for(i=0; i<16; i++)
        { avg+=samp[i]; }
    avg/=16;

#if 1
    avga=0; avgb=0;
    for(i=0; i<8; i++)
        { avga+=samp[0+i]; avgb+=samp[8+i]; }
    for(i=0; i<4; i++)
        { avga+=samp[0+i]; avgb+=samp[12+i]; }

    for(i=0; i<2; i++)
        { avga+=samp[0+i]; avgb+=samp[14+i]; }

    for(i=0; i<4; i++)
        { avga-=samp[12+i]; avgb-=samp[0+i]; }
    avga/=10;
    avgb/=10;

#endif

    lo=sblk0_enc(avga);
    hi=sblk0_enc(avgb);
    avga=sblk0_dec(lo);
    avgb=sblk0_dec(hi);

    e=0; avge=0;
    for(i=0; i<16; i++)
    {
        avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
        d=samp[i]-avgp;

        if(d<0)d=-d;
        avge+=d;
    }

    avge=avge/16;
//  avge=sqrt(e/16.0);

    avge*=1.5;
    avgf=avge*0.667;

    me=sblk0_enc(avge);
    avge=sblk0_dec(me);

    bits=0;
    for(i=0; i<16; i++)
    {
        avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
        d=samp[i]-avgp;
        pb=(d>0)?2:0;

        if(d<0)d=-d;
        if(d>avgf)
            pb|=1;

        while(1)
        {
            switch(pb)
            {
                case 0: d=avgp-(0.3333*avge); break;
                case 1: d=avgp-(1.0000*avge); break;
                case 2: d=avgp+(0.3333*avge); break;
                case 3: d=avgp+(1.0000*avge); break;
            }

//          if((d<-32600) || (d>32600))
            if((d<-32690) || (d>32690))
            {
                switch(pb)
                {
                    case 0: pb=2; break;
                    case 1: pb=0; break;
                    case 2: pb=0; break;
                    case 3: pb=2; break;
                }
                continue;
            }

            break;
        }

        bits|=(pb<<(i*2));
    }

    d=avga-avgb;
    if(d<0)d=-d;
    stat_avga+=avga;
    stat_avgb+=avgb;
    stat_avge+=avge;
    stat_avgd+=d;
    stat_cnt++;

    lo=sblk0_enc(avga);
    hi=sblk0_enc(avgb);

    me=sblk0_enc(avge);

    blk=lo|(hi<<8)|(me<<16)|(((u64)bits)<<32);
    return(blk);
}

int ublk1_dec(s16 *samp, u64 blk)
{
    int avga, avgb, avge, avgp, p, phi, plo, bits;
    int i, j, k;

    avga=(blk>> 0)&0xFF;
    avgb=(blk>> 8)&0xFF;
    avge=(blk>>16)&0xFF;

    bits=blk>>32;

    avga=sblk0_dec(avga);
    avgb=sblk0_dec(avgb);
    avge=sblk0_dec(avge);

    for(i=0; i<16; i++)
    {
        j=bits>>(i*2);

        avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;

        if(j&1)
        {
            phi=avgp+avge;
            plo=avgp-avge;
        }else
        {
            phi=avgp+avge*0.333;
            plo=avgp-avge*0.333;
        }

        k=(j&2)?phi:plo;
        samp[i]=k;
    }
    return(0);
}

#endif

#if 1
u64 ublk1_enc_stereo(s16 *samp_i)
{
    s16 samp_l[16];
    s16 samp_r[16];
    s16 samp[16];
    int avg, hi, lo, me, hicnt, locnt;
    int avga, avgb, avgp, avge, avgf;
    int avgl, avgr, avglr, ml;
    int bits, d, dl, dr, pb, n;
    s64 e;
    u64 blk;
    int i, j, k;

    for(i=0; i<16; i++)
    {
        dl=samp_i[i*2+0];
        if(dl<-32600)   dl=-32600;
        if(dl> 32600)   dl= 32600;
        samp_l[i]=dl;

        dr=samp_i[i*2+1];
        if(dr<-32600)   dr=-32600;
        if(dr> 32600)   dr= 32600;
        samp_r[i]=dr;

        samp[i]=(dl+dr)/2;
    }


    avg=0; avgl=0; avgr=0;
    for(i=0; i<16; i++)
    {
        avg+=samp[i];
        avgl+=samp_l[i];
        avgr+=samp_r[i];
    }
    avg/=16;
    avgl/=16;
    avgr/=16;

#if 1
    avga=0; avgb=0;
    for(i=0; i<8; i++)
        { avga+=samp[0+i]; avgb+=samp[8+i]; }
    for(i=0; i<4; i++)
        { avga+=samp[0+i]; avgb+=samp[12+i]; }

    for(i=0; i<2; i++)
        { avga+=samp[0+i]; avgb+=samp[14+i]; }

    for(i=0; i<4; i++)
        { avga-=samp[12+i]; avgb-=samp[0+i]; }
    avga/=10;
    avgb/=10;

#endif

    lo=sblk0_enc(avga);
    hi=sblk0_enc(avgb);
    avga=sblk0_dec(lo);
    avgb=sblk0_dec(hi);

    avglr=(avgl-avgr)/2;
    ml=sblk0_enc(avglr);
    avglr=sblk0_dec(ml);

//  avglr=0;

    e=0; avge=0;
    for(i=0; i<16; i++)
    {
        avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
        d=samp[i]-avgp;

        if(d<0)d=-d;
        avge+=d;
    }

    avge=avge/16;
//  avge=sqrt(e/16.0);

    avge*=1.5;
    avgf=avge*0.667;

    me=sblk0_enc(avge);
    avge=sblk0_dec(me);

    bits=0;
    for(i=0; i<16; i++)
    {
        avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;
        d=samp[i]-avgp;
        pb=(d>0)?2:0;

        if(d<0)d=-d;
        if(d>avgf)
            pb|=1;


        n=8;
        while(n--)
        {
            switch(pb)
            {
                case 0: d=avgp-(0.3333*avge); break;
                case 1: d=avgp-(1.0000*avge); break;
                case 2: d=avgp+(0.3333*avge); break;
                case 3: d=avgp+(1.0000*avge); break;
            }

            dl=d+avglr;
            dr=d-avglr;

//          if((d<-32600) || (d>32600))
            if( (dl<-32690) || (dl>32690) ||
                (dr<-32690) || (dr>32690))
            {
                switch(pb)
                {
                    case 0: pb=2; break;
                    case 1: pb=0; break;
                    case 2: pb=0; break;
                    case 3: pb=2; break;
                }
                continue;
            }

            break;
        }

        if(n<=0)
        {
            if(avglr!=0)
            {
                avglr=0;
                bits=0;
                i=0;
                continue;
            }
        }

        bits|=(pb<<(i*2));
    }

    d=avga-avgb;
    if(d<0)d=-d;
    stat_avga+=avga;
    stat_avgb+=avgb;
    stat_avge+=avge;
    stat_avgd+=d;
    stat_cnt++;

    lo=sblk0_enc(avga);
    hi=sblk0_enc(avgb);

    me=sblk0_enc(avge);
    ml=sblk0_enc(avglr);

    blk=lo|(hi<<8)|(me<<16)|(((u64)ml)<<24)|(((u64)bits)<<32);
    return(blk);
}

int ublk1_dec_stereo(s16 *samp, u64 blk)
{
    int avga, avgb, avge, avgp, avgl, p, phi, plo, bits;
    int i, j, k;

    avga=(blk>> 0)&0xFF;
    avgb=(blk>> 8)&0xFF;
    avge=(blk>>16)&0xFF;
    avgl=(blk>>24)&0xFF;

    bits=blk>>32;

    avga=sblk0_dec(avga);
    avgb=sblk0_dec(avgb);
    avge=sblk0_dec(avge);
    avgl=sblk0_dec(avgl);

    for(i=0; i<16; i++)
    {
        j=bits>>(i*2);

        avgp=(((31-2*i)*avga)+((2*i+1)*avgb))/32;

        if(j&1)
        {
            phi=avgp+avge;
            plo=avgp-avge;
        }else
        {
            phi=avgp+avge*0.333;
            plo=avgp-avge*0.333;
        }

        k=(j&2)?phi:plo;

        samp[i*2+0]=k+avgl;
        samp[i*2+1]=k-avgl;
    }
    return(0);
}
#endif