Esempio n. 1
0
        override public Object unpack(Info vi, csBuffer opb)
        {
            InfoFloor0 info = new InfoFloor0();

            info.order    = opb.read(8);
            info.rate     = opb.read(16);
            info.barkmap  = opb.read(16);
            info.ampbits  = opb.read(6);
            info.ampdB    = opb.read(8);
            info.numbooks = opb.read(4) + 1;

            if ((info.order < 1) ||
                (info.rate < 1) ||
                (info.barkmap < 1) ||
                (info.numbooks < 1))
            {
                //free_info(info);
                return(null);
            }

            for (int j = 0; j < info.numbooks; j++)
            {
                info.books[j] = opb.read(8);
                if (info.books[j] < 0 || info.books[j] >= vi.books)
                {
                    //free_info(info);
                    return(null);
                }
            }
            return(info);
            //  err_out:
            //    free_info(info);
            //    return(NULL);
        }
Esempio n. 2
0
        private object state(object i)
        {
            EchstateFloor0 state = new EchstateFloor0();
            InfoFloor0     info  = (InfoFloor0)i;

            // a safe size if usually too big (dim==1)
            state.codewords = new int[info.order];
            state.curve     = new float[info.barkmap];
            state.frameno   = -1;
            return(state);
        }
Esempio n. 3
0
        override public void pack(Object i, csBuffer opb)
        {
            InfoFloor0 info = (InfoFloor0)i;

            opb.write(info.order, 8);
            opb.write(info.rate, 16);
            opb.write(info.barkmap, 16);
            opb.write(info.ampbits, 6);
            opb.write(info.ampdB, 8);
            opb.write(info.numbooks - 1, 4);
            for (int j = 0; j < info.numbooks; j++)
            {
                opb.write(info.books[j], 8);
            }
        }
Esempio n. 4
0
        override public Object look(DspState vd, InfoMode mi, Object i)
        {
            float scale;

            Info       vi   = vd.vi;
            InfoFloor0 info = (InfoFloor0)i;
            LookFloor0 look = new LookFloor0();

            look.m  = info.order;
            look.n  = vi.blocksizes[mi.blockflag] / 2;
            look.ln = info.barkmap;
            look.vi = info;
            look.lpclook.init(look.ln, look.m);

            // we choose a scaling constant so that:
            //  floor(bark(rate/2-1)*C)=mapped-1
            // floor(bark(rate/2)*C)=mapped
            scale = look.ln / (float)toBARK((float)(info.rate / 2.0));

            // the mapping from a linear scale to a smaller bark scale is
            // straightforward.  We do *not* make sure that the linear mapping
            // does not skip bark-scale bins; the decoder simply skips them and
            // the encoder may do what it wishes in filling them.  They're
            // necessary in some mapping combinations to keep the scale spacing
            // accurate
            look.linearmap = new int[look.n];

            for (int j = 0; j < look.n; j++)
            {
                int val = (int)Math.Floor(toBARK((float)((info.rate / 2.0) / look.n * j))
                                          * scale); // bark numbers represent band edges
                if (val >= look.ln)
                {
                    val = look.ln;                            // guard against the approximation
                }
                look.linearmap[j] = val;
            }
            return(look);
        }
Esempio n. 5
0
        override public int inverse2(Block vb, Object i, Object memo, float[] fout)
        {
            //System.err.println("Floor0.inverse "+i.getClass()+"]");
            LookFloor0 look = (LookFloor0)i;
            InfoFloor0 info = look.vi;

            if (memo != null)
            {
                float[] lsp = (float[])memo;
                float   amp = lsp[look.m];

                Lsp.lsp_to_curve(fout, look.linearmap, look.n, look.ln,
                                 lsp, look.m, amp, info.ampdB);
                return(1);
            }
            //  eop:
            //    memset(out,0,sizeof(float)*look->n);
            for (int j = 0; j < look.n; j++)
            {
                fout[j] = 0.0f;
            }
            return(0);
        }
