csvorbis.Floor1.inverse1 C# (CSharp) Method

        public override Object inverse1(Block vb, Object ii, Object memo)
        {
            LookFloor1 look=(LookFloor1)ii;
            InfoFloor1 info=look.vi;
            CodeBook[] books=vb.vd.fullbooks;

            /* unpack wrapped/predicted values from stream */
            if(vb.opb.read(1)==1)
            {
                int[] fit_value=null;
                if(memo is int[])
                {
                    fit_value=(int[])memo;
                }
                if(fit_value==null || fit_value.Length<look.posts)
                {
                    fit_value=new int[look.posts];
                }
                else
                {
                    for(int i=0; i<fit_value.Length; i++) fit_value[i]=0;
                }

                fit_value[0]=vb.opb.read(ilog(look.quant_q-1));
                fit_value[1]=vb.opb.read(ilog(look.quant_q-1));

                /* partition by partition */
                for(int i=0,j=2;i<info.partitions;i++)
                {
                    int clss=info.partitionclass[i];
                    int cdim=info.class_dim[clss];
                    int csubbits=info.class_subs[clss];
                    int csub=1<<csubbits;
                    int cval=0;

                    /* decode the partition's first stage cascade value */
                    if(csubbits!=0)
                    {
                        cval=books[info.class_book[clss]].decode(vb.opb);

                        if(cval==-1)
                        {
                            //goto eop;
                            return(null);
                        }
                    }

                    for(int k=0;k<cdim;k++)
                    {
                        int book=info.class_subbook[clss][cval&(csub-1)];
                        cval = (int)((uint)cval >> csubbits);
                        if(book>=0)
                        {
                            if((fit_value[j+k]=books[book].decode(vb.opb))==-1)
                            {
                                return(null);
                            }
                        }
                        else
                        {
                            fit_value[j+k]=0;
                        }
                    }
                    j+=cdim;
                }

                /* unwrap positive values and reconsitute via linear interpolation */
                for(int i=2;i<look.posts;i++)
                {
                    int predicted=render_point(info.postlist[look.loneighbor[i-2]],
                        info.postlist[look.hineighbor[i-2]],
                        fit_value[look.loneighbor[i-2]],
                        fit_value[look.hineighbor[i-2]],
                        info.postlist[i]);
                    int hiroom=look.quant_q-predicted;
                    int loroom=predicted;
                    int room=(hiroom<loroom?hiroom:loroom)<<1;
                    int val=fit_value[i];

                    if(val!=0)
                    {
                        if(val>=room)
                        {
                            if(hiroom>loroom)
                            {
                                val = val-loroom;
                            }
                            else
                            {
                                val = -1-(val-hiroom);
                            }
                        }
                        else
                        {
                            if((val&1)!=0)
                            {
                                val= (int)(-((uint)(val+1) >> 1));
                            }
                            else
                            {
                                val>>=1;
                            }
                        }

                        fit_value[i]=val+predicted;
                        fit_value[look.loneighbor[i-2]]&=0x7fff;
                        fit_value[look.hineighbor[i-2]]&=0x7fff;
                    }
                    else
                    {
                        fit_value[i]=predicted|0x8000;
                    }
                }
                return(fit_value);
            }

            //  eop:
            //    return(NULL);
            return(null);
        }