/// Copyright (c) 2008 Jeffrey Powers for Fluxcapacity Open Source.

/// Under the MIT License, details: License.txt.



// Partially derives from a Java encoder, JpegEncoder.java by James R Weeks.

// Implements Baseline JPEG Encoding http://www.opennet.ru/docs/formats/jpeg.txt



using System;



using FluxJpeg.Core.IO;

using System.IO;

using System.Collections.Generic;



namespace FluxJpeg.Core

{

    internal class HuffmanTable

    {

        public static int HUFFMAN_MAX_TABLES = 4;



        private short[] huffcode = new short[256];

        private short[] huffsize = new short[256];

        private short[] valptr = new short[16];

        private short[] mincode = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,-1,-1};

        private short[] maxcode = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};



        private short[] huffval;

        private short[] bits;



        int bufferPutBits, bufferPutBuffer;

        internal int ImageHeight;

        internal int ImageWidth;

        internal int[,] DC_matrix0;

        internal int[,] AC_matrix0;

        internal int[,] DC_matrix1;

        internal int[,] AC_matrix1;

        internal int[][,] DC_matrix;

        internal int[][,] AC_matrix;

        internal int NumOfDCTables;

        internal int NumOfACTables;



        public List<short[]> bitsList;

        public List<short[]> val;





        public static byte JPEG_DC_TABLE = 0;

        public static byte JPEG_AC_TABLE = 1;



        private short lastk = 0;



        internal HuffmanTable(JpegHuffmanTable table)

        {

            if (table != null)

            {

                huffval = table.Values;

                bits = table.Lengths;



                GenerateSizeTable();

                GenerateCodeTable();

                GenerateDecoderTables();

            }

            else

            {

                // Encode initialization



                bitsList = new List<short[]>();

                bitsList.Add(JpegHuffmanTable.StdDCLuminance.Lengths);

                bitsList.Add(JpegHuffmanTable.StdACLuminance.Lengths);

                bitsList.Add(JpegHuffmanTable.StdDCChrominance.Lengths);

                bitsList.Add(JpegHuffmanTable.StdACChrominance.Lengths);



                val = new List<short[]>();

                val.Add(JpegHuffmanTable.StdDCLuminance.Values);

                val.Add(JpegHuffmanTable.StdACLuminance.Values);

                val.Add(JpegHuffmanTable.StdDCChrominance.Values);

                val.Add(JpegHuffmanTable.StdACChrominance.Values);



                initHuf();

            }

        }



        /// <summary>See Figure C.1</summary>

        private void GenerateSizeTable()

        {

            short index = 0;

            for (short i = 0; i < bits.Length; i++)

            {

                for (short j = 0; j < bits[i]; j++)

                {

                    huffsize[index] = (short)(i + 1);

                    index++;

                }

            }

            lastk = index;

        }



        /// <summary>See Figure C.2</summary>

        private void GenerateCodeTable()

        {

            short k = 0;

            short si = huffsize[0];

            short code = 0;

            for (short i = 0; i < huffsize.Length; i++)

            {

                while (huffsize[k] == si)

                {

                    huffcode[k] = code;

                    code++;

                    k++;

                }

                code <<= 1;

                si++;

            }

        }



        /// <summary>See figure F.15</summary>

        private void GenerateDecoderTables()

        {

            short bitcount = 0;

            for (int i = 0; i < 16; i++)

            {

                if (bits[i] != 0)

                    valptr[i] = bitcount;

                for (int j = 0; j < bits[i]; j++)

                {

                    if (huffcode[j + bitcount] < mincode[i] || mincode[i] == -1)

                        mincode[i] = huffcode[j + bitcount];



                    if (huffcode[j + bitcount] > maxcode[i])

                        maxcode[i] = huffcode[j + bitcount];

                }

                if (mincode[i] != -1)

                    valptr[i] = (short)(valptr[i] - mincode[i]);

                bitcount += bits[i];

            }

        }



        /// <summary>Figure F.12</summary>

        public static int Extend(int diff, int t)

        {

            // here we use bitshift to implement 2^ ... 

            // NOTE: Math.Pow returns 0 for negative powers, which occassionally happen here!



            int Vt = 1 << t - 1;

            // WAS: int Vt = (int)Math.Pow(2, (t - 1));



            if (diff < Vt)

            {

                Vt = (-1 << t) + 1;

                diff = diff + Vt;

            }

            return diff;

        }



        /// <summary>Figure F.16 - Reads the huffman code bit-by-bit.</summary>

        public int Decode(JPEGBinaryReader JPEGStream)

        {

            int i = 0;

            short code = (short)JPEGStream.ReadBits(1);

            while (code > maxcode[i])

            {

                i++;

                code <<= 1;

                code |= (short)JPEGStream.ReadBits(1);

            }

            int val = huffval[code + (valptr[i])];

            if (val < 0)

                val = 256 + val;

            return val;

        }



                /// <summary>

        /// HuffmanBlockEncoder run length encodes and Huffman encodes the quantized data.

        /// </summary>

        internal void HuffmanBlockEncoder(Stream outStream, int[] zigzag, int prec, int DCcode, int ACcode)

        {

            int temp, temp2, nbits, k, r, i;



            NumOfDCTables = 2;

            NumOfACTables = 2;



            // The DC portion



            temp = temp2 = zigzag[0] - prec;

            if (temp < 0)

            {

                temp = -temp;

                temp2--;

            }

            nbits = 0;

            while (temp != 0)

            {

                nbits++;

                temp >>= 1;

            }

            //		  if (nbits > 11) nbits = 11;

            bufferIt(outStream, 

                DC_matrix[DCcode][nbits, 0],

                DC_matrix[DCcode][nbits, 1]);



            // The arguments in bufferIt are code and size.

            if (nbits != 0)

            {

                bufferIt(outStream, temp2, nbits);

            }



            // The AC portion



            r = 0;



            for (k = 1; k < 64; k++)

            {

                if ((temp = zigzag[ ZigZag.ZigZagMap[k] ]) == 0)

                {

                    r++;

                }

                else

                {

                    while (r > 15)

                    {

                        bufferIt(outStream, 

                            AC_matrix[ACcode][0xF0, 0], 

                            AC_matrix[ACcode][0xF0, 1]);



                        r -= 16;

                    }

                    temp2 = temp;

                    if (temp < 0)

                    {

                        temp = -temp;

                        temp2--;

                    }

                    nbits = 1;

                    while ((temp >>= 1) != 0)

                    {

                        nbits++;

                    }

                    i = (r << 4) + nbits;

                    bufferIt(outStream, 

                        AC_matrix[ACcode][i, 0], 

                        AC_matrix[ACcode][i, 1]);

                    bufferIt(outStream, temp2, nbits);



                    r = 0;

                }

            }



            if (r > 0)

            {

                bufferIt(outStream, 

                    AC_matrix[ACcode][0, 0], 

                    AC_matrix[ACcode][0, 1]);

            }

        }



        /// <summary>

        /// Uses an integer long (32 bits) buffer to store the Huffman encoded bits

        /// and sends them to outStream by the byte.

        /// </summary>

        void bufferIt(Stream outStream, int code, int size)

        {

            int PutBuffer = code;

            int PutBits = bufferPutBits;



            PutBuffer &= (1 << size) - 1;

            PutBits += size;

            PutBuffer <<= 24 - PutBits;

            PutBuffer |= bufferPutBuffer;



            while (PutBits >= 8)

            {

                int c = ((PutBuffer >> 16) & 0xFF);

                outStream.WriteByte((byte)c);

                

                // FF must be escaped

                if (c == 0xFF) outStream.WriteByte(0);

                

                PutBuffer <<= 8;

                PutBits -= 8;

            }

            bufferPutBuffer = PutBuffer;

            bufferPutBits = PutBits;



        }



        public void FlushBuffer(Stream outStream)

        {

            int PutBuffer = bufferPutBuffer;

            int PutBits = bufferPutBits;

            while (PutBits >= 8)

            {

                int c = ((PutBuffer >> 16) & 0xFF);

                outStream.WriteByte((byte)c);



                // FF must be escaped

                if (c == 0xFF) outStream.WriteByte(0);



                PutBuffer <<= 8;

                PutBits -= 8;

            }

            if (PutBits > 0)

            {

                int c = ((PutBuffer >> 16) & 0xFF);

                outStream.WriteByte((byte)c);

            }

        }





        /// <summary>

        /// Initialisation of the Huffman codes for Luminance and Chrominance.

        /// This code results in the same tables created in the IJG Jpeg-6a

        /// library.

        /// </summary>

        public void initHuf()

        {

            DC_matrix0 = new int[12, 2];

            DC_matrix1 = new int[12, 2];

            AC_matrix0 = new int[255, 2];

            AC_matrix1 = new int[255, 2];

            DC_matrix = new int[2][,];

            AC_matrix = new int[2][,];

            int p, l, i, lastp, si, code;

            int[] huffsize = new int[257];

            int[] huffcode = new int[257];



            short[] bitsDCchrominance = JpegHuffmanTable.StdDCChrominance.Lengths;

            short[] bitsACchrominance = JpegHuffmanTable.StdACChrominance.Lengths;

            short[] bitsDCluminance = JpegHuffmanTable.StdDCLuminance.Lengths;

            short[] bitsACluminance = JpegHuffmanTable.StdACLuminance.Lengths;





            short[] valDCchrominance = JpegHuffmanTable.StdDCChrominance.Values;

            short[] valACchrominance = JpegHuffmanTable.StdACChrominance.Values;

            short[] valDCluminance = JpegHuffmanTable.StdDCLuminance.Values;

            short[] valACluminance = JpegHuffmanTable.StdACLuminance.Values;





            /*

            * init of the DC values for the chrominance

            * [,0] is the code   [,1] is the number of bit

            */



            p = 0;

            for (l = 0; l < 16; l++)

            {

                for (i = 1; i <= bitsDCchrominance[l]; i++)

                {

                    huffsize[p++] = l+1;

                }

            }



            huffsize[p] = 0;

            lastp = p;



            code = 0;

            si = huffsize[0];

            p = 0;

            while (huffsize[p] != 0)

            {

                while (huffsize[p] == si)

                {

                    huffcode[p++] = code;

                    code++;

                }

                code <<= 1;

                si++;

            }



            for (p = 0; p < lastp; p++)

            {

                DC_matrix1[valDCchrominance[p], 0] = huffcode[p];

                DC_matrix1[valDCchrominance[p], 1] = huffsize[p];

            }



            /*

            * Init of the AC hufmann code for the chrominance

            * matrix [,,0] is the code & matrix[,,1] is the number of bit needed

            */



            p = 0;

            for (l = 0; l < 16; l++)

            {

                for (i = 1; i <= bitsACchrominance[l]; i++)

                {

                    huffsize[p++] = l+1;

                }

            }

            huffsize[p] = 0;

            lastp = p;



            code = 0;

            si = huffsize[0];

            p = 0;

            while (huffsize[p] != 0)

            {

                while (huffsize[p] == si)

                {

                    huffcode[p++] = code;

                    code++;

                }

                code <<= 1;

                si++;

            }



            for (p = 0; p < lastp; p++)

            {

                AC_matrix1[valACchrominance[p], 0] = huffcode[p];

                AC_matrix1[valACchrominance[p], 1] = huffsize[p];

            }



            /*

            * init of the DC values for the luminance

            * [,0] is the code   [,1] is the number of bit

            */

            p = 0;

            for (l = 0; l < 16; l++)

            {

                for (i = 1; i <= bitsDCluminance[l]; i++)

                {

                    huffsize[p++] = l+1;

                }

            }

            huffsize[p] = 0;

            lastp = p;



            code = 0;

            si = huffsize[0];

            p = 0;

            while (huffsize[p] != 0)

            {

                while (huffsize[p] == si)

                {

                    huffcode[p++] = code;

                    code++;

                }

                code <<= 1;

                si++;

            }



            for (p = 0; p < lastp; p++)

            {

                DC_matrix0[valDCluminance[p], 0] = huffcode[p];

                DC_matrix0[valDCluminance[p], 1] = huffsize[p];

            }



            /*

            * Init of the AC hufmann code for luminance

            * matrix [,,0] is the code & matrix[,,1] is the number of bit

            */



            p = 0;

            for (l = 0; l < 16; l++)

            {

                for (i = 1; i <= bitsACluminance[l]; i++)

                {

                    huffsize[p++] = l+1;

                }

            }

            huffsize[p] = 0;

            lastp = p;



            code = 0;

            si = huffsize[0];

            p = 0;

            while (huffsize[p] != 0)

            {

                while (huffsize[p] == si)

                {

                    huffcode[p++] = code;

                    code++;

                }

                code <<= 1;

                si++;

            }

            for (int q = 0; q < lastp; q++)

            {

                AC_matrix0[valACluminance[q], 0] = huffcode[q];

                AC_matrix0[valACluminance[q], 1] = huffsize[q];

            }



            DC_matrix[0] = DC_matrix0;

            DC_matrix[1] = DC_matrix1;

            AC_matrix[0] = AC_matrix0;

            AC_matrix[1] = AC_matrix1;

        }





    }

}