Repe [T3DU] Update - 31f26d171bba0355ce2a77031e3aad4c64dbc7e9
This commit is contained in:
651
leenkx/Sources/iron/format/jpg/WriterOriginal.hx
Normal file
651
leenkx/Sources/iron/format/jpg/WriterOriginal.hx
Normal file
@ -0,0 +1,651 @@
|
||||
/*
|
||||
* format - Haxe File Formats
|
||||
*
|
||||
* JPG File Format
|
||||
* Copyright (C) 2007-2009 Thibault Imbert, AS3-to-Haxe by Michel Oster
|
||||
*
|
||||
* Copyright (c) 2009, The Haxe Project Contributors
|
||||
* All rights reserved.
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* - Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE HAXE PROJECT CONTRIBUTORS "AS IS" AND ANY
|
||||
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
* DISCLAIMED. IN NO EVENT SHALL THE HAXE PROJECT CONTRIBUTORS BE LIABLE FOR
|
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
|
||||
* DAMAGE.
|
||||
*/
|
||||
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>; // = new Array(64);
|
||||
var UVTable: Array<Int>; // = new Array(64);
|
||||
var fdtbl_Y: Array<Float>; // = new Array(64);
|
||||
var fdtbl_UV: Array<Float>; // = new Array(64);
|
||||
|
||||
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>;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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) {
|
||||
var value: Int = bs.val;
|
||||
var posval: Int = bs.len - 1;
|
||||
while( posval >= 0 ) {
|
||||
//if (value & uint(1 << posval) ) {
|
||||
if( (value & (1 << posval)) != 0 ) { //<- CORRECT ?
|
||||
//bytenew |= uint(1 << bytepos);
|
||||
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>; //<- initialized in function new JPEGEncoder()
|
||||
|
||||
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];
|
||||
//Encode DC
|
||||
if( Diff == 0 ) {
|
||||
writeBits( HTDC.get(0) ); // Diff might be 0
|
||||
} else {
|
||||
idx = 32767 + Diff;
|
||||
writeBits(HTDC.get( category.get( idx ) ));
|
||||
writeBits( bitcode.get( idx ) );
|
||||
}
|
||||
|
||||
//Encode ACs
|
||||
var end0pos = 63;
|
||||
//for (; (end0pos>0)&&(DU[end0pos]==0); end0pos--) { };
|
||||
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;
|
||||
//for (; (DU[i]==0) && (i<=end0pos); i++) { }; <- it's a 'while' loop
|
||||
while( ( DU[i] == 0.0 ) && ( i <= end0pos ) ) i++;
|
||||
|
||||
var nrzeroes: Int = i - startpos;
|
||||
if ( nrzeroes >= 16 ) {
|
||||
//for (var nrmarker: Int=1; nrmarker <= nrzeroes/16; nrmarker++) {
|
||||
for( nrmarker in 0...(nrzeroes >> 4) ) writeBits(M16zeroes);
|
||||
nrzeroes &= 0xF;
|
||||
}
|
||||
idx = 32767 + Std.int( DU[i] ); //<- line added
|
||||
writeBits( HTAC.get( nrzeroes * 16 + category.get( idx ) ) );
|
||||
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(); //<- 65535 elements <BitString>
|
||||
category = new Map(); //<- 65535 elements <Int>
|
||||
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>(); //<- 64 elements
|
||||
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 ) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user