public static void TransBlock(PDJPG_Context ctx, ShortPtr iblk, ShortPtr oblk, int dcbias, int qid, out int tag)
{
ShortPtr tblk = new ShortPtr(64);
double err, berr;
int i, j, k, btag, bqt;
if (false)
{
tag = 0;
TransBlock2(iblk, oblk, dcbias, tag, 1);
return;
}
k = (100 - (ctx.jpg_qfl&255)) / 10;
bqt = k;
//bqt = k * k;
//bqt = 0;
btag = 0; berr = 999999999.0;
for (i = 0; i < 7; i++)
{
TransBlock2(iblk, tblk, dcbias, i, bqt + 1);
ctx.block.QuantBlock(ctx, tblk, tblk, qid, i);
err = 0;
for (j = 0; j < 64; j++)
{
k = tblk[j];
if (k < 0) k = -k;
err += k;
}
if (err < berr)
{ btag = i; berr = err; }
}
//if (btag != 0)
//Console.Write("P={0}Q{1} ", btag, bqt);
tag = btag;
if (btag != 0) tag |= (bqt << 8);
TransBlock2(iblk, oblk, dcbias, tag, bqt + 1);
}
public void CheckAdjustRangeRead(PDJPG_Context ctx)
{
//if (range <= 0xFFFFFF)
if ((low & 0xFF000000) == (high & 0xFF000000))
{
low = low << 8;
high = (high << 8) + 0xFF;
win = (uint)((win << 8) + NextByte(ctx));
return;
}
if ((high - low) <= minSymRange)
{
//Console.WriteLine("Read Range Collapse");
//FlushBits(ctx);
win = (uint)NextByte(ctx);
win = (uint)((win << 8) + NextByte(ctx));
win = (uint)((win << 8) + NextByte(ctx));
win = (uint)((win << 8) + NextByte(ctx));
low = 0x00000000;
high = 0xFFFFFFFF;
}
}
public static void PDJPG_EmitMarkerDMLT_DQT(PDJPG_Context ctx, int n)
{
BytePtr tbuf, ct1, ct2;
int i, j, k, l, nb;
#if false
nb = 1;
for (i = 0; i < 64; i++)
{
j=ctx.jpg_qt[n * 64 + i];
while (j >= (1 << nb)) nb++;
}
#endif
nb = 4;
tbuf = new BytePtr(65536);
ct2 = ctx.huff.ct;
ctx.huff.InitOutputStream(ctx, tbuf);
ctx.huff.WriteNBits(ctx, 0, 4); //reserved
ctx.huff.WriteNBits(ctx, nb, 4); //DQT bits
l = 0;
for (i = 0; i < 64; i++)
{
//ctx.huff.WriteNBits(ctx, ctx.jpg_qt[n * 64 + pdjpg_zigzag2[i]], nb);
k = ctx.jpg_qt[n * 64 + pdjpg_zigzag2[i]];
((PDJHUFF)ctx.huff).WriteSRice(ctx, k - l, nb);
l = k;
}
// WriteNBits(ctx, 1, 4);
// WriteNBits(ctx, 2, 4);
// BSXRP_EncodeCodeLengths(ctx, new BytePtr(len, tab * 256), 256);
ctx.huff.FlushBits(ctx);
ct1 = ctx.huff.ct;
ctx.huff.ct = ct2;
i = ct1 - tbuf;
ctx.huff.ct.emit(PDJPG_DMLT_DQT0 + n);
ctx.huff.ct.EmitUVLI((ulong)i);
BytePtr.memcpy(ctx.huff.ct, tbuf, i);
ctx.huff.ct += i;
}
public static int PDJPG_EncodeFloatComponentCtx(PDJPG_Context ctx,
float[] rgba, float[] norm, float[] spec, float[] luma,
BytePtr obuf, int xs, int ys, int qf)
{
byte[] trgba, tnorm, tspec, tluma, tlebe;
int i, j, n;
double f;
n = xs * ys;
if (ctx.imgbuf_rgba == null)
ctx.imgbuf_rgba = new byte[4 * n];
if (ctx.imgbuf_norm == null)
ctx.imgbuf_norm = new byte[4 * n];
if (ctx.imgbuf_spec == null)
ctx.imgbuf_spec = new byte[4 * n];
if (ctx.imgbuf_luma == null)
ctx.imgbuf_luma = new byte[4 * n];
if (ctx.imgbuf_lebe == null)
{
ctx.imgbuf_lebe = new byte[4 * n];
BytePtr.memset(ctx.imgbuf_lebe, 192, 4 * n);
}
trgba = ctx.imgbuf_rgba;
tnorm = ctx.imgbuf_norm;
tspec = ctx.imgbuf_spec;
tluma = ctx.imgbuf_luma;
tlebe = ctx.imgbuf_lebe;
if (rgba != null)
{
for (i = 0; i < n; i++)
{
PDJPG_EncodeFloatPixel(new FloatPtr(rgba, i * 4), new BytePtr(trgba, i * 4), new BytePtr(tlebe, i * 4 + 0));
}
}
if (norm != null)
{
for (i = 0; i < n; i++)
{
// f=(1.0/256)*pdjpg_scltab[tlebe[i*4+0]];
j = PDJPG_CalcComponentValueExponent(norm[i * 4 + 3]);
f = 255 / pdjpg_scltab[j];
tnorm[i * 4 + 0] = (byte)(norm[i * 4 + 0] * 255);
tnorm[i * 4 + 1] = (byte)(norm[i * 4 + 1] * 255);
tnorm[i * 4 + 2] = (byte)(norm[i * 4 + 2] * 255);
tnorm[i * 4 + 3] = (byte)(norm[i * 4 + 3] * f);
tlebe[i * 4 + 3] = (byte)j;
}
}
if (spec != null)
{
for (i = 0; i < n; i++)
{
tspec[i * 4 + 0] = (byte)(spec[i * 4 + 0] * 255);
tspec[i * 4 + 1] = (byte)(spec[i * 4 + 1] * 255);
tspec[i * 4 + 2] = (byte)(spec[i * 4 + 2] * 255);
tspec[i * 4 + 3] = (byte)(spec[i * 4 + 3] * 255);
}
}
if (luma != null)
{
for (i = 0; i < n; i++)
{
PDJPG_EncodeFloatPixel(new FloatPtr(luma, i * 4), new BytePtr(tluma, i * 4), new BytePtr(tlebe, i * 4 + 1));
}
}
i = PDJPG_EncodeComponentCtxI(ctx,
trgba, tnorm, tspec, tluma, tlebe,
obuf, xs, ys, qf);
return (i);
}
public static void PDJPG_ConvertImageYUV(PDJPG_Context ctx,
BytePtr ibuf, int xs, int ys, int pf,
int xs2, int ys2, int xs3, int ys3)
{
// void (*getPixel2)(BytePtr rgb,
// int *ra, int *ga, int *ba,
// int *rb, int *gb, int *bb);
BytePtr cse;
ShortPtr ctu, ctv;
BytePtr cs1, cs2;
ShortPtr cty1, cty2;
int cr, cg, cb, ca, cy, cu, cv;
int cra, cga, cba, caa, cya, cua, cva;
int crb, cgb, cbb, cab, cyb, cub, cvb;
int crc, cgc, cbc, cac, cyc, cuc, cvc;
int crd, cgd, cbd, cad, cyd, cud, cvd;
int psz, psz2;
int i, k, l, n;
if ((pf == PDJPG_RGBA) && (ctx.alphaClr == 0))
{
n = (ys + 1) / 2;
for (i = 0; i < n; i++)
{
k = ((ys - (2 * i + 1)) * xs) * 4;
cs1 = ibuf + k; cse = cs1 + xs * 4;
l = ((ys - (2 * i + 2)) * xs) * 4;
cs2 = ibuf + l;
cty1 = new ShortPtr(ctx.yb, (2 * i + 0) * xs2);
cty2 = new ShortPtr(ctx.yb, (2 * i + 1) * xs2);
l = i * xs3;
ctu = new ShortPtr(ctx.ub, l);
ctv = new ShortPtr(ctx.vb, l);
while (cs1 < cse)
{
cra = cs1[0]; cga = cs1[1]; cba = cs1[2];
crb = cs1[4]; cgb = cs1[5]; cbb = cs1[6];
crc = cs2[0]; cgc = cs2[1]; cbc = cs2[2];
crd = cs2[4]; cgd = cs2[5]; cbd = cs2[6];
cya = 19595 * cra + 38470 * cga + 7471 * cba;
cyb = 19595 * crb + 38470 * cgb + 7471 * cbb;
cyc = 19595 * crc + 38470 * cgc + 7471 * cbc;
cyd = 19595 * crd + 38470 * cgd + 7471 * cbd;
cty1.emit(cya >> 16);
cty1.emit(cyb >> 16);
cty2.emit(cyc >> 16);
cty2.emit(cyd >> 16);
cr = (cra + crb + crc + crd) >> 2;
cg = (cga + cgb + cgc + cgd) >> 2;
cb = (cba + cbb + cbc + cbd) >> 2;
cu = -11056 * cr - 21712 * cg + 32768 * cb;
cv = 32768 * cr - 27440 * cg - 5328 * cb;
ctu.emit((cu >> 16) + 128);
ctv.emit((cv >> 16) + 128);
cs1 += 8; cs2 += 8;
}
}
}
else
if ((pf == PDJPG_RGBA) || (pf == PDJPG_RGB) ||
(pf == PDJPG_BGRA) || (pf == PDJPG_BGR))
{
switch (pf)
{
case PDJPG_RGBA:
case PDJPG_BGRA:
psz = 4; break;
case PDJPG_RGB:
case PDJPG_BGR:
psz = 3; break;
default: psz = 4; break;
}
psz2 = psz * 2;
n = (ys + 1) / 2;
for (i = 0; i < n; i++)
{
k = ((ys - (2 * i + 1)) * xs) * psz;
cs1 = ibuf + k; cse = cs1 + xs * psz;
l = ((ys - (2 * i + 2)) * xs) * psz;
cs2 = ibuf + l;
cty1 = new ShortPtr(ctx.yb, (2 * i + 0) * xs2);
cty2 = new ShortPtr(ctx.yb, (2 * i + 1) * xs2);
l = i * xs3;
ctu = new ShortPtr(ctx.ub, l);
ctv = new ShortPtr(ctx.vb, l);
while (cs1 < cse)
{
// getPixel2(cs1, &cra, &cga, &cba, &crb, &cgb, &cbb);
// getPixel2(cs2, &crc, &cgc, &cbc, &crd, &cgd, &cbd);
switch (pf)
{
case PDJPG_RGBA:
cra = cs1[0]; cga = cs1[1]; cba = cs1[2]; caa = cs1[3];
crb = cs1[4]; cgb = cs1[5]; cbb = cs1[6]; cab = cs1[7];
crc = cs2[0]; cgc = cs2[1]; cbc = cs2[2]; cac = cs2[3];
crd = cs2[4]; cgd = cs2[5]; cbd = cs2[6]; cad = cs2[7];
psz = 8; break;
case PDJPG_BGRA:
cra = cs1[2]; cga = cs1[1]; cba = cs1[0]; caa = cs1[3];
crb = cs1[6]; cgb = cs1[5]; cbb = cs1[4]; cab = cs1[7];
crc = cs2[2]; cgc = cs2[1]; cbc = cs2[0]; cac = cs2[3];
crd = cs2[6]; cgd = cs2[5]; cbd = cs2[4]; cad = cs2[7];
psz = 8; break;
case PDJPG_RGB:
cra = cs1[0]; cga = cs1[1]; cba = cs1[2]; caa = 255;
crb = cs1[3]; cgb = cs1[4]; cbb = cs1[5]; cab = 255;
crc = cs2[0]; cgc = cs2[1]; cbc = cs2[2]; cac = 255;
crd = cs2[3]; cgd = cs2[4]; cbd = cs2[5]; cad = 255;
psz = 6; break;
case PDJPG_BGR:
cra = cs1[2]; cga = cs1[1]; cba = cs1[0]; caa = 255;
crb = cs1[5]; cgb = cs1[4]; cbb = cs1[3]; cab = 255;
crc = cs2[2]; cgc = cs2[1]; cbc = cs2[0]; cac = 255;
crd = cs2[5]; cgd = cs2[4]; cbd = cs2[3]; cad = 255;
psz = 6; break;
default:
cra = 0; crb = 0; crc = 0; crd = 0;
cga = 0; cgb = 0; cgc = 0; cgd = 0;
cba = 0; cbb = 0; cbc = 0; cbd = 0;
caa = 0; cab = 0; cac = 0; cad = 0;
break;
}
if (ctx.alphaClr != 0)
{
ca = (caa + cab + cac + cad) >> 2;
if (ca < ctx.alphaClrA)
{
cy = ctx.alphaClrY;
cu = ctx.alphaClrU;
cv = ctx.alphaClrV;
cty1.emit(cy); cty1.emit(cy);
cty2.emit(cy); cty2.emit(cy);
ctu.emit(cu); ctv.emit(cv);
continue;
}
}
cya = 19595 * cra + 38470 * cga + 7471 * cba;
cyb = 19595 * crb + 38470 * cgb + 7471 * cbb;
cyc = 19595 * crc + 38470 * cgc + 7471 * cbc;
cyd = 19595 * crd + 38470 * cgd + 7471 * cbd;
cty1.emit(cya >> 16);
cty1.emit(cyb >> 16);
cty2.emit(cyc >> 16);
cty2.emit(cyd >> 16);
cr = (cra + crb + crc + crd) >> 2;
cg = (cga + cgb + cgc + cgd) >> 2;
cb = (cba + cbb + cbc + cbd) >> 2;
cu = -11056 * cr - 21712 * cg + 32768 * cb;
cv = 32768 * cr - 27440 * cg - 5328 * cb;
ctu.emit((cu >> 16) + 128);
ctv.emit((cv >> 16) + 128);
cs1 += psz2; cs2 += psz2;
}
}
}
else
{
switch (pf)
{
case PDJPG_YUVA: psz = 4; psz2 = 8; break;
case PDJPG_YUV: psz = 3; psz2 = 6; break;
case PDJPG_YUV422: psz = 2; psz2 = 4; break;
case PDJPG_YUV420: psz = 3; psz2 = 3; break;
case PDJPG_YA: psz = 2; psz2 = 4; break;
case PDJPG_Y: psz = 1; psz2 = 2; break;
case PDJPG_YYYA: psz = 4; psz2 = 8; break;
default: psz = 4; psz2 = 8; break;
}
n = (ys + 1) / 2;
for (i = 0; i < n; i++)
{
if (pf == PDJPG_YUV420)
{
k = (((ys - (2 * i + 1)) * xs2) * psz2) >> 1;
cs1 = ibuf + k; cse = cs1 + ((xs * psz2) >> 1);
l = (((ys - (2 * i + 2)) * xs2) * psz2) >> 1;
cs2 = ibuf + l;
}
else
{
k = ((ys - (2 * i + 1)) * xs) * psz;
cs1 = ibuf + k; cse = cs1 + xs * psz;
l = ((ys - (2 * i + 2)) * xs) * psz;
cs2 = ibuf + l;
}
cty1 = new ShortPtr(ctx.yb, (2 * i + 0) * xs2);
cty2 = new ShortPtr(ctx.yb, (2 * i + 1) * xs2);
l = i * xs3;
ctu = new ShortPtr(ctx.ub, l);
ctv = new ShortPtr(ctx.vb, l);
while (cs1 < cse)
{
// getPixel2(cs1, &cra, &cga, &cba, &crb, &cgb, &cbb);
// getPixel2(cs2, &crc, &cgc, &cbc, &crd, &cgd, &cbd);
switch (pf)
{
case PDJPG_YUVA:
cya = cs1[0]; cua = cs1[1]; cva = cs1[2];
cyb = cs1[4]; cub = cs1[5]; cvb = cs1[6];
cyc = cs2[0]; cuc = cs2[1]; cvc = cs2[2];
cyd = cs2[4]; cud = cs2[5]; cvd = cs2[6];
cu = (cua + cub + cuc + cud) >> 2;
cv = (cva + cvb + cvc + cvd) >> 2;
break;
case PDJPG_YUV:
cya = cs1[0]; cua = cs1[1]; cva = cs1[2];
cyb = cs1[3]; cub = cs1[4]; cvb = cs1[5];
cyc = cs2[0]; cuc = cs2[1]; cvc = cs2[2];
cyd = cs2[3]; cud = cs2[4]; cvd = cs2[5];
cu = (cua + cub + cuc + cud) >> 2;
cv = (cva + cvb + cvc + cvd) >> 2;
break;
case PDJPG_YUV422:
cya = cs1[0]; cua = cs1[1]; cyb = cs1[2]; cva = cs1[3];
cyc = cs2[0]; cuc = cs2[1]; cyd = cs2[2]; cvc = cs2[3];
cu = (cua + cuc) >> 1; cv = (cva + cvc) >> 1;
break;
case PDJPG_YUV420:
cya = cs1[0]; cyb = cs1[1]; cu = cs1[2];
cyc = cs2[0]; cyd = cs2[1]; cv = cs2[2];
break;
case PDJPG_YA:
cya = cs1[0]; cyb = cs1[2];
cyc = cs2[0]; cyd = cs2[2];
cu = 0; cv = 0;
break;
case PDJPG_Y:
cya = cs1[0]; cyb = cs1[1];
cyc = cs2[0]; cyd = cs2[1];
cu = 0; cv = 0;
break;
case PDJPG_YYYA:
cya = cs1[1]; cyb = cs1[5];
cyc = cs2[1]; cyd = cs2[5];
cu = 0; cv = 0;
break;
default:
cya = 0; cyb = 0; cyc = 0; cyd = 0;
cua = 0; cub = 0; cuc = 0; cud = 0;
cva = 0; cvb = 0; cvc = 0; cvd = 0;
caa = 0; cab = 0; cac = 0; cad = 0;
cu = 0; cv = 0;
break;
}
cty1.emit(cya); cty1.emit(cyb);
cty2.emit(cyc); cty2.emit(cyd);
ctu.emit(cu); ctv.emit(cv);
cs1 += psz2; cs2 += psz2;
}
}
}
}
public static int PDJPG_EncodeComponentCtx(
PDJPG_Context ctx,
byte[] rgba, byte[] norm, byte[] spec, byte[] luma,
BytePtr obuf, int xs, int ys, int qf)
{
return (PDJPG_EncodeComponentCtxI(ctx,
rgba, norm, spec, luma, null,
obuf, xs, ys, qf));
}
public static int PDJPG_EncodeComponentCtxI2(
PDJPG_Context ctx,
byte[] rgba, byte[] norm, byte[] spec, byte[] luma, byte[] lebe,
BytePtr obuf, int xs, int ys, int qf, string tlname, PDJPG_LayerInfo linf)
{
byte[] tbuf;
BytePtr ct;
int i, j, k, n;
if (rgba == null) return (-1);
if (linf != null)
{
ctx.bcst_orgx = linf.orgx;
ctx.bcst_orgy = linf.orgy;
ctx.bcst_alpha = linf.alpha;
ctx.bcst_blend = linf.blend;
ctx.bcst_flags = (uint)linf.flags;
ctx.bcst_minx = linf.minx;
ctx.bcst_miny = linf.miny;
ctx.bcst_maxx = linf.maxx;
ctx.bcst_maxy = linf.maxy;
}
else
{
ctx.bcst_orgx = 0;
ctx.bcst_orgy = 0;
ctx.bcst_alpha = 255;
ctx.bcst_blend = 0;
ctx.bcst_flags = 0;
ctx.bcst_minx = 0;
ctx.bcst_miny = 0;
ctx.bcst_maxx = 0;
ctx.bcst_maxy = 0;
}
n = xs * ys;
tbuf = new byte[xs * ys * 4];
ct = obuf;
//ct.emit(0xFF);
//ct.emit(JPG.JPG_SOI);
//ct = PDJPG_EmitMarkerJFIF(ctx, ct);
if (tlname != null)
{
ct = PDJPG_EmitTagLayer(ctx, ct, tlname);
ct = PDJPG_EmitComponentLayer(ctx, ct, "RGB");
i = PDJPG_EncodeLDatCtx(ctx, rgba, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
else
{
ct = PDJPG_EmitComponentLayer(ctx, ct, "RGB");
// i=PDJPG_EncodeCtx(ctx, rgba, ct, xs, ys, qf, 0);
i = PDJPG_EncodeBaseCtx(ctx, rgba, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
// if((ct[-2]==0xFF) && (ct[-2]==JPG_EOI))
// { ct-=2; }
if (norm != null)
{
for (i = 0; i < n; i++)
{
tbuf[i * 4 + 0] = norm[i * 4 + 0];
tbuf[i * 4 + 1] = norm[i * 4 + 2];
tbuf[i * 4 + 2] = norm[i * 4 + 1];
tbuf[i * 4 + 3] = 255;
}
ct = PDJPG_EmitComponentLayer(ctx, ct, "XYZ");
i = PDJPG_EncodeLDatCtx(ctx, tbuf, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
if (spec != null)
{
ct = PDJPG_EmitComponentLayer(ctx, ct, "SpRGB");
i = PDJPG_EncodeLDatCtx(ctx, spec, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
if ((norm != null) || (spec != null))
{
for (i = 0; i < n; i++)
{
j = rgba[i * 4 + 3];
tbuf[i * 4 + 0] = (byte)((norm != null) ? norm[i * 4 + 3] : j);
tbuf[i * 4 + 1] = rgba[i * 4 + 3];
tbuf[i * 4 + 2] = (byte)((spec != null) ? spec[i * 4 + 3] : j);
tbuf[i * 4 + 3] = 255;
}
ct = PDJPG_EmitComponentLayer(ctx, ct, "DASe");
i = PDJPG_EncodeLDatCtx(ctx, tbuf, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
else
{
k = 0;
for (i = 0; i < n; i++)
{
j = rgba[i * 4 + 3];
if (j != 255) k = 1;
tbuf[i * 4 + 0] = (byte)j;
tbuf[i * 4 + 1] = (byte)j;
tbuf[i * 4 + 2] = (byte)j;
tbuf[i * 4 + 3] = 255;
}
if (k != 0)
{
ct = PDJPG_EmitComponentLayer(ctx, ct, "Alpha");
i = PDJPG_EncodeLDatCtx(ctx, tbuf, ct, xs, ys, qf, PDJPG_YYYA);
if (i < 0) { return (i); }
ct += i;
}
}
if (luma != null)
{
ct = PDJPG_EmitComponentLayer(ctx, ct, "LuRGB");
i = PDJPG_EncodeLDatCtx(ctx, luma, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
if (lebe != null)
{
ct = PDJPG_EmitComponentLayer(ctx, ct, "LeBe");
i = PDJPG_EncodeLDatCtx(ctx, lebe, ct, xs, ys, qf, 0);
if (i < 0) { return (i); }
ct += i;
}
//ct.emit(0xFF);
//ct.emit(JPG.JPG_EOI);
//free(tbuf);
return (ct - obuf);
}
public static void PDJPG_EmitSOS(PDJPG_Context ctx)
{
BytePtr p;
int i;
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_SOS);
i = 6 + (ctx.jpg_mono ? 1 : 3) * 2;
p = ctx.huff.ct;
ctx.huff.ct.emit(i >> 8); //Lf
ctx.huff.ct.emit(i & 0xFF);
if (ctx.jpg_yuvw)
{
ctx.huff.ct.emit(4); //Ns
ctx.huff.ct.emit(1); //Csi
ctx.huff.ct.emit(0x00); //Tdi Tai
ctx.huff.ct.emit(2); //Csi
ctx.huff.ct.emit(0x11); //Tdi Tai
ctx.huff.ct.emit(3); //Csi
ctx.huff.ct.emit(0x11); //Tdi Tai
ctx.huff.ct.emit(4); //Csi
ctx.huff.ct.emit(0x11); //Tdi Tai
}
else if (!ctx.jpg_mono)
{
ctx.huff.ct.emit(3); //Ns
ctx.huff.ct.emit(1); //Csi
ctx.huff.ct.emit(0x00); //Tdi Tai
ctx.huff.ct.emit(2); //Csi
ctx.huff.ct.emit(0x11); //Tdi Tai
ctx.huff.ct.emit(3); //Csi
ctx.huff.ct.emit(0x11); //Tdi Tai
}
else
{
ctx.huff.ct.emit(1); //Ns
ctx.huff.ct.emit(1); //Csi
ctx.huff.ct.emit(0x00); //Tdi Tai
}
ctx.huff.ct.emit(0); //Ss
ctx.huff.ct.emit(63); //Se
ctx.huff.ct.emit(0x00); //Ah Al
i = ctx.huff.ct - p;
p[0] = i >> 8; //Lf
p[1] = i & 0xFF;
}
public static int PDJPG_EncodeBaseCtx(
PDJPG_Context ctx, byte[] ibuf, BytePtr obuf,
int xs, int ys, int qf, int pf)
{
BytePtr tbuf, cs, cse, ct;
int sz;
tbuf = new BytePtr(1 << 24);
sz = PDJPG_EncodeCtx(ctx, ibuf, tbuf, xs, ys, qf, pf);
cs = tbuf; cse = tbuf + sz; ct = obuf;
if ((cs[0] == 0xFF) && (cs[1] == JPG.JPG_SOI))
cs += 2;
while (cs < cse)
{
if ((cs[0] == 0xFF) && (cs[1] == JPG.JPG_EOI))
break;
ct.emit(cs.next());
}
//free(tbuf);
return (ct - obuf);
}
//Encoder
public static void PDJPG_WriteString(PDJPG_Context ctx, string str)
{
// char* s;
int i;
ctx.huff.FlushBits(ctx);
// s = str;
// while (*s)
// *ctx.huff.ct++ = *s++;
for (i = 0; i < str.Length; i++)
ctx.huff.ct.emit(str[i]);
ctx.huff.ct.emit(0);
}
public static int PDJPG_EncodeCtx_MegablockInner(
PDJPG_Context ctx, BytePtr obuf, int xs, int ys, int qfl)
{
// static BytePtr yb=null, *ub, *vb;
// static short *ydb=null, *udb, *vdb;
// static int lxs=0, lys=0;
IntPtr dcs = new IntPtr(256);
IntPtr acs = new IntPtr(256);
IntPtr dcsuv = new IntPtr(256);
IntPtr acsuv = new IntPtr(256);
ShortPtr tp;
int xs2, ys2, xs3, ys3, qf;
// int cr, cg, cb, cy, cu, cv;
int i, j, k, l;
qf = qfl & 255;
xs2 = ctx.xs2;
ys2 = ctx.ys2;
xs3 = ctx.xs3;
ys3 = ctx.ys3;
// printf("M1\n");
// if(qf==110)
if (ctx.jpg_rdct)
{
// printf("PDJPG_EncodeCtx: Lossless Detect\n");
PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128);
PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128);
PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128);
}
else
{
PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128);
PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128);
PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128);
//PDJPG_FilterImageDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128);
//PDJPG_FilterImageDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128);
//PDJPG_FilterImageDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128);
}
j = (xs2 / 64) * (ys2 / 64);
PDJPG_MakeMegaQuantTabInputY(ctx.ydb, j, new BytePtr(ctx.jpg_qt, 0 * 256), qf / 100.0);
j = (xs3 / 64) * (ys3 / 64);
PDJPG_MakeMegaQuantTabInputUV(ctx.udb, j, new BytePtr(ctx.jpg_qt, 1 * 256), qf / 100.0);
PDJPG_MakeMegaQuantTabInputUV(ctx.vdb, j, new BytePtr(ctx.jpg_qt, 2 * 256), qf / 100.0);
for (i = 0; i < 128; i++) ctx.jpg_qt[1 * 256 + i] = (byte)((ctx.jpg_qt[1 * 256 + i] + ctx.jpg_qt[2 * 256 + i]) / 2);
PDJPG_SetupQuantTabDivFP(ctx, 0);
PDJPG_SetupQuantTabDivFP(ctx, 1);
// free(yb);
// free(ub);
// free(vb);
if (ctx.jpg_mono || !ctx.jpg_is420)
{
j = (xs2 / 64) * (ys2 / 64); k = 0;
for (i = 0; i < j; i++)
{
ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.ydb, i * 4096), new ShortPtr(ctx.ydb, i * 4096), 0);
ctx.ydb[i * 4096 + 0] -= (short)k; k = ctx.ydb[i * 4096 + 0] + k;
}
}
if (!ctx.jpg_mono && ctx.jpg_is420)
{
l = 0;
for (i = 0; i <= (ys3 / 64); i++)
for (j = 0; j < (xs3 / 64); j++)
{
tp = new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 0) * 4096);
ctx.block.QuantMegaBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
tp = new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 1) * 4096);
ctx.block.QuantMegaBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
tp = new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 0) * 4096);
ctx.block.QuantMegaBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
tp = new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 1) * 4096);
ctx.block.QuantMegaBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
}
}
j = (xs3 / 64) * (ys3 / 64); k = 0; l = 0;
for (i = 0; i < j; i++)
{
ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.udb, i * 4096), new ShortPtr(ctx.udb, i * 4096), 1);
ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.vdb, i * 4096), new ShortPtr(ctx.vdb, i * 4096), 1);
ctx.udb[i * 4096 + 0] -= (short)k; k = ctx.udb[i * 4096 + 0] + k;
ctx.vdb[i * 4096 + 0] -= (short)l; l = ctx.vdb[i * 4096 + 0] + l;
}
if (ctx.jpg_yuvw)
{
j = (xs3 / 64) * (ys3 / 64); k = 0;
for (i = 0; i < j; i++)
{
ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.wdb, i * 4096), new ShortPtr(ctx.wdb, i * 4096), 1);
ctx.wdb[i * 4096 + 0] -= (short)k; k = ctx.wdb[i * 4096 + 0] + k;
}
}
// printf("M2\n");
for (i = 0; i < 256; i++) dcs[i] = 0;
for (i = 0; i < 256; i++) acs[i] = 0;
for (i = 0; i < 256; i++) dcsuv[i] = 0;
for (i = 0; i < 256; i++) acsuv[i] = 0;
j = (xs2 / 64) * (ys2 / 64);
k = (xs3 / 64) * (ys3 / 64);
for (i = 0; i < j; i++) ctx.block.StatMegaBlock(new ShortPtr(ctx.ydb, i * 4096), dcs, acs);
for (i = 0; i < k; i++) ctx.block.StatMegaBlock(new ShortPtr(ctx.udb, i * 4096), dcsuv, acsuv);
for (i = 0; i < k; i++) ctx.block.StatMegaBlock(new ShortPtr(ctx.vdb, i * 4096), dcsuv, acsuv);
if (ctx.jpg_yuvw)
{ for (i = 0; i < k; i++)ctx.block.StatMegaBlock(new ShortPtr(ctx.wdb, i * 4096), dcsuv, acsuv); }
// ctx.huff.BuildLengths(dcs, 256, ctx.huff.len+0*256, 16);
// ctx.huff.BuildLengths(acs, 256, ctx.huff.len+1*256, 16);
// ctx.huff.BuildLengths(dcsuv, 256, ctx.huff.len+2*256, 16);
// ctx.huff.BuildLengths(acsuv, 256, ctx.huff.len+3*256, 16);
//ctx.huff.BuildLengthsAdjust(dcs, 256, new BytePtr(ctx.huff.len, 0 * 256), 16);
//ctx.huff.BuildLengthsAdjust(acs, 256, new BytePtr(ctx.huff.len, 1 * 256), 16);
//ctx.huff.BuildLengthsAdjust(dcsuv, 256, new BytePtr(ctx.huff.len, 2 * 256), 16);
//ctx.huff.BuildLengthsAdjust(acsuv, 256, new BytePtr(ctx.huff.len, 3 * 256), 16);
ctx.huff.BuildTable(dcs, 0);
ctx.huff.BuildTable(acs, 1);
ctx.huff.BuildTable(dcsuv, 2);
ctx.huff.BuildTable(acsuv, 3);
//ctx.huff.ct = obuf;
//ctx.huff.win = 0;
//ctx.huff.pos = 0;
ctx.huff.InitOutputStream(ctx, obuf);
if ((qfl & PDJPG_QFL_NOSOI) == 0)
{
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_SOI);
}
PDJPG_EmitMarkerBCST(ctx);
PDJPG_EmitDQT(ctx, 0);
if (!ctx.jpg_mono) PDJPG_EmitDQT(ctx, 1);
PDJPG_EmitSOF(ctx, xs, ys);
ctx.huff.EmitDHT(ctx, 0);
ctx.huff.EmitDHT(ctx, 1);
if (!ctx.jpg_mono)
{
ctx.huff.EmitDHT(ctx, 2);
ctx.huff.EmitDHT(ctx, 3);
}
PDJPG_EmitSOS(ctx);
ctx.huff.InitOutputStream(ctx, ctx.huff.ct);
//ctx.huff.win = 0;
//ctx.huff.pos = 0;
if (ctx.jpg_mono)
{
j = (xs2 / 64) * (ys2 / 64);
for (i = 0; i < j; i++) ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, i * 4096), 0, 1);
}
else if (ctx.jpg_is420)
{
for (i = 0; i <= (ys3 / 64); i++)
for (j = 0; j < (xs3 / 64); j++)
{
ctx.block.EncodeMegaBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 0) * 4096), 0, 1);
ctx.block.EncodeMegaBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 1) * 4096), 0, 1);
ctx.block.EncodeMegaBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 0) * 4096), 0, 1);
ctx.block.EncodeMegaBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 1) * 4096), 0, 1);
k = i * (xs3 / 64) + j;
ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.udb, k * 4096), 2, 3);
ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.vdb, k * 4096), 2, 3);
if (ctx.jpg_yuvw)
{ ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.wdb, k * 4096), 2, 3); }
}
}
else
{
j = (xs2 / 64) * (ys2 / 64);
for (i = 0; i < j; i++)
{
ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, i * 4096), 0, 1);
ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.udb, i * 4096), 2, 3);
ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.vdb, i * 4096), 2, 3);
if (ctx.jpg_yuvw)
{ ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.wdb, i * 4096), 2, 3); }
}
}
ctx.huff.FlushBits(ctx);
if ((qfl & PDJPG_QFL_NOSOI) == 0)
{
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_EOI);
}
// printf("M3\n");
i = ctx.huff.ct - obuf;
return (i);
}
public static void PDJPG_FreeContext(PDJPG_Context ctx)
{
#if false
if(ctx.yb)
{
free(ctx.yb);
free(ctx.ub);
free(ctx.vb);
free(ctx.ydb);
free(ctx.udb);
free(ctx.vdb);
}
if(ctx.jpg_imgbuf)
free(ctx.jpg_imgbuf);
if(ctx.imgbuf_rgba)
free(ctx.imgbuf_rgba);
if(ctx.imgbuf_norm)
free(ctx.imgbuf_norm);
if(ctx.imgbuf_spec)
free(ctx.imgbuf_spec);
if(ctx.imgbuf_luma)
free(ctx.imgbuf_luma);
if(ctx.imgbuf_lebe)
free(ctx.imgbuf_lebe);
free(ctx);
#endif
}
public static void PDJPG_SetContextAlphaColor(PDJPG_Context ctx,
int cr, int cg, int cb, int ca)
{
int cy, cu, cv;
// if(!ctx)return;
if (ca < 1)
{
ctx.alphaClr = 0;
return;
}
ctx.alphaClr = cr + (cg << 8) + (cb << 16) + (ca << 24);
cy = 19595 * cr + 38470 * cg + 7471 * cb;
cu = -11056 * cr - 21712 * cg + 32768 * cb;
cv = 32768 * cr - 27440 * cg - 5328 * cb;
ctx.alphaClrY = (byte)(cy >> 16);
ctx.alphaClrU = (byte)((cu >> 16) + 128);
ctx.alphaClrV = (byte)((cv >> 16) + 128);
ctx.alphaClrA = (byte)ca;
}
public static void PDJPG_FlushEncodeFast(PDJPG_Context ctx)
{
// if(!ctx)return;
ctx.jpg_tabcacheframe = 0; //force rebuild
ctx.oldAlphaClr = 0;
}
//int PDJPG_FilterImageRDCT(BytePtr ibuf, short *obuf, int xs, int ys)
public static int PDJPG_FilterImageAuDCT(PDJPG_Context ctx, ShortPtr ibuf, ShortPtr obuf, IntPtr tagbuf,
int xs, int ys, int dcbias, int cn)
{
// static short tblk[DCTSZ2], tblk2[DCTSZ2];
// static char blk[DCTSZ2];
// short tblk[DCTSZ2], tblk2[DCTSZ2];
// char blk[DCTSZ2];
ShortPtr blk = new ShortPtr(DCTSZ2);
int i, j, k, tag;
k = 0;
for (i = 0; i < (ys / DCTSZ); i++)
for (j = 0; j < (xs / DCTSZ); j++)
{
// PDJPG_GetImgBlk(blk, j*DCTSZ, i*DCTSZ, ibuf, xs, ys);
PDJPG_GetImgBlk16(blk, j * DCTSZ, i * DCTSZ, ibuf, xs, ys);
PDJPG_TransAuDCT.TransBlock(ctx, blk, obuf + k * DCTSZ2, dcbias, (cn == 0) ? 0 : 1, out tag);
tagbuf[k] = tag;
k++;
}
return (0);
}
public static int PDJPG_EncodeLDatCtx(
PDJPG_Context ctx, byte[] ibuf, BytePtr obuf,
int xs, int ys, int qf, int pf)
{
BytePtr tbuf, cts;
int i, j, sz, tsz;
// if(!ctx)ctx=PDJPG_AllocContext();
tbuf = new BytePtr(1 << 20);
sz = PDJPG_EncodeCtx(ctx, ibuf, tbuf, xs, ys, qf, pf);
sz = PDJPG_EscapeEncodeSingleBuffer(tbuf, sz);
cts = tbuf; tsz = sz;
//ctx.huff.ct = obuf; ctx.huff.win = 0; ctx.huff.pos = 0;
ctx.huff.InitOutputStream(ctx, obuf);
while (tsz >= 65528)
{
i = 65529;
if (cts[i - 1] == 0xFF) i--;
j = i + 6;
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_APP12);
ctx.huff.ct.emit((j >> 8) & 0xFF);
ctx.huff.ct.emit(j & 0xFF);
ctx.huff.ct.emit('L');
ctx.huff.ct.emit('D');
ctx.huff.ct.emit('A');
ctx.huff.ct.emit('T');
BytePtr.memcpy(ctx.huff.ct, cts, i);
cts += i; ctx.huff.ct += i;
tsz -= i;
}
if ((tsz > 0) && (tsz < 65528))
{
i = tsz + 6;
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_APP12);
ctx.huff.ct.emit((i >> 8) & 0xFF);
ctx.huff.ct.emit(i & 0xFF);
ctx.huff.ct.emit('L');
ctx.huff.ct.emit('D');
ctx.huff.ct.emit('A');
ctx.huff.ct.emit('T');
BytePtr.memcpy(ctx.huff.ct, cts, tsz);
ctx.huff.ct += tsz;
}
sz = ctx.huff.ct - obuf;
//free(tbuf);
return (sz);
}
public static BytePtr PDJPG_EmitMarkerJFIF(PDJPG_Context ctx, BytePtr ct)
{
BytePtr ctt;
int i;
if (ctx.jpg_clrtrans != PDJPG_CLRS_YCBCR)
return (ct);
//ctx.huff.ct = ct; ctx.huff.win = 0; ctx.huff.pos = 0;
//ctx.huff.InitOutputStream(ctx, ct);
ct.emit(0xFF);
ct.emit(JPG.JPG_APP0);
ctt = ct;
ct.emit(0x00);
ct.emit(0x00);
ct.EmitString("JFIF");
//PDJPG_WriteString(ctx, "JFIF");
ct.emit(0x01); //version high
ct.emit(0x02); //version low
ct.emit(0x00); //no units
ct.emit(0x00); //X density
ct.emit(0x01);
ct.emit(0x00); //Y density
ct.emit(0x01);
ct.emit(0x00); //thumbnail
ct.emit(0x00);
// ctx.huff.WriteString(ctx, name);
i = ct - ctt;
ctt[0] = (i >> 8) & 0xFF; ctt[1] = i & 0xFF;
return (ct);
}
public static int PDJPG_EncodeFastCtx(PDJPG_Context ctx,
BytePtr ibuf, BytePtr obuf, int xs, int ys, int qf, int pf)
{
char[] tb = new char[256];
ShortPtr tp;
int xs2, ys2, xs3, ys3;
BytePtr ctt;
int i, j, k, l;
xs2 = ((xs + 7) / 8) * 8;
ys2 = ((ys + 7) / 8) * 8;
xs3 = ((xs + 15) / 16) * 8;
ys3 = ((ys + 15) / 16) * 8;
ctx.jpg_mono = ctx.huff.;
if (ctx.jpg_tabcacheframe == 0)
{
//full quality
for (i = 0; i < 64; i++) ctx.jpg_qt[0 * 64 + i] = 1;
for (i = 0; i < 64; i++) ctx.jpg_qt[1 * 64 + i] = 1;
}
if ((ctx.yb == null) || (xs != ctx.lxs) || (ys != ctx.lys))
{
#if false
if(ctx.yb)
{
free(ctx.yb);
free(ctx.ub);
free(ctx.vb);
free(ctx.ydb);
free(ctx.udb);
free(ctx.vdb);
}
#endif
ctx.yb = new short[xs2 * ys2];
ctx.ub = new short[xs2 * ys2];
ctx.vb = new short[xs2 * ys2];
ctx.ydb = new short[(xs2 + 8) * (ys2 + 16)];
ctx.udb = new short[(xs3 + 8) * (ys3 + 8)];
ctx.vdb = new short[(xs3 + 8) * (ys3 + 8)];
ctx.lxs = xs;
ctx.lys = ys;
ShortPtr.memset(ctx.yb, 128, xs2 * ys2);
ShortPtr.memset(ctx.ub, 128, xs2 * ys2);
ShortPtr.memset(ctx.vb, 128, xs2 * ys2);
ShortPtr.memset(ctx.ydb, 0, xs2 * (ys2 + 8));
ShortPtr.memset(ctx.udb, 0, xs3 * (ys3 + 8));
ShortPtr.memset(ctx.vdb, 0, xs3 * (ys3 + 8));
ctx.jpg_tabcacheframe = 0; //force rebuild
}
PDJPG_ConvertImageYUV(ctx,
ibuf, xs, ys, pf,
xs2, ys2, xs3, ys3);
PDJPG_FilterImageDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128);
PDJPG_FilterImageDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128);
PDJPG_FilterImageDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128);
if (ctx.jpg_tabcacheframe <= 0)
{
j = (xs2 / 8) * (ys2 / 8);
PDJPG_MakeQuantTabInputFast(ctx.ydb, j, new BytePtr(ctx.jpg_qt, 0 * 64), qf / 100.0);
j = (xs3 / 8) * (ys3 / 8);
PDJPG_MakeQuantTabInputFast(ctx.udb, j, new BytePtr(ctx.jpg_qt, 1 * 64), qf / 100.0);
PDJPG_MakeQuantTabInputFast(ctx.vdb, j, new BytePtr(ctx.jpg_qt, 2 * 64), qf / 100.0);
for (i = 0; i < 64; i++)
ctx.jpg_qt[1 * 64 + i] = (byte)((ctx.jpg_qt[1 * 64 + i] + ctx.jpg_qt[2 * 64 + i]) / 2);
PDJPG_SetupQuantTabDivFP(ctx, 0);
PDJPG_SetupQuantTabDivFP(ctx, 1);
}
if (ctx.jpg_mono)
{
j = (xs2 / 8) * (ys2 / 8); k = 0;
for (i = 0; i < j; i++)
{
ctx.huff.QuantBlock(ctx, new ShortPtr(ctx.ydb, i * 64), new ShortPtr(ctx.ydb, i * 64), 0);
ctx.ydb[i * 64 + 0] -= (short)k;
k = ctx.ydb[i * 64 + 0] + k;
}
}
if (!ctx.jpg_mono)
{
l = 0;
for (i = 0; i <= (ys3 / 8); i++)
for (j = 0; j < (xs3 / 8); j++)
{
tp = new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 8) + j * 2 + 0) * 64);
ctx.huff.QuantBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
tp = new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 8) + j * 2 + 1) * 64);
ctx.huff.QuantBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
tp = new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 8) + j * 2 + 0) * 64);
ctx.huff.QuantBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
tp = new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 8) + j * 2 + 1) * 64);
ctx.huff.QuantBlock(ctx, tp, tp, 0);
tp[0] -= l; l = tp[0] + l;
}
}
j = (xs3 / 8) * (ys3 / 8); k = 0; l = 0;
for (i = 0; i < j; i++)
{
ctx.huff.QuantBlock(ctx, new ShortPtr(ctx.udb, i * 64), new ShortPtr(ctx.udb, i * 64), 1);
ctx.huff.QuantBlock(ctx, new ShortPtr(ctx.vdb, i * 64), new ShortPtr(ctx.vdb, i * 64), 1);
ctx.udb[i * 64 + 0] -= (short)k; k = ctx.udb[i * 64 + 0] + k;
ctx.vdb[i * 64 + 0] -= (short)l; l = ctx.vdb[i * 64 + 0] + l;
}
// printf("M2\n");
if (ctx.jpg_tabcacheframe <= 0)
{
for (i = 0; i < 256; i++) ctx.dcs[i] = 1;
for (i = 0; i < 256; i++) ctx.acs[i] = 1;
for (i = 0; i < 256; i++) ctx.dcsuv[i] = 1;
for (i = 0; i < 256; i++) ctx.acsuv[i] = 1;
j = (xs2 / 8) * (ys2 / 8);
k = (xs3 / 8) * (ys3 / 8);
for (i = 0; i < j; i++)
ctx.huff.StatBlock(new ShortPtr(ctx.ydb, i * 64), new IntPtr(ctx.dcs), new IntPtr(ctx.acs));
for (i = 0; i < k; i++)
ctx.huff.StatBlock(new ShortPtr(ctx.udb, i * 64), new IntPtr(ctx.dcsuv), new IntPtr(ctx.acsuv));
for (i = 0; i < k; i++)
ctx.huff.StatBlock(new ShortPtr(ctx.vdb, i * 64), new IntPtr(ctx.dcsuv), new IntPtr(ctx.acsuv));
// ctx.huff.BuildLengths(ctx.dcs, 256, ctx.huff.len+0*256, 16);
// ctx.huff.BuildLengths(ctx.acs, 256, ctx.huff.len+1*256, 16);
// ctx.huff.BuildLengths(ctx.dcsuv, 256, ctx.huff.len+2*256, 16);
// ctx.huff.BuildLengths(ctx.acsuv, 256, ctx.huff.len+3*256, 16);
ctx.huff.BuildLengthsAdjust(
new IntPtr(ctx.dcs), 256, new BytePtr(ctx.huff.len, 0 * 256), 16);
ctx.huff.BuildLengthsAdjust(
new IntPtr(ctx.acs), 256, new BytePtr(ctx.huff.len, 1 * 256), 16);
ctx.huff.BuildLengthsAdjust(
new IntPtr(ctx.dcsuv), 256, new BytePtr(ctx.huff.len, 2 * 256), 16);
ctx.huff.BuildLengthsAdjust(
new IntPtr(ctx.acsuv), 256, new BytePtr(ctx.huff.len, 3 * 256), 16);
}
ctx.huff.ct = obuf;
ctx.huff.win = 0;
ctx.huff.pos = 0;
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_SOI);
if ((ctx.alphaClr != 0) && (ctx.alphaClr != ctx.oldAlphaClr))
{
// sprintf_s(tb, "%d %d %d %d",
// (ctx.alphaClr&0xFF),
// ((ctx.alphaClr>>8)&0xFF),
// ((ctx.alphaClr>>16)&0xFF),
// ((ctx.alphaClr>>24)&0xFF));
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_APP11);
ctt = ctx.huff.ct;
ctx.huff.ct.emit(0x00);
ctx.huff.ct.emit(0x00);
ctx.huff.WriteString(ctx, "AlphaColor");
// ctx.huff.WriteString(ctx, tb);
ctx.huff.WriteString(ctx, "");
i = (ctx.huff.ct - ctt);
ctt[0] = (i >> 8) & 0xFF; ctt[1] = i & 0xFF;
}
if (ctx.jpg_tabcacheframe <= 0)
{
PDJPG_EmitDQT(ctx, 0);
if (!ctx.jpg_mono) PDJPG_EmitDQT(ctx, 1);
}
PDJPG_EmitSOF(ctx, xs, ys);
// if(ctx.jpg_tabcacheframe<=0)
if (true)
{
ctx.huff.EmitDHT(ctx, 0);
ctx.huff.EmitDHT(ctx, 1);
if (!ctx.jpg_mono)
{
ctx.huff.EmitDHT(ctx, 2);
ctx.huff.EmitDHT(ctx, 3);
}
}
PDJPG_EmitSOS(ctx);
ctx.huff.win = 0;
ctx.huff.pos = 0;
if (ctx.jpg_mono)
{
j = (xs2 / 8) * (ys2 / 8);
for (i = 0; i < j; i++) ctx.huff.EncodeBlock(ctx, new ShortPtr(ctx.ydb, i * 64), 0, 1);
}
else
{
for (i = 0; i <= ((ys3) / 8); i++)
for (j = 0; j < (xs3 / 8); j++)
{
ctx.huff.EncodeBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 8) + j * 2 + 0) * 64), 0, 1);
ctx.huff.EncodeBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 8) + j * 2 + 1) * 64), 0, 1);
ctx.huff.EncodeBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 8) + j * 2 + 0) * 64), 0, 1);
ctx.huff.EncodeBlock(ctx,
new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 8) + j * 2 + 1) * 64), 0, 1);
k = i * (xs3 / 8) + j;
ctx.huff.EncodeBlock(ctx, new ShortPtr(ctx.udb, k * 64), 2, 3);
ctx.huff.EncodeBlock(ctx, new ShortPtr(ctx.vdb, k * 64), 2, 3);
}
}
ctx.huff.FlushBits(ctx);
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_EOI);
if (ctx.jpg_tabcacheframe <= 0)
{
// ctx.jpg_tabcacheframe=16;
ctx.jpg_tabcacheframe = 8;
}
else
{
ctx.jpg_tabcacheframe--;
}
// printf("M3\n");
i = ctx.huff.ct - obuf;
return (i);
}
public static void PDJPG_EmitSOF(PDJPG_Context ctx, int xs, int ys)
{
BytePtr p;
int i;
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_SOF0);
i = 8 + (ctx.jpg_mono ? 1 : 3) * 3;
p = ctx.huff.ct;
ctx.huff.ct.emit(i >> 8); //Lf
ctx.huff.ct.emit(i & 0xFF);
ctx.huff.ct.emit(8); //P
ctx.huff.ct.emit(ys >> 8); //Y
ctx.huff.ct.emit(ys & 0xFF); //Y
ctx.huff.ct.emit(xs >> 8); //X
ctx.huff.ct.emit(xs & 0xFF); //X
if (ctx.jpg_mono)
{
ctx.huff.ct.emit(1); //Nf
ctx.huff.ct.emit(1); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(0); //Tqi
}
else if (ctx.jpg_is420)
{
if (!ctx.jpg_yuvw)
{
//YUV 4:2:0
ctx.huff.ct.emit(3); //Nf
ctx.huff.ct.emit(1); //Ci
ctx.huff.ct.emit(0x22); //Hi Vi
ctx.huff.ct.emit(0); //Tqi
ctx.huff.ct.emit(2); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
ctx.huff.ct.emit(3); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
}
else
{
//YUVW 4:2:0
ctx.huff.ct.emit(4); //Nf
ctx.huff.ct.emit(1); //Ci
ctx.huff.ct.emit(0x22); //Hi Vi
ctx.huff.ct.emit(0); //Tqi
ctx.huff.ct.emit(2); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
ctx.huff.ct.emit(3); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
ctx.huff.ct.emit(4); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
}
}
else
{
if (!ctx.jpg_yuvw)
{
//YUV 4:4:4
ctx.huff.ct.emit(3); //Nf
ctx.huff.ct.emit(1); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(0); //Tqi
ctx.huff.ct.emit(2); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
ctx.huff.ct.emit(3); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
}
else
{
//YUVW 4:4:4
ctx.huff.ct.emit(4); //Nf
ctx.huff.ct.emit(1); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(0); //Tqi
ctx.huff.ct.emit(2); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
ctx.huff.ct.emit(3); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
ctx.huff.ct.emit(4); //Ci
ctx.huff.ct.emit(0x11); //Hi Vi
ctx.huff.ct.emit(1); //Tqi
}
}
i = ctx.huff.ct - p;
p[0] = i >> 8; //Lf
p[1] = i & 0xFF;
}
public static void PDJPG_EmitDQT(PDJPG_Context ctx, int n)
{
int i;
if (ctx.megablock)
{
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_DQT);
i = 128 + 3;
ctx.huff.ct.emit(i >> 8);
ctx.huff.ct.emit(i & 0xFF);
ctx.huff.ct.emit(n);
for (i = 0; i < 64; i++)
ctx.huff.ct.emit(ctx.jpg_qt[n * 256 + pdjpg_zigzag2[i]]);
for (i = 0; i < 64; i++)
ctx.huff.ct.emit(ctx.jpg_qt[n * 256 + 64 + pdjpg_zigzag2[i]]);
return;
}
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_DQT);
i = 64 + 3;
ctx.huff.ct.emit(i >> 8);
ctx.huff.ct.emit(i & 0xFF);
ctx.huff.ct.emit(n);
for (i = 0; i < 64; i++)
ctx.huff.ct.emit(ctx.jpg_qt[n * 64 + pdjpg_zigzag2[i]]);
}
public static BytePtr PDJPG_EmitTagLayer(PDJPG_Context ctx,
BytePtr ct, string name)
{
BytePtr ctt;
int i;
//ctx.huff.ct = ct; ctx.huff.win = 0; ctx.huff.pos = 0;
//ctx.huff.InitOutputStream(ctx, ct);
ct.emit(0xFF);
ct.emit(JPG.JPG_APP11);
ctt = ct;
ct.emit(0x00);
ct.emit(0x00);
ct.EmitString("TagLayer");
ct.EmitString(name);
i = ct - ctt;
ctt[0] = (i >> 8) & 0xFF; ctt[1] = i & 0xFF;
return (ct);
}
public static void PDJPG_EmitMarkerBCST(PDJPG_Context ctx)
{
BytePtr lfp;
int i;
if (ctx.jpg_rdct)
{
//Emit libjpeg SERM marker
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_APP9);
lfp = ctx.huff.ct;
ctx.huff.ct.emit(0x00); //length
ctx.huff.ct.emit(0x00);
ctx.huff.ct.emit('J');
ctx.huff.ct.emit('P');
ctx.huff.ct.emit('S');
ctx.huff.ct.emit('E');
ctx.huff.ct.emit('R');
ctx.huff.ct.emit('M');
ctx.huff.ct.emit(0);
i = ctx.huff.ct - lfp;
lfp[0] = i >> 8; //length
lfp[1] = i & 0xFF;
}
if (ctx.jpg_clrtrans == PDJPG_CLRS_RGB)
{
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_APP14);
lfp = ctx.huff.ct;
ctx.huff.ct.emit(0x00); //length
ctx.huff.ct.emit(0x00);
ctx.huff.ct.emit('A');
ctx.huff.ct.emit('d');
ctx.huff.ct.emit('o');
ctx.huff.ct.emit('b');
ctx.huff.ct.emit('e');
i = 100;
ctx.huff.ct.emit((i >> 8) & 0xFF);
ctx.huff.ct.emit(i & 0xFF);
i = 0;
ctx.huff.ct.emit((i >> 24) & 0xFF);
ctx.huff.ct.emit((i >> 16) & 0xFF);
ctx.huff.ct.emit((i >> 8) & 0xFF);
ctx.huff.ct.emit(i & 0xFF);
ctx.huff.ct.emit(0); //RGB
// ctx.huff.ct.emit(ctx.bcst_bpp);
i = ctx.huff.ct - lfp;
lfp[0] = i >> 8; //length
lfp[1] = i & 0xFF;
}
ctx.bcst_version = 0x0101;
ctx.bcst_flags = 0;
ctx.bcst_trans = ctx.jpg_clrtrans;
ctx.bcst_bpp = 8;
if (ctx.jpg_rdct)
ctx.bcst_flags |= PDJPG_BCSFL_RDCT;
if (ctx.layer_hidden)
ctx.bcst_flags |= PDJPG_BCSFL_LAYER_HIDDEN;
if (ctx.megablock)
ctx.bcst_flags |= PDJPG_BCSFL_MEGABLOCK;
if (ctx.altvlc)
ctx.bcst_flags |= PDJPG_BCSFL_ALTVLC;
if((ctx.jpg_qfl&PDJPG_QFL_ALPHACYAN)!=0)
ctx.bcst_flags |= PDJPG_BCSFL_ALPHACYAN;
if (ctx.rangecoder)
ctx.bcst_flags |= PDJPG_BCSFL_RANGECODER;
if (ctx.auto_dct)
ctx.bcst_flags |= PDJPG_BCSFL_AUTODCT;
//check if not to bother with marker...
if ((ctx.bcst_flags == 0) && (ctx.bcst_trans == 0))
{
// printf("PDJPG_EmitMarkerBCST: No Emit\n");
return;
}
// printf("PDJPG_EmitMarkerBCST: Emit\n");
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_APP12);
lfp = ctx.huff.ct;
ctx.huff.ct.emit(0x00); //length
ctx.huff.ct.emit(0x00);
ctx.huff.ct.emit('B');
ctx.huff.ct.emit('C');
ctx.huff.ct.emit('S');
ctx.huff.ct.emit('T');
ctx.huff.ct.emit((ctx.bcst_version >> 8) & 0xFF);
ctx.huff.ct.emit(ctx.bcst_version & 0xFF);
ctx.huff.ct.emit(ctx.bcst_trans);
ctx.huff.ct.emit(ctx.bcst_bpp);
ctx.huff.ct.emit((byte)(ctx.bcst_flags >> 24) & 0xFF);
ctx.huff.ct.emit((byte)(ctx.bcst_flags >> 16) & 0xFF);
ctx.huff.ct.emit((byte)(ctx.bcst_flags >> 8) & 0xFF);
ctx.huff.ct.emit((byte)ctx.bcst_flags & 0xFF);
ctx.huff.ct.emit(ctx.bcst_alpha);
ctx.huff.ct.emit(ctx.bcst_blend);
ctx.huff.ct.emit((ctx.bcst_orgx >> 8) & 0xFF);
ctx.huff.ct.emit(ctx.bcst_orgx & 0xFF);
ctx.huff.ct.emit((ctx.bcst_orgy >> 8) & 0xFF);
ctx.huff.ct.emit(ctx.bcst_orgy & 0xFF);
ctx.huff.ct.EmitWord16BE(ctx.bcst_minx);
ctx.huff.ct.EmitWord16BE(ctx.bcst_miny);
ctx.huff.ct.EmitWord16BE(ctx.bcst_maxx);
ctx.huff.ct.EmitWord16BE(ctx.bcst_maxy);
i = ctx.huff.ct - lfp;
lfp[0] = i >> 8; //length
lfp[1] = i & 0xFF;
}
public static BytePtr PDJPG_EncodeBeginLayeredCtx(
PDJPG_Context ctx, BytePtr ct, int xs, int ys, int qf)
{
ct.emit(0xFF);
ct.emit(JPG.JPG_SOI);
ct = PDJPG_EmitMarkerJFIF(ctx, ct);
return ct;
}
public static PDJPG_Context PDJPG_AllocContext()
{
PDJPG_Context ctx;
PDJPG_Init();
ctx = new PDJPG_Context();
//ctx.huff = new PDJHUFF(ctx);
ctx.block = new BTJBlock();
ctx.jpg_qt = new byte[4 * 256]; //quantization tables
ctx.jpg_qtfp = new int[4 * 256]; //quantization tables (fixed point)
ctx.jpg_cid = new byte[16];
ctx.jpg_ch = new byte[16];
ctx.jpg_cv = new byte[16];
ctx.jpg_qid = new byte[16];
ctx.jpg_cxi = new int[16];
ctx.jpg_cyi = new int[16];
ctx.jpg_scid = new int[4];
ctx.jpg_scn = new int[4];
ctx.jpg_scbuf = new ShortPtr[4];
ctx.jpg_sibuf = new ShortPtr[4];
ctx.jpg_stbuf = new IntPtr[4];
ctx.cstb = new int[4];
ctx.jpg_schs = new int[4]; //scan horizontal size
ctx.jpg_scvs = new int[4]; //scan vertical size
ctx.jpg_schsci = new int[4]; //scan horizontal scale
ctx.jpg_scvsci = new int[4]; //scan vertical scale
ctx.dcs = new int[256];
ctx.acs = new int[256];
ctx.dcsuv = new int[256];
ctx.acsuv = new int[256];
return (ctx);
}
public static int PDJPG_EncodeComponentCtxI(PDJPG_Context ctx,
byte[] rgba, byte[] norm, byte[] spec, byte[] luma, byte[] lebe,
BytePtr obuf, int xs, int ys, int qf)
{
int i;
BytePtr ct;
ct = obuf;
ct = PDJPG_EncodeBeginLayeredCtx(ctx, ct, xs, ys, qf);
i = PDJPG_EncodeComponentCtxI2(ctx, rgba, norm, spec, luma, lebe, ct, xs, ys, qf, null, null);
ct += i;
ct = PDJPG_EncodeEndLayeredCtx(ctx, ct);
//free(tbuf);
return (ct - obuf);
}
public static void PDJPG_EncodeCtx_Prepare(
PDJPG_Context ctx, int xs, int ys, int qfl, int pf)
{
int xs2, ys2, xs3, ys3;
// int cr, cg, cb, cy, cu, cv;
int i, qf;
qf = qfl & 255;
ctx.jpg_qfl = qfl;
ctx.layer_hidden = false;
if ((qfl & PDJPG_QFL_LAYER_HIDDEN) != 0)
ctx.layer_hidden = true;
ctx.megablock = false;
if ((qfl & PDJPG_QFL_MEGABLOCK) != 0)
ctx.megablock = true;
ctx.altvlc = false;
if ((qfl & PDJPG_QFL_ALTVLC) != 0)
ctx.altvlc = true;
ctx.rangecoder = false;
if ((qfl & PDJPG_QFL_RANGECODER) != 0)
ctx.rangecoder = true;
ctx.auto_dct = false;
if ((qfl & PDJPG_QFL_AUTODCT) != 0)
ctx.auto_dct = true;
if (ctx.megablock)
ctx.altvlc = true;
if (ctx.auto_dct)
ctx.altvlc = true;
ctx.jpg_is420 = true;
if ((qf == 110) || (qf == 111) || ((qfl & PDJPG_QFL_444) != 0) ||
(qf == 102) || (qf == 103))
ctx.jpg_is420 = false;
ctx.jpg_noquant = false;
if (qf >= 100)
ctx.jpg_noquant = true;
//combination not allowed
//if (ctx.auto_dct && (qf < 100))
//ctx.auto_dct = false;
// ctx.jpg_is444=ctx.huff.;
if (ctx.megablock)
{
if (ctx.jpg_is420)
{
xs2 = ((xs + 63) / 64) * 64;
ys2 = ((ys + 63) / 64) * 64;
// xs3=(xs2+1)/2;
// ys3=(ys2+1)/2;
xs3 = ((xs + 127) / 64) * 64;
ys3 = ((ys + 127) / 64) * 64;
ctx.jpg_is444 = false;
}
else
{
xs2 = ((xs + 63) / 64) * 64;
ys2 = ((ys + 63) / 64) * 64;
xs3 = xs2;
ys3 = ys2;
ctx.jpg_is444 = true;
}
}
else
{
if (ctx.jpg_is420)
{
xs2 = ((xs + 7) / 8) * 8;
ys2 = ((ys + 7) / 8) * 8;
// xs3=(xs2+1)/2;
// ys3=(ys2+1)/2;
xs3 = ((xs + 15) / 16) * 8;
ys3 = ((ys + 15) / 16) * 8;
ctx.jpg_is444 = false;
}
else
{
xs2 = ((xs + 7) / 8) * 8;
ys2 = ((ys + 7) / 8) * 8;
xs3 = xs2;
ys3 = ys2;
ctx.jpg_is444 = true;
}
}
ctx.xs = xs;
ctx.ys = ys;
ctx.xs2 = xs2;
ctx.ys2 = ys2;
ctx.xs3 = xs3;
ctx.ys3 = ys3;
ctx.jpg_mono = false;
ctx.jpg_yuvw = false;
ctx.jpg_tabcacheframe = 0;
ctx.xs = xs;
ctx.ys = ys;
if (pf == PDJPG_YYYA)
ctx.jpg_mono = true;
ctx.jpg_rdct = false;
if ((qf == 110) || (qf == 111) || ((qfl & PDJPG_QFL_RDCT) != 0))
ctx.jpg_rdct = true;
ctx.jpg_clrtrans = 0;
if ((qf == 110) || ((qfl & PDJPG_QFL_ORCT) != 0) || (qf == 101) || (qf == 103))
ctx.jpg_clrtrans = PDJPG_CLRS_ORCT;
if ((qf == 111) || ((qfl & PDJPG_QFL_RGB) != 0) || (qf == 104))
ctx.jpg_clrtrans = PDJPG_CLRS_RGB;
//full quality
for (i = 0; i < 64; i++) ctx.jpg_qt[0 * 64 + i] = 1;
for (i = 0; i < 64; i++) ctx.jpg_qt[1 * 64 + i] = 1;
if (ctx.rangecoder)
{
ctx.huff = new BTJRange(ctx);
ctx.huff.SetDefaults();
}else
{
ctx.huff = new PDJHUFF(ctx);
ctx.huff.SetDefaults();
}
// for(i=0; i<255; i++)ctx.huff.len[0*256+i]=8;
// for(i=0; i<255; i++)ctx.huff.len[2*256+i]=8;
// ctx.huff.len[1*256+0]=7;
// printf("M0\n");
//make sure intermediate buffers are present and the correct size
if ((ctx.yb == null) || (xs != ctx.lxs) || (ys != ctx.lys))
{
#if false
if(ctx.yb)
{
free(ctx.yb);
free(ctx.ub);
free(ctx.vb);
free(ctx.ydb);
free(ctx.udb);
free(ctx.vdb);
}
//W channel is rare, and so is handled specially
if(ctx.wb)
{
free(ctx.wb);
free(ctx.wdb);
}
#endif
// ctx.yb=malloc(xs2*ys2);
// ctx.ub=malloc(xs2*ys2);
// ctx.vb=malloc(xs2*ys2);
ctx.yb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.ub = new short[(xs2 + 16) * (ys2 + 16)];
ctx.vb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.ydb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.udb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.vdb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.ydtb = new int[((xs2 + 16) * (ys2 + 16))/64];
ctx.udtb = new int[((xs2 + 16) * (ys2 + 16))/64];
ctx.vdtb = new int[((xs2 + 16) * (ys2 + 16))/64];
if (ctx.jpg_yuvw)
{
ctx.wb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.wdb = new short[(xs2 + 16) * (ys2 + 16)];
ctx.wdtb = new int[((xs2 + 16) * (ys2 + 16)) / 64];
}
ctx.lxs = xs;
ctx.lys = ys;
}
// memset(ctx.yb, 128, xs2*ys2);
// memset(ctx.ub, 128, xs2*ys2);
// memset(ctx.vb, 128, xs2*ys2);
ShortPtr.memset(ctx.yb, 128, xs2 * ys2);
ShortPtr.memset(ctx.ub, 128, xs2 * ys2);
ShortPtr.memset(ctx.vb, 128, xs2 * ys2);
ShortPtr.memset(ctx.ydb, 0, xs2 * (ys2 + 8));
ShortPtr.memset(ctx.udb, 0, xs3 * (ys3 + 8));
ShortPtr.memset(ctx.vdb, 0, xs3 * (ys3 + 8));
if (ctx.jpg_yuvw)
{
ShortPtr.memset(ctx.wb, 128, xs2 * ys2);
ShortPtr.memset(ctx.wdb, 0, xs2 * (ys2 + 8));
}
}
public static void PDJPG_EmitMarkerDMLT(PDJPG_Context ctx)
{
BytePtr lfp;
int i;
ctx.huff.ct.emit(0xFF);
ctx.huff.ct.emit(JPG.JPG_JPG12);
lfp = ctx.huff.ct;
ctx.huff.ct.emit(0x00); //length
ctx.huff.ct.emit(0x00);
ctx.huff.ct.emit('D');
ctx.huff.ct.emit('M');
ctx.huff.ct.emit('L');
ctx.huff.ct.emit('T');
PDJPG_EmitMarkerDMLT_DQT(ctx, 0);
if (!ctx.jpg_mono) PDJPG_EmitMarkerDMLT_DQT(ctx, 1);
PDJPG_EmitMarkerDMLT_DHT(ctx, 0);
PDJPG_EmitMarkerDMLT_DHT(ctx, 1);
if (!ctx.jpg_mono)
{
PDJPG_EmitMarkerDMLT_DHT(ctx, 2);
PDJPG_EmitMarkerDMLT_DHT(ctx, 3);
}
i = ctx.huff.ct - lfp;
lfp[0] = i >> 8; //length
lfp[1] = i & 0xFF;
//PDJPG_EmitDQT(ctx, 0);
//if (!ctx.jpg_mono) PDJPG_EmitDQT(ctx, 1);
//PDJPG_EmitSOF(ctx, xs, ys);
//ctx.huff.EmitDHT(ctx, 0);
//ctx.huff.EmitDHT(ctx, 1);
//if (!ctx.jpg_mono)
//{
//ctx.huff.EmitDHT(ctx, 2);
//ctx.huff.EmitDHT(ctx, 3);
//}
PDJPG_EmitSOF(ctx, ctx.xs, ctx.ys);
}
public static BytePtr PDJPG_EncodeEndLayeredCtx(
PDJPG_Context ctx, BytePtr ct)
{
ct.emit(0xFF);
ct.emit(JPG.JPG_EOI);
return ct;
}
public static void PDJPG_SetupQuantTabDivFP(PDJPG_Context ctx, int qid)
{
int i;
if (ctx.megablock)
{
for (i = 0; i < 128; i++)
ctx.jpg_qtfp[qid * 256 + i] = (int)(4096.0 / ctx.jpg_qt[qid * 256 + i]);
}
else
{
for (i = 0; i < 64; i++)
ctx.jpg_qtfp[qid * 64 + i] = (int)(4096.0 / ctx.jpg_qt[qid * 64 + i]);
}
}
public static void PDJPG_EmitMarkerDMLT_DHT(PDJPG_Context ctx, int tab)
{
BytePtr tbuf, ct1;
int i;
tbuf = new BytePtr(65536);
ct1 = ctx.huff.EmitMiniHufftabBuf(ctx, tbuf, tab);
i = ct1 - tbuf;
ctx.huff.ct.emit(PDJPG_DMLT_DHT0 + tab);
ctx.huff.ct.EmitUVLI((ulong)i);
BytePtr.memcpy(ctx.huff.ct, tbuf, i);
ctx.huff.ct += i;
}
