LNXSDK/leenkx/Sources/iron/format/jpg/Writer.hx

package iron.format.jpg;

class Writer {
    var ZigZag: Array<Int>;

    // Static table initialization
    function initZigZag() {
        ZigZag = [
             0, 1, 5, 6,14,15,27,28,
             2, 4, 7,13,16,26,29,42,
             3, 8,12,17,25,30,41,43,
             9,11,18,24,31,40,44,53,
            10,19,23,32,39,45,52,54,
            20,22,33,38,46,51,55,60,
            21,34,37,47,50,56,59,61,
            35,36,48,49,57,58,62,63
        ];
    }

    var YTable: Array<Int>;
    var UVTable: Array<Int>;
    var fdtbl_Y: Array<Float>;
    var fdtbl_UV: Array<Float>;

    function initQuantTables(sf: Int) {
        var YQT: Array<Int> = [
            16, 11, 10, 16, 24, 40, 51, 61,
            12, 12, 14, 19, 26, 58, 60, 55,
            14, 13, 16, 24, 40, 57, 69, 56,
            14, 17, 22, 29, 51, 87, 80, 62,
            18, 22, 37, 56, 68,109,103, 77,
            24, 35, 55, 64, 81,104,113, 92,
            49, 64, 78, 87,103,121,120,101,
            72, 92, 95, 98,112,100,103, 99
        ];
        for (i in 0...64) {
            var t: Int = Math.floor( (YQT[i] * sf + 50) / 100 );
            if( t < 1 ) t = 1;
            else if( t > 255 ) t = 255;
            YTable[ ZigZag[i] ] = t;
        }
        var UVQT: Array<Int> = [
            17, 18, 24, 47, 99, 99, 99, 99,
            18, 21, 26, 66, 99, 99, 99, 99,
            24, 26, 56, 99, 99, 99, 99, 99,
            47, 66, 99, 99, 99, 99, 99, 99,
            99, 99, 99, 99, 99, 99, 99, 99,
            99, 99, 99, 99, 99, 99, 99, 99,
            99, 99, 99, 99, 99, 99, 99, 99,
            99, 99, 99, 99, 99, 99, 99, 99
        ];
        for( j in 0...64 ) {
            var u: Int = Math.floor( (UVQT[j] * sf + 50) / 100 );
            if( u < 1 ) u = 1;
            else if( u > 255 ) u = 255;
            UVTable[ ZigZag[j] ] = u;
        }
        var aasf: Array<Float> = [
            1.0, 1.387039845, 1.306562965, 1.175875602,
            1.0, 0.785694958, 0.541196100, 0.275899379
        ];
        var k = 0;
        for( row in 0...8 ) {
            for( col in 0...8 ) {
                fdtbl_Y[k]  = (1.0 / (YTable [ZigZag[k]] * aasf[row] * aasf[col] * 8.0));
                fdtbl_UV[k] = (1.0 / (UVTable[ZigZag[k]] * aasf[row] * aasf[col] * 8.0));
                k++;
            }
        }
    }

    var std_dc_luminance_nrcodes: Array<Int>;
    var std_dc_luminance_values: haxe.io.Bytes;
    var std_ac_luminance_nrcodes: Array<Int>;
    var std_ac_luminance_values: haxe.io.Bytes;

    function initLuminance() {
        std_dc_luminance_nrcodes = [0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0];
        std_dc_luminance_values = strIntsToBytes( '0,1,2,3,4,5,6,7,8,9,10,11' );
        std_ac_luminance_nrcodes = [0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d];
        std_ac_luminance_values = strIntsToBytes(
            '0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,' +
            '0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,' +
            '0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,' +
            '0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,' +
            '0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,' +
            '0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,' +
            '0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,' +
            '0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,' +
            '0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,' +
            '0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,' +
            '0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,' +
            '0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,' +
            '0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,' +
            '0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,' +
            '0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,' +
            '0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,' +
            '0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,' +
            '0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,' +
            '0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,' +
            '0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,' +
            '0xf9,0xfa'
        );
    }

