CSJ2K.j2k.image.forwcomptransf.ForwCompTransf.forwRCT C# (CSharp) Method

        private DataBlk forwRCT(DataBlk blk, int c)
        {
            int k, k0, k1, k2, mink, i;
            int w = blk.w; //width of output block
            int h = blk.h; //height of ouput block
            int[] outdata; //array of output data

            //If asking for Yr, Ur or Vr do transform
            if (c >= 0 && c <= 2)
            {
                // Check that request data type is int
                if (blk.DataType != DataBlk.TYPE_INT)
                {
                    if (outBlk == null || outBlk.DataType != DataBlk.TYPE_INT)
                    {
                        outBlk = new DataBlkInt();
                    }
                    outBlk.w = w;
                    outBlk.h = h;
                    outBlk.ulx = blk.ulx;
                    outBlk.uly = blk.uly;
                    blk = outBlk;
                }

                //Reference to output block data array
                outdata = (int[]) blk.Data;

                //Create data array of blk if necessary
                if (outdata == null || outdata.Length < h * w)
                {
                    outdata = new int[h * w];
                    blk.Data = outdata;
                }

                // Block buffers for input RGB data
                int[] data0, data1, bdata; // input data arrays

                if (block0 == null)
                    block0 = new DataBlkInt();
                if (block1 == null)
                    block1 = new DataBlkInt();
                if (block2 == null)
                    block2 = new DataBlkInt();
                block0.w = block1.w = block2.w = blk.w;
                block0.h = block1.h = block2.h = blk.h;
                block0.ulx = block1.ulx = block2.ulx = blk.ulx;
                block0.uly = block1.uly = block2.uly = blk.uly;

                //Fill in buffer blocks (to be read only)
                // Returned blocks may have different size and position
                block0 = (DataBlkInt) src.getInternCompData(block0, 0);
                data0 = (int[]) block0.Data;
                block1 = (DataBlkInt) src.getInternCompData(block1, 1);
                data1 = (int[]) block1.Data;
                block2 = (DataBlkInt) src.getInternCompData(block2, 2);
                bdata = (int[]) block2.Data;

                // Set the progressiveness of the output data
                blk.progressive = block0.progressive || block1.progressive || block2.progressive;
                blk.offset = 0;
                blk.scanw = w;

                //Perform conversion

                // Initialize general indexes
                k = w * h - 1;
                k0 = block0.offset + (h - 1) * block0.scanw + w - 1;
                k1 = block1.offset + (h - 1) * block1.scanw + w - 1;
                k2 = block2.offset + (h - 1) * block2.scanw + w - 1;

                switch (c)
                {

                    case 0:  //RGB to Yr conversion
                        for (i = h - 1; i >= 0; i--)
                        {
                            for (mink = k - w; k > mink; k--, k0--, k1--, k2--)
                            {
                                // Use int arithmetic with 12 fractional bits
                                // and rounding
                                outdata[k] = (data0[k] + 2 * data1[k] + bdata[k]) >> 2; // Same as / 4
                            }
                            // Jump to beggining of previous line in input
                            k0 -= (block0.scanw - w);
                            k1 -= (block1.scanw - w);
                            k2 -= (block2.scanw - w);
                        }
                        break;

                    case 1:  //RGB to Ur conversion
                        for (i = h - 1; i >= 0; i--)
                        {
                            for (mink = k - w; k > mink; k--, k1--, k2--)
                            {
                                // Use int arithmetic with 12 fractional bits
                                // and rounding
                                outdata[k] = bdata[k2] - data1[k1];
                            }
                            // Jump to beggining of previous line in input
                            k1 -= (block1.scanw - w);
                            k2 -= (block2.scanw - w);
                        }
                        break;

                    case 2:  //RGB to Vr conversion
                        for (i = h - 1; i >= 0; i--)
                        {
                            for (mink = k - w; k > mink; k--, k0--, k1--)
                            {
                                // Use int arithmetic with 12 fractional bits
                                // and rounding
                                outdata[k] = data0[k0] - data1[k1];
                            }
                            // Jump to beggining of previous line in input
                            k0 -= (block0.scanw - w);
                            k1 -= (block1.scanw - w);
                        }
                        break;
                    }
            }
            else if (c >= 3)
            {
                // Requesting a component which is not Y, Ur or Vr =>
                // just pass the data
                return src.getInternCompData(blk, c);
            }
            else
            {
                // Requesting a non valid component index
                throw new System.ArgumentException();
            }
            return blk;
        }