Esempio n. 6
0
        override public Object inverse1(Block vb, Object i, Object memo)
        {
            //System.err.println("Floor0.inverse "+i.getClass()+"]");
            LookFloor0 look = (LookFloor0)i;
            InfoFloor0 info = look.vi;

            float[] lsp = null;
            if (memo is float[])
            {
                lsp = (float[])memo;
            }

            int ampraw = vb.opb.read(info.ampbits);

            if (ampraw > 0)
            {             // also handles the -1 out of data case
                int   maxval  = (1 << info.ampbits) - 1;
                float amp     = (float)ampraw / maxval * info.ampdB;
                int   booknum = vb.opb.read(ilog(info.numbooks));

                if (booknum != -1 && booknum < info.numbooks)
                {
                    CodeBook b    = vb.vd.fullbooks[info.books[booknum]];
                    float    last = 0.0f;

                    if (lsp == null || lsp.Length < look.m + 1)
                    {
                        lsp = new float[look.m + 1];
                    }
                    else
                    {
                        for (int j = 0; j < lsp.Length; j++)
                        {
                            lsp[j] = 0.0f;
                        }
                    }

                    for (int j = 0; j < look.m; j += b.dim)
                    {
                        if (b.decodev_set(lsp, j, vb.opb, b.dim) == -1)
                        {
                            //goto eop;
                            return(null);
                        }
                    }

                    for (int j = 0; j < look.m;)
                    {
                        for (int k = 0; k < b.dim; k++, j++)
                        {
                            lsp[j] += last;
                        }
                        last = lsp[j - 1];
                    }
                    lsp[look.m] = amp;
                    return(lsp);
                }
            }
            //  eop:
            return(null);
        }
Esempio n. 7
0
        int inverse(Block vb, Object i, float[] fout)
        {
            //System.err.println("Floor0.inverse "+i.getClass()+"]");
            LookFloor0 look   = (LookFloor0)i;
            InfoFloor0 info   = look.vi;
            int        ampraw = vb.opb.read(info.ampbits);

            if (ampraw > 0)
            {             // also handles the -1 out of data case
                int   maxval  = (1 << info.ampbits) - 1;
                float amp     = (float)ampraw / maxval * info.ampdB;
                int   booknum = vb.opb.read(ilog(info.numbooks));

                if (booknum != -1 && booknum < info.numbooks)
                {
                    lock (this)
                    {
                        if (lsp == null || lsp.Length < look.m)
                        {
                            lsp = new float[look.m];
                        }
                        else
                        {
                            for (int j = 0; j < look.m; j++)
                            {
                                lsp[j] = 0.0f;
                            }
                        }

                        CodeBook b    = vb.vd.fullbooks[info.books[booknum]];
                        float    last = 0.0f;

                        //memset(out,0,sizeof(float)*look->m);
                        for (int j = 0; j < look.m; j++)
                        {
                            fout[j] = 0.0f;
                        }

                        for (int j = 0; j < look.m; j += b.dim)
                        {
                            if (b.decodevs(lsp, j, vb.opb, 1, -1) == -1)
                            {
                                //goto eop;
                                // memset(out,0,sizeof(float)*look->n);
                                for (int k = 0; k < look.n; k++)
                                {
                                    fout[k] = 0.0f;
                                }
                                return(0);
                            }
                        }
                        for (int j = 0; j < look.m;)
                        {
                            for (int k = 0; k < b.dim; k++, j++)
                            {
                                lsp[j] += last;
                            }
                            last = lsp[j - 1];
                        }
                        // take the coefficients back to a spectral envelope curve

                        /*
                         * lsp_to_lpc(out,out,look.m);
                         * lpc_to_curve(out,out,amp,look,"",0);
                         * for(int j=0;j<look.n;j++){
                         * out[j]=fromdB(out[j]-info.ampdB);
                         * }
                         */
                        Lsp.lsp_to_curve(fout, look.linearmap, look.n, look.ln,
                                         lsp, look.m, amp, info.ampdB);

                        return(1);
                    }
                }
            }
            //  eop:
            //    memset(out,0,sizeof(float)*look->n);
            return(0);
        }