    function strIntsToBytes( s: String ) {
        var len = s.length;
        var b = new haxe.io.BytesBuffer();
        var val = 0;
        var i = 0;
        for( j in 0...len ) {
            if( s.charAt( j ) == ',' ) {
                val = Std.parseInt( s.substr(i, j - i) );
                b.addByte( val );
                i = j + 1;
            }
        }
        if( i < len ) {
            val = Std.parseInt( s.substr(i) );
            b.addByte( val );
        }
        return b.getBytes();
    }

    var std_dc_chrominance_nrcodes: Array<Int>;
    var std_dc_chrominance_values: haxe.io.Bytes;
    var std_ac_chrominance_nrcodes: Array<Int>;
    var std_ac_chrominance_values: haxe.io.Bytes;

    function initChrominance() {
        std_dc_chrominance_nrcodes = [0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0];
        std_dc_chrominance_values = strIntsToBytes( '0,1,2,3,4,5,6,7,8,9,10,11' );
        std_ac_chrominance_nrcodes = [0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77];
        std_ac_chrominance_values = strIntsToBytes(
            '0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,' +
            '0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,' +
            '0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,' +
            '0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,' +
            '0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,' +
            '0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,' +
            '0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,' +
            '0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,' +
            '0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,' +
            '0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,' +
            '0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,' +
            '0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,' +
            '0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,' +
            '0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,' +
            '0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,' +
            '0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,' +
            '0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,' +
            '0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,' +
            '0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,' +
            '0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,' +
            '0xf9,0xfa'
        );
    }

    var YDC_HT: Map<Int,BitString>;
    var UVDC_HT: Map<Int,BitString>;
    var YAC_HT: Map<Int,BitString>;
    var UVAC_HT: Map<Int,BitString>;

    // Función para crear la tabla Huffman (Helper)
    function computeHuffmanTbl(nrcodes: Array<Int>, std_table: haxe.io.Bytes): Map<Int,BitString> {
        var codevalue = 0;
        var pos_in_table = 0;
        var HT: Map<Int,BitString> = new Map();
        for( k in 1...17 ) {
            var end = nrcodes[k];
            for( j in 0...end ) {
                var idx: Int = std_table.get( pos_in_table );
                HT.set( idx, new BitString( k, codevalue ) );
                pos_in_table++;
                codevalue++;
            }
            codevalue *= 2;
        }
        return HT;
    }

    function initHuffmanTbl() {
        YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes, std_dc_luminance_values);
        UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes, std_dc_chrominance_values);
        
        YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes, std_ac_luminance_values);
        UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes, std_ac_chrominance_values);

        // CORRECCIÓN DE TABLAS: Asegurar la existencia de EOB (0x00) y ZRL (0xF0)
        // Esto es necesario para evitar fallos si el 'computeHuffmanTbl' no incluye estos valores por algún motivo.
        if (YAC_HT.get(0x00) == null) YAC_HT.set(0x00, new BitString(4, 0x00));
        if (UVAC_HT.get(0x00) == null) UVAC_HT.set(0x00, new BitString(4, 0x00));
        if (YAC_HT.get(0xF0) == null) YAC_HT.set(0xF0, new BitString(11, 0x1E));
        if (UVAC_HT.get(0xF0) == null) UVAC_HT.set(0xF0, new BitString(11, 0x1E));
    }

    var bitcode: Map<Int,BitString>;
    var category: Map<Int,Int>;

    function initCategoryNumber() {
        var nrlower = 1;
        var nrupper = 2;
        var idx: Int;
        for (cat in 1...16) {
            //Positive numbers
            for( nr in nrlower...nrupper ) {
                idx = 32767 + nr;
                category.set( idx, cat );
                bitcode.set( idx, new BitString( cat, nr ) );
            }
            //Negative numbers
            var nrneg: Int = -(nrupper - 1);
            while( nrneg <= -nrlower ) {
                idx = 32767 + nrneg;
                category.set( idx, cat );
                bitcode.set( idx, new BitString( cat, nrupper - 1 + nrneg ) );
                nrneg++;
            }
            nrlower <<= 1;
            nrupper <<= 1;
        }
    }

    // IO functions
    var byteout: haxe.io.Output;
    var bytenew: Int;
    var bytepos: Int;

    function writeBits(bs: BitString) {
        // Se confía en que bs no es nulo gracias al clamping y las correcciones de tablas.
        var value: Int = bs.val;
        var posval: Int = bs.len - 1;
        while( posval >= 0 ) {
            if( (value & (1 << posval)) != 0 ) {
                bytenew |= (1 << bytepos);
            }
            posval--;
            bytepos--;
            if( bytepos < 0 ) {
                if( bytenew == 0xFF ) {
                    b(0xFF);
                    b(0);
                }
                else {
                    b(bytenew);
                }
                bytepos = 7;
                bytenew = 0;
            }
        }
    }

    function writeWord( val: Int ) {
        b( (val >> 8) & 0xFF );
        b( val & 0xFF );
    }

    // DCT & quantization core

    function fDCTQuant(data: Array<Float>, fdtbl: Array<Float>): Array<Float> {
        /* Pass 1:  process rows. */
        var dataOff = 0;
        for (i in 0...8) {
            var tmp0: Float = data[dataOff + 0] + data[dataOff + 7];
            var tmp7: Float = data[dataOff + 0] - data[dataOff + 7];
            var tmp1: Float = data[dataOff + 1] + data[dataOff + 6];
            var tmp6: Float = data[dataOff + 1] - data[dataOff + 6];
            var tmp2: Float = data[dataOff + 2] + data[dataOff + 5];
            var tmp5: Float = data[dataOff + 2] - data[dataOff + 5];
            var tmp3: Float = data[dataOff + 3] + data[dataOff + 4];
            var tmp4: Float = data[dataOff + 3] - data[dataOff + 4];

            /* Even part */
            var tmp10: Float = tmp0 + tmp3;  /* phase 2 */
            var tmp13: Float = tmp0 - tmp3;
            var tmp11: Float = tmp1 + tmp2;
            var tmp12: Float = tmp1 - tmp2;

            data[dataOff + 0] = tmp10 + tmp11; /* phase 3 */
            data[dataOff + 4] = tmp10 - tmp11;

            var z1: Float = (tmp12 + tmp13) * 0.707106781; /* c4 */
            data[dataOff + 2] = tmp13 + z1; /* phase 5 */
            data[dataOff + 6] = tmp13 - z1;

            /* Odd part */
            tmp10 = tmp4 + tmp5; /* phase 2 */
            tmp11 = tmp5 + tmp6;
            tmp12 = tmp6 + tmp7;

            /* The rotator is modified from fig 4-8 to avoid extra negations. */
            var z5: Float = (tmp10 - tmp12) * 0.382683433; /* c6 */
            var z2: Float = 0.541196100 * tmp10 + z5; /* c2-c6 */
            var z4: Float = 1.306562965 * tmp12 + z5; /* c2+c6 */
            var z3: Float = tmp11 * 0.707106781; /* c4 */

            var z11: Float = tmp7 + z3;  /* phase 5 */
            var z13: Float = tmp7 - z3;

            data[dataOff + 5] = z13 + z2;    /* phase 6 */
            data[dataOff + 3] = z13 - z2;
            data[dataOff + 1] = z11 + z4;
            data[dataOff + 7] = z11 - z4;

            dataOff += 8; /* advance pointer to next row */
        }

        /* Pass 2:  process columns. */
        dataOff = 0;
        for (j in 0...8) {
            var tmp0p2: Float = data[dataOff+ 0] + data[dataOff+56];
            var tmp7p2: Float = data[dataOff+ 0] - data[dataOff+56];
            var tmp1p2: Float = data[dataOff+ 8] + data[dataOff+48];
            var tmp6p2: Float = data[dataOff+ 8] - data[dataOff+48];
            var tmp2p2: Float = data[dataOff+16] + data[dataOff+40];
            var tmp5p2: Float = data[dataOff+16] - data[dataOff+40];
            var tmp3p2: Float = data[dataOff+24] + data[dataOff+32];
            var tmp4p2: Float = data[dataOff+24] - data[dataOff+32];

            /* Even part */
            var tmp10p2: Float = tmp0p2 + tmp3p2;    /* phase 2 */
            var tmp13p2: Float = tmp0p2 - tmp3p2;
            var tmp11p2: Float = tmp1p2 + tmp2p2;
            var tmp12p2: Float = tmp1p2 - tmp2p2;

            data[dataOff+ 0] = tmp10p2 + tmp11p2; /* phase 3 */
            data[dataOff+32] = tmp10p2 - tmp11p2;

            var z1p2: Float = (tmp12p2 + tmp13p2) * 0.707106781; /* c4 */
            data[dataOff+16] = tmp13p2 + z1p2; /* phase 5 */
            data[dataOff+48] = tmp13p2 - z1p2;

            /* Odd part */
            tmp10p2 = tmp4p2 + tmp5p2; /* phase 2 */
            tmp11p2 = tmp5p2 + tmp6p2;
            tmp12p2 = tmp6p2 + tmp7p2;

            /* The rotator is modified from fig 4-8 to avoid extra negations. */
            var z5p2: Float = (tmp10p2 - tmp12p2) * 0.382683433; /* c6 */
            var z2p2: Float = 0.541196100 * tmp10p2 + z5p2; /* c2-c6 */
            var z4p2: Float = 1.306562965 * tmp12p2 + z5p2; /* c2+c6 */
            var z3p2: Float= tmp11p2 * 0.707106781; /* c4 */

            var z11p2: Float = tmp7p2 + z3p2;  /* phase 5 */
            var z13p2: Float = tmp7p2 - z3p2;

            data[dataOff+40] = z13p2 + z2p2; /* phase 6 */
            data[dataOff+24] = z13p2 - z2p2;
            data[dataOff+ 8] = z11p2 + z4p2;
            data[dataOff+56] = z11p2 - z4p2;

            dataOff++; /* advance pointer to next column */
        }

        // Quantize/descale the coefficients
        for (k in 0...64) {
            // Apply the quantization and scaling factor & Round to nearest integer
            data[k] = Math.round(data[k] * fdtbl[k]);
        }
        return data;
    }

    // Chunk writing

    inline function b(v) {
        byteout.writeByte(v);
    }

    function writeAPP0() {
        b(0xFF); b(0xE0);  //<- marker 0xFFE0
        b(0); b(16);  //<- length
        b("J".code);  // J
        b("F".code);
        b("I".code);
        b("F".code);
        b(0);
        b(1);  // versionhi
        b(1);  // versionlo
        b(0);  // xyunits
        b(0); b(1);  // xdensity
        b(0); b(1);  // ydensity
        b(0);  // thumbnwidth
        b(0);  // thumbnheight
    }
    function writeDQT() {
        b(0xFF); b(0xDB);  //<- marker 0xFFDB
        b(0); b(132);    //<- length
        b(0);
        for( j in 0...64 )
            b(YTable[j]);
        b(1);
        for( j in 0...64 )
            b(UVTable[j]);
    }
    function writeSOF0(width: Int, height: Int) {
        b(0xFF); b(0xC0);  //<- marker 0xFFC0
        b(0);  b(17);     //<- length, truecolor YUV JPG
        b(8);  // precision
        b( (height>>8) & 0xFF );
        b(  height & 0xFF );
        b(  (width>>8) & 0xFF );
        b(  width & 0xFF );
        b(3);      // nrofcomponents
        b(1);      // IdY
        b(0x11); // HVY
        b(0);      // QTY
        b(2);      // IdU
        b(0x11); // HVU
        b(1);      // QTU
        b(3);      // IdV
        b(0x11); // HVV
        b(1);      // QTV
    }

    function writeDHT() {
        b(0xFF); b(0xC4);  //<- marker 0xFFC4
        b(0x01); b(0xA2);    //<- length
        b(0);  // HTYDCinfo
        for( j in 1...17 )
            b(std_dc_luminance_nrcodes[j]);
        byteout.write(std_dc_luminance_values);

        b(0x10);  // HTYACinfo
        for( j in 1...17 )
            b(std_ac_luminance_nrcodes[j]);
        byteout.write(std_ac_luminance_values);

        b(1);  // HTUDCinfo
        for( j in 1...17 )
            b(std_dc_chrominance_nrcodes[j]);
        byteout.write(std_dc_chrominance_values);

        b(0x11);  // HTUACinfo
        for( j in 1...17 )
            b(std_ac_chrominance_nrcodes[j]);
        byteout.write(std_ac_chrominance_values);
    }

    function writeSOS() {
        b(0xFF); b(0xDA);  //<- marker 0xFFDA
        b(0); b(12);    //<- length
        b(3);      // nrofcomponents
        b(1);      // IdY
        b(0);      // HTY
        b(2);      // IdU
        b(0x11); // HTU
        b(3);      // IdV
        b(0x11); // HTV
        b(0);      // Ss
        b(0x3F); // Se
        b(0);      // Bf
    }

    // Core processing
    var DU: Array<Float>;

    function processDU(CDU: Array<Float>, fdtbl: Array<Float>, DC: Float, HTDC: Map<Int,BitString>, HTAC: Map<Int,BitString>): Float {
        var EOB: BitString = HTAC.get( 0x00 );
        var M16zeroes: BitString = HTAC.get( 0xF0 );

        var DU_DCT: Array<Float> = fDCTQuant(CDU, fdtbl);
        //ZigZag reorder
        for (i in 0...64) {
            DU[ ZigZag[i] ] = DU_DCT[i];
        }
        var idx: Int;
        var Diff = Std.int( DU[0] - DC );
        DC = DU[0];
        
        // CORRECCIÓN DE RANGO: Clamping de la diferencia DC (previene accesos a `category` fuera de rango)
        if (Diff > 16383) Diff = 16383; 
        if (Diff < -16383) Diff = -16383; 

        //Encode DC
        if( Diff == 0 ) {
            writeBits( HTDC.get(0) );
        } else {
            idx = 32767 + Diff;
            writeBits(HTDC.get( category.get( idx ) ));
            writeBits( bitcode.get( idx ) );
        }

        //Encode ACs
        var end0pos = 63;
        while( (end0pos > 0) && ( DU[end0pos] == 0.0 ) ) end0pos--;

        //end0pos = first element in reverse order !=0
        if ( end0pos == 0 ) {
            writeBits(EOB);
            return DC;
        }
        var i = 1;
        while ( i <= end0pos ) {
            var startpos = i;
            while( ( DU[i] == 0.0 ) && ( i <= end0pos ) ) i++;

            // Chequeo de seguridad si 'i' saltó más allá
            if (i > end0pos) break;

            var nrzeroes: Int = i - startpos;
            if ( nrzeroes >= 16 ) {
                for( nrmarker in 0...(nrzeroes >> 4) ) writeBits(M16zeroes);
                nrzeroes &= 0xF;
            }
            
            // CORRECCIÓN DE RANGO: Clamping del coeficiente AC
            var du_val = Std.int( DU[i] );
            if (du_val > 16383) du_val = 16383; 
            if (du_val < -16383) du_val = -16383;
            
            // LÓGICA DE SALTO: Si el clamping forzó el valor a 0, saltamos.
            if (du_val == 0) {
                i++; 
                continue;
            }
            
            idx = 32767 + du_val;
            
            var cat = category.get( idx );
            // Si 'cat' es nulo, significa que el valor de 'du_val' está fuera del rango -16383..16383, lo cual el clamping debería haber prevenido.
            var index_ac = nrzeroes * 16 + cat;

            writeBits( HTAC.get( index_ac ) );
            writeBits( bitcode.get( idx ) );
            i++;
        }
        if( end0pos != 63 ) writeBits(EOB);
        return DC;
    }

    var YDU: Array<Float>;
    var UDU: Array<Float>;
    var VDU: Array<Float>;

    function RGB2YUV(img: haxe.io.Bytes, width : Int, xpos: Int, ypos: Int) {
        var pos = 0;
        for( y in 0...8 ) {
            var offset = ((y + ypos) * width + xpos) << 2;
            for( x in 0...8 ) {
                offset++; // skip alpha
                var R = img.get(offset++);
                var G = img.get(offset++);
                var B = img.get(offset++);
                YDU[pos] = ((( 0.29900) * R + ( 0.58700) * G + ( 0.11400) * B)) -128;
                UDU[pos] = (((-0.16874) * R + (-0.33126) * G + ( 0.50000) * B));
                VDU[pos] = ((( 0.50000) * R + (-0.41869) * G + (-0.08131) * B));
                pos++;
            }
        }
    }

    public function new( out : haxe.io.Output ) {
    //begin : lines added to initialize variables
        YTable = new Array<Int>();
        UVTable = new Array<Int>();
        fdtbl_Y = new Array<Float>();
        fdtbl_UV = new Array<Float>();
        for (i in 0...64) {
            YTable.push(0); UVTable.push(0);
            fdtbl_Y.push(0.0); fdtbl_UV.push(0.0);
        }

        bitcode = new Map();
        category = new Map();
        byteout = out;
        bytenew = 0;
        bytepos = 7;

        YDC_HT = new Map();
        UVDC_HT = new Map();
        YAC_HT = new Map();
        UVAC_HT = new Map();

        YDU = new Array<Float>();
        UDU = new Array<Float>();
        VDU = new Array<Float>();
        DU = new Array<Float>();
        for (i in 0...64) {
            YDU.push(0.0); UDU.push(0.0); VDU.push(0.0); DU.push(0.0);
        }
        initZigZag();
        initLuminance();
        initChrominance();
    //end : lines added to initialize variables

        // Create tables
        initHuffmanTbl();
        initCategoryNumber();
    }

    public function write( image : Data ) {
        // init quality table
        var quality = image.quality;
        if( quality <= 0 ) quality = 1;
        if( quality > 100 ) quality = 100;
        var sf =
            if( quality < 50 ) Std.int( 5000 / quality )
            else Std.int( 200 - quality * 2 );
        initQuantTables(sf);

        // Initialize bit writer
        bytenew = 0;
        bytepos = 7;

        var width = image.width;
        var height = image.height;
        // Add JPEG headers
        writeWord(0xFFD8); // SOI
        writeAPP0();
        writeDQT();
        writeSOF0( width, height );
        writeDHT();
        writeSOS();

        // Encode 8x8 macroblocks
        var DCY = 0.0;
        var DCU = 0.0;
        var DCV = 0.0;
        bytenew = 0;
        bytepos = 7;
        var ypos = 0;
        while( ypos < height ) {
            var xpos = 0;
            while( xpos < width ) {
                
                // CORRECCIÓN CRÍTICA DE ESTADO: Limpieza de arreglos para evitar arrastre de valores (lo que el 'trace' estaba enmascarando)
                // Se asegura que los buffers sean cero antes de llenarlos con RGB2YUV si no se llenan completamente.
                for (k in 0...64) { YDU[k] = 0.0; UDU[k] = 0.0; VDU[k] = 0.0; }
                
                RGB2YUV(image.pixels, width, xpos, ypos);
                DCY = processDU(YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
                DCU = processDU(UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
                DCV = processDU(VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
                xpos += 8;
            }
            ypos += 8;
        }

        // Do the bit alignment of the EOI marker
        if( bytepos >= 0 ) {
            var fillbits = new BitString( bytepos + 1, ( 1 << (bytepos + 1) ) - 1 );
            writeBits(fillbits);
        }

        writeWord(0xFFD9); //EOI
    }
}

private class BitString {
    public var len: Int;
    public var val: Int;

    public function new( l: Int, v: Int ) {
        len = l;
        val = v;
    }
}