public static void TransBlock2(ShortPtr iblk, ShortPtr oblk, int dcbias, int tag, int quant)
{
switch (tag&255)
{
case 0:
PDJPG_TransRDCT.TransBlock(iblk, oblk, dcbias);
break;
case 1:
PDJPG_TransAuDCT.TransBlock_Left(iblk, oblk, dcbias, quant);
break;
case 2:
PDJPG_TransAuDCT.TransBlock_Up(iblk, oblk, dcbias, quant);
break;
case 3:
PDJPG_TransAuDCT.TransBlock_Avg(iblk, oblk, dcbias, quant);
break;
case 4:
PDJPG_TransAuDCT.TransBlock_Paeth(iblk, oblk, dcbias, quant);
break;
case 5:
PDJPG_TransAuDCT.TransBlock_Linear(iblk, oblk, dcbias, quant);
break;
case 6:
PDJPG_TransAuDCT.TransBlock_None(iblk, oblk, dcbias, quant);
break;
default:
break;
}
}
// void PDJPG_TransDCT(byte *iblk, short *oblk)
public static void TransBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
IntPtr s = new IntPtr(PDJPG.DCTSZ2);
IntPtr t = new IntPtr(PDJPG.DCTSZ2);
int i, j;
PDJPG_TransDCT_Horiz(iblk + 0, s + 0, dcbias);
PDJPG_TransDCT_Horiz(iblk + 8, s + 8, dcbias);
PDJPG_TransDCT_Horiz(iblk + 16, s + 16, dcbias);
PDJPG_TransDCT_Horiz(iblk + 24, s + 24, dcbias);
PDJPG_TransDCT_Horiz(iblk + 32, s + 32, dcbias);
PDJPG_TransDCT_Horiz(iblk + 40, s + 40, dcbias);
PDJPG_TransDCT_Horiz(iblk + 48, s + 48, dcbias);
PDJPG_TransDCT_Horiz(iblk + 56, s + 56, dcbias);
PDJPG_TransDCT_Vert(s + 0, t + 0);
PDJPG_TransDCT_Vert(s + 1, t + 1);
PDJPG_TransDCT_Vert(s + 2, t + 2);
PDJPG_TransDCT_Vert(s + 3, t + 3);
PDJPG_TransDCT_Vert(s + 4, t + 4);
PDJPG_TransDCT_Vert(s + 5, t + 5);
PDJPG_TransDCT_Vert(s + 6, t + 6);
PDJPG_TransDCT_Vert(s + 7, t + 7);
for (i = 0; i < 64; i++)
{
j = t[i] >> 16;
if (((short)j)!=j)
throw new Exception();
oblk[i] = j;
//oblk[i] = t[i] >> 16;
}
}
// void PDJPG_TransDCT_Horiz(byte *iblk, int *oblk)
public static void PDJPG_TransDCT_Horiz(ShortPtr iblk, IntPtr oblk, int dcbias)
{
int[] ib = new int[8];
// ib[0]=iblk[0]-128; ib[1]=iblk[1]-128;
// ib[2]=iblk[2]-128; ib[3]=iblk[3]-128;
// ib[4]=iblk[4]-128; ib[5]=iblk[5]-128;
// ib[6]=iblk[6]-128; ib[7]=iblk[7]-128;
ib[0] = iblk[0] - dcbias; ib[1] = iblk[1] - dcbias;
ib[2] = iblk[2] - dcbias; ib[3] = iblk[3] - dcbias;
ib[4] = iblk[4] - dcbias; ib[5] = iblk[5] - dcbias;
ib[6] = iblk[6] - dcbias; ib[7] = iblk[7] - dcbias;
oblk[0] = ib[0] * 91 + ib[1] * 91 + ib[2] * 91 + ib[3] * 91
+ ib[4] * 91 + ib[5] * 91 + ib[6] * 91 + ib[7] * 91;
oblk[1] = ib[0] * 126 + ib[1] * 106 + ib[2] * 71 + ib[3] * 25
- ib[4] * 25 - ib[5] * 71 - ib[6] * 106 - ib[7] * 126;
oblk[2] = ib[0] * 118 + ib[1] * 49 - ib[2] * 49 - ib[3] * 118
- ib[4] * 118 - ib[5] * 49 + ib[6] * 49 + ib[7] * 118;
oblk[3] = ib[0] * 106 - ib[1] * 25 - ib[2] * 126 - ib[3] * 71
+ ib[4] * 71 + ib[5] * 126 + ib[6] * 25 - ib[7] * 106;
oblk[4] = ib[0] * 91 - ib[1] * 91 - ib[2] * 91 + ib[3] * 91
+ ib[4] * 91 - ib[5] * 91 - ib[6] * 91 + ib[7] * 91;
oblk[5] = ib[0] * 71 - ib[1] * 126 + ib[2] * 25 + ib[3] * 106
- ib[4] * 106 - ib[5] * 25 + ib[6] * 126 - ib[7] * 71;
oblk[6] = ib[0] * 49 - ib[1] * 118 + ib[2] * 118 - ib[3] * 49
- ib[4] * 49 + ib[5] * 118 - ib[6] * 118 + ib[7] * 49;
oblk[7] = ib[0] * 25 - ib[1] * 71 + ib[2] * 106 - ib[3] * 126
+ ib[4] * 126 - ib[5] * 106 + ib[6] * 71 - ib[7] * 25;
}
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);
}
// void PDJPG_TransRDCT(byte *iblk, short *oblk)
public static void TransBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
// IntPtr s = new IntPtr(PDJPG.DCTSZ2);
// IntPtr t = new IntPtr(PDJPG.DCTSZ2);
int s00, s01, s02, s03, s04, s05, s06, s07;
int s10, s11, s12, s13, s14, s15, s16, s17;
int s20, s21, s22, s23, s24, s25, s26, s27;
int s30, s31, s32, s33, s34, s35, s36, s37;
int s40, s41, s42, s43, s44, s45, s46, s47;
int s50, s51, s52, s53, s54, s55, s56, s57;
int s60, s61, s62, s63, s64, s65, s66, s67;
int s70, s71, s72, s73, s74, s75, s76, s77;
int t00, t01, t02, t03, t04, t05, t06, t07;
int t10, t11, t12, t13, t14, t15, t16, t17;
int t20, t21, t22, t23, t24, t25, t26, t27;
int t30, t31, t32, t33, t34, t35, t36, t37;
int t40, t41, t42, t43, t44, t45, t46, t47;
int t50, t51, t52, t53, t54, t55, t56, t57;
int t60, t61, t62, t63, t64, t65, t66, t67;
int t70, t71, t72, t73, t74, t75, t76, t77;
int i;
PDJPG_TransRDCT_Ref(
iblk[0] - dcbias, iblk[1] - dcbias, iblk[2] - dcbias, iblk[3] - dcbias,
iblk[4] - dcbias, iblk[5] - dcbias, iblk[6] - dcbias, iblk[7] - dcbias,
out s00, out s01, out s02, out s03, out s04, out s05, out s06, out s07);
PDJPG_TransRDCT_Ref(
iblk[8] - dcbias, iblk[9] - dcbias, iblk[10] - dcbias, iblk[11] - dcbias,
iblk[12] - dcbias, iblk[13] - dcbias, iblk[14] - dcbias, iblk[15] - dcbias,
out s10, out s11, out s12, out s13, out s14, out s15, out s16, out s17);
PDJPG_TransRDCT_Ref(
iblk[16] - dcbias, iblk[17] - dcbias, iblk[18] - dcbias, iblk[19] - dcbias,
iblk[20] - dcbias, iblk[21] - dcbias, iblk[22] - dcbias, iblk[23] - dcbias,
out s20, out s21, out s22, out s23, out s24, out s25, out s26, out s27);
PDJPG_TransRDCT_Ref(
iblk[24] - dcbias, iblk[25] - dcbias, iblk[26] - dcbias, iblk[27] - dcbias,
iblk[28] - dcbias, iblk[29] - dcbias, iblk[30] - dcbias, iblk[31] - dcbias,
out s30, out s31, out s32, out s33, out s34, out s35, out s36, out s37);
PDJPG_TransRDCT_Ref(
iblk[32] - dcbias, iblk[33] - dcbias, iblk[34] - dcbias, iblk[35] - dcbias,
iblk[36] - dcbias, iblk[37] - dcbias, iblk[38] - dcbias, iblk[39] - dcbias,
out s40, out s41, out s42, out s43, out s44, out s45, out s46, out s47);
PDJPG_TransRDCT_Ref(
iblk[40] - dcbias, iblk[41] - dcbias, iblk[42] - dcbias, iblk[43] - dcbias,
iblk[44] - dcbias, iblk[45] - dcbias, iblk[46] - dcbias, iblk[47] - dcbias,
out s50, out s51, out s52, out s53, out s54, out s55, out s56, out s57);
PDJPG_TransRDCT_Ref(
iblk[48] - dcbias, iblk[49] - dcbias, iblk[50] - dcbias, iblk[51] - dcbias,
iblk[52] - dcbias, iblk[53] - dcbias, iblk[54] - dcbias, iblk[55] - dcbias,
out s60, out s61, out s62, out s63, out s64, out s65, out s66, out s67);
PDJPG_TransRDCT_Ref(
iblk[56] - dcbias, iblk[57] - dcbias, iblk[58] - dcbias, iblk[59] - dcbias,
iblk[60] - dcbias, iblk[61] - dcbias, iblk[62] - dcbias, iblk[63] - dcbias,
out s70, out s71, out s72, out s73, out s74, out s75, out s76, out s77);
PDJPG_TransRDCT_Ref(s00, s10, s20, s30, s40, s50, s60, s70,
out t00, out t10, out t20, out t30, out t40, out t50, out t60, out t70);
PDJPG_TransRDCT_Ref(s01, s11, s21, s31, s41, s51, s61, s71,
out t01, out t11, out t21, out t31, out t41, out t51, out t61, out t71);
PDJPG_TransRDCT_Ref(s02, s12, s22, s32, s42, s52, s62, s72,
out t02, out t12, out t22, out t32, out t42, out t52, out t62, out t72);
PDJPG_TransRDCT_Ref(s03, s13, s23, s33, s43, s53, s63, s73,
out t03, out t13, out t23, out t33, out t43, out t53, out t63, out t73);
PDJPG_TransRDCT_Ref(s04, s14, s24, s34, s44, s54, s64, s74,
out t04, out t14, out t24, out t34, out t44, out t54, out t64, out t74);
PDJPG_TransRDCT_Ref(s05, s15, s25, s35, s45, s55, s65, s75,
out t05, out t15, out t25, out t35, out t45, out t55, out t65, out t75);
PDJPG_TransRDCT_Ref(s06, s16, s26, s36, s46, s56, s66, s76,
out t06, out t16, out t26, out t36, out t46, out t56, out t66, out t76);
PDJPG_TransRDCT_Ref(s07, s17, s27, s37, s47, s57, s67, s77,
out t07, out t17, out t27, out t37, out t47, out t57, out t67, out t77);
oblk[0] = t00; oblk[1] = t01; oblk[2] = t02; oblk[3] = t03;
oblk[4] = t04; oblk[5] = t05; oblk[6] = t06; oblk[7] = t07;
oblk[8] = t10; oblk[9] = t11; oblk[10] = t12; oblk[11] = t13;
oblk[12] = t14; oblk[13] = t15; oblk[14] = t16; oblk[15] = t17;
oblk[16] = t20; oblk[17] = t21; oblk[18] = t22; oblk[19] = t23;
oblk[20] = t24; oblk[21] = t25; oblk[22] = t26; oblk[23] = t27;
oblk[24] = t30; oblk[25] = t31; oblk[26] = t32; oblk[27] = t33;
oblk[28] = t34; oblk[29] = t35; oblk[30] = t36; oblk[31] = t37;
oblk[32] = t40; oblk[33] = t41; oblk[34] = t42; oblk[35] = t43;
oblk[36] = t44; oblk[37] = t45; oblk[38] = t46; oblk[39] = t47;
oblk[40] = t50; oblk[41] = t51; oblk[42] = t52; oblk[43] = t53;
oblk[44] = t54; oblk[45] = t55; oblk[46] = t56; oblk[47] = t57;
oblk[48] = t60; oblk[49] = t61; oblk[50] = t62; oblk[51] = t63;
oblk[52] = t64; oblk[53] = t65; oblk[54] = t66; oblk[55] = t67;
oblk[56] = t70; oblk[57] = t71; oblk[58] = t72; oblk[59] = t73;
oblk[60] = t74; oblk[61] = t75; oblk[62] = t76; oblk[63] = t77;
#if false
PDJPG_TransRDCT_Horiz(iblk + 0, s + 0, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 8, s + 8, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 16, s + 16, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 24, s + 24, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 32, s + 32, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 40, s + 40, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 48, s + 48, dcbias);
PDJPG_TransRDCT_Horiz(iblk + 56, s + 56, dcbias);
PDJPG_TransRDCT_Vert(s + 0, t + 0);
PDJPG_TransRDCT_Vert(s + 1, t + 1);
PDJPG_TransRDCT_Vert(s + 2, t + 2);
PDJPG_TransRDCT_Vert(s + 3, t + 3);
PDJPG_TransRDCT_Vert(s + 4, t + 4);
PDJPG_TransRDCT_Vert(s + 5, t + 5);
PDJPG_TransRDCT_Vert(s + 6, t + 6);
PDJPG_TransRDCT_Vert(s + 7, t + 7);
for (i = 0; i < 64; i++)
oblk[i] = t[i];
#endif
}
public static void TransMegaBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
IntPtr s = new IntPtr(PDJPG.DCTSZ2 * PDJPG.DCTSZ2);
IntPtr t = new IntPtr(PDJPG.DCTSZ2 * PDJPG.DCTSZ2);
int i, j;
for (i = 0; i < 4096; i++)
{
s[i] = iblk[i];
}
#if true
TransIRDCT_Step(s + 0 * 64, s + 0 * 64, 512);
TransIRDCT_Step(s + 1 * 64, s + 1 * 64, 512);
TransIRDCT_Step(s + 2 * 64, s + 2 * 64, 512);
TransIRDCT_Step(s + 3 * 64, s + 3 * 64, 512);
TransIRDCT_Step(s + 4 * 64, s + 4 * 64, 512);
TransIRDCT_Step(s + 5 * 64, s + 5 * 64, 512);
TransIRDCT_Step(s + 6 * 64, s + 6 * 64, 512);
TransIRDCT_Step(s + 7 * 64, s + 7 * 64, 512);
TransIRDCT_Step(s + 0 * 512, s + 0 * 512, 64);
TransIRDCT_Step(s + 1 * 512, s + 1 * 512, 64);
TransIRDCT_Step(s + 2 * 512, s + 2 * 512, 64);
TransIRDCT_Step(s + 3 * 512, s + 3 * 512, 64);
TransIRDCT_Step(s + 4 * 512, s + 4 * 512, 64);
TransIRDCT_Step(s + 5 * 512, s + 5 * 512, 64);
TransIRDCT_Step(s + 6 * 512, s + 6 * 512, 64);
TransIRDCT_Step(s + 7 * 512, s + 7 * 512, 64);
#endif
#if true
for (i = 0; i < 64; i++)
{
TransBasicBlock(s + (i * 64), s + (i * 64));
}
#endif
#if false
for (i = 0; i < 64; i++)
{
TransIRDCT_Step(s + 0 * 64 + i, s + 0 * 64 + i, 512);
TransIRDCT_Step(s + 1 * 64 + i, s + 1 * 64 + i, 512);
TransIRDCT_Step(s + 2 * 64 + i, s + 2 * 64 + i, 512);
TransIRDCT_Step(s + 3 * 64 + i, s + 3 * 64 + i, 512);
TransIRDCT_Step(s + 4 * 64 + i, s + 4 * 64 + i, 512);
TransIRDCT_Step(s + 5 * 64 + i, s + 5 * 64 + i, 512);
TransIRDCT_Step(s + 6 * 64 + i, s + 6 * 64 + i, 512);
TransIRDCT_Step(s + 7 * 64 + i, s + 7 * 64 + i, 512);
TransIRDCT_Step(s + 0 * 512 + i, s + 0 * 512 + i, 64);
TransIRDCT_Step(s + 1 * 512 + i, s + 1 * 512 + i, 64);
TransIRDCT_Step(s + 2 * 512 + i, s + 2 * 512 + i, 64);
TransIRDCT_Step(s + 3 * 512 + i, s + 3 * 512 + i, 64);
TransIRDCT_Step(s + 4 * 512 + i, s + 4 * 512 + i, 64);
TransIRDCT_Step(s + 5 * 512 + i, s + 5 * 512 + i, 64);
TransIRDCT_Step(s + 6 * 512 + i, s + 6 * 512 + i, 64);
TransIRDCT_Step(s + 7 * 512 + i, s + 7 * 512 + i, 64);
}
#endif
for (i = 0; i < 4096; i++)
{
j = (s[i]) + dcbias;
// if(j&(~255))j=(j<0)?0:((j>255)?255:j);
oblk[i] = j;
}
}
public static void TransIDCT16(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
IntPtr s = new IntPtr(PDJPG.DCTSZ2);
IntPtr t = new IntPtr(PDJPG.DCTSZ2);
int i, j;
TransIDCT_Horiz(iblk + 0, s + 0);
TransIDCT_Horiz(iblk + 8, s + 8);
TransIDCT_Horiz(iblk + 16, s + 16);
TransIDCT_Horiz(iblk + 24, s + 24);
TransIDCT_Horiz(iblk + 32, s + 32);
TransIDCT_Horiz(iblk + 40, s + 40);
TransIDCT_Horiz(iblk + 48, s + 48);
TransIDCT_Horiz(iblk + 56, s + 56);
for (i = 0; i < PDJPG.DCTSZ2; i++)
s[i] >>= 4;
TransIDCT_Vert(s + 0, t + 0);
TransIDCT_Vert(s + 1, t + 1);
TransIDCT_Vert(s + 2, t + 2);
TransIDCT_Vert(s + 3, t + 3);
TransIDCT_Vert(s + 4, t + 4);
TransIDCT_Vert(s + 5, t + 5);
TransIDCT_Vert(s + 6, t + 6);
TransIDCT_Vert(s + 7, t + 7);
for (i = 0; i < 64; i++)
{
j = (t[i] >> 12) + dcbias;
// if(j&(~255))j=(j<0)?0:((j>255)?255:j);
oblk[i] = j;
}
}
public static void TransBlock_Paeth(ShortPtr iblk, ShortPtr oblk, int dcbias, int quant)
{
int a, b, c;
int i, j, k, l;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
a = (j > 0) ? oblk[(i - 0) * 8 + (j - 1)] : dcbias;
b = (i > 0) ? oblk[(i - 1) * 8 + (j - 0)] : dcbias;
c = ((i > 0) && (j > 0)) ? oblk[(i - 1) * 8 + (j - 1)] : dcbias;
l = Paeth(a, b, c);
k = iblk[i * 8 + j];
oblk[i * 8 + j] = (k * quant) + l;
}
}
}
public static void TransBlock_Linear(ShortPtr iblk, ShortPtr oblk, int dcbias, int quant)
{
int a, b, c;
int i, j, k, l;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
a = (j > 0) ? oblk[(i - 0) * 8 + (j - 1)] : dcbias;
b = (i > 0) ? oblk[(i - 1) * 8 + (j - 0)] : dcbias;
c = ((i > 0) && (j > 0)) ? oblk[(i - 1) * 8 + (j - 1)] : dcbias;
l = a + b - c;
k = iblk[i * 8 + j] * quant;
oblk[i * 8 + j] = k + l;
}
}
}
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);
}
//int PDJPG_FilterImageRDCT(BytePtr ibuf, short *obuf, int xs, int ys)
public static int PDJPG_FilterImageMegablockRDCT(ShortPtr ibuf, ShortPtr obuf,
int xs, int ys, int dcbias)
{
// static short tblk[DCTSZ2], tblk2[DCTSZ2];
// static char blk[DCTSZ2];
// short tblk[DCTSZ2], tblk2[DCTSZ2];
// char blk[DCTSZ2];
ShortPtr blk = new ShortPtr(DCTSZ4);
int i, j, k;
k = 0;
for (i = 0; i < (ys / DCTSZ2); i++)
for (j = 0; j < (xs / DCTSZ2); j++)
{
// PDJPG_GetImgBlk(blk, j*DCTSZ, i*DCTSZ, ibuf, xs, ys);
PDJPG_GetImgMegaBlk16(blk, j * DCTSZ2, i * DCTSZ2, ibuf, xs, ys);
PDJPG_TransRDCT.TransMegaBlock(blk, obuf + k * DCTSZ4, dcbias);
k++;
}
return (0);
}
public static void PDJPG_GetImgMegaBlk16(
ShortPtr blk, int xo, int yo,
ShortPtr img, int xs, int ys)
{
int i, j;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
PDJPG_GetImgBlk16(blk + ((i * 8 + j) * 64), xo + j * 8, yo + i * 8, img, xs, ys);
}
}
}
public static int PDJPG_GetImgBlk16(
ShortPtr blk, int xo, int yo,
ShortPtr img, int xs, int ys)
{
ShortPtr cs;
ShortPtr ct;
cs = img + (yo * xs + xo); ct = blk;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs); ct += 8; cs += xs;
ShortPtr.memcpy16(ct, cs);
return (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 void PDJPG_EncodeCtx_ColorTransform16(
PDJPG_Context ctx, ShortPtr ibuf, int xs, int ys, int pf)
{
int xs2, ys2, xs3, ys3;
int cr, cg, cb, ca, cy, cu, cv, cw;
int i, j, k;
xs2 = ctx.xs2;
ys2 = ctx.ys2;
xs3 = ctx.xs3;
ys3 = ctx.ys3;
for (i = 0; i < ys; i++)
for (j = 0; j < xs; j++)
{
k = ys - (i + 1);
cr = ibuf[(k * xs + j) * 4 + 0];
cg = ibuf[(k * xs + j) * 4 + 1];
cb = ibuf[(k * xs + j) * 4 + 2];
ca = ibuf[(k * xs + j) * 4 + 3];
// if(qf==110)
if (ctx.jpg_clrtrans == PDJPG_CLRS_YCBCR)
{
cy = (int)(0.299 * cr + 0.587 * cg + 0.114 * cb);
cu = (int)(-0.1687 * cr - 0.3313 * cg + 0.5 * cb + 128);
cv = (int)(0.5 * cr - 0.4187 * cg - 0.0813 * cb + 128);
cw = ca;
}
else if (ctx.jpg_clrtrans == PDJPG_CLRS_ORCT)
{
// cy=(cr+2*cg+cb)/4;
cy = cg + (cb + cr - 2 * cg) / 4;
cu = (cb - cg) + 128;
cv = (cr - cg) + 128;
cw = ca;
}
else if (ctx.jpg_clrtrans == PDJPG_CLRS_RGB)
{
cy = cr; cu = cg; cv = cb; cw = ca;
}
else
{
cy = (int)(0.299 * cr + 0.587 * cg + 0.114 * cb);
cu = (int)(-0.1687 * cr - 0.3313 * cg + 0.5 * cb + 128);
cv = (int)(0.5 * cr - 0.4187 * cg - 0.0813 * cb + 128);
cw = ca;
}
// cu=128; cv=128;
// cy=(cy<0)?0:((cy>255)?255:cy);
// cu=(cu<0)?0:((cu>255)?255:cu);
// cv=(cv<0)?0:((cv>255)?255:cv);
ctx.yb[i * xs2 + j] = (short)cy;
ctx.ub[i * xs2 + j] = (short)cu;
ctx.vb[i * xs2 + j] = (short)cv;
if (ctx.jpg_yuvw)
ctx.wb[i * xs2 + j] = (short)cw;
}
}
// void TransRDCT(byte *iblk, short *oblk)
public static void TransBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
IntPtr s = new IntPtr(PDJPG.DCTSZ2);
IntPtr t = new IntPtr(PDJPG.DCTSZ2);
int i;
TransRDCT_Horiz(iblk + 0, s + 0, dcbias);
TransRDCT_Horiz(iblk + 8, s + 8, dcbias);
TransRDCT_Horiz(iblk + 16, s + 16, dcbias);
TransRDCT_Horiz(iblk + 24, s + 24, dcbias);
TransRDCT_Horiz(iblk + 32, s + 32, dcbias);
TransRDCT_Horiz(iblk + 40, s + 40, dcbias);
TransRDCT_Horiz(iblk + 48, s + 48, dcbias);
TransRDCT_Horiz(iblk + 56, s + 56, dcbias);
TransRDCT_Vert(s + 0, t + 0);
TransRDCT_Vert(s + 1, t + 1);
TransRDCT_Vert(s + 2, t + 2);
TransRDCT_Vert(s + 3, t + 3);
TransRDCT_Vert(s + 4, t + 4);
TransRDCT_Vert(s + 5, t + 5);
TransRDCT_Vert(s + 6, t + 6);
TransRDCT_Vert(s + 7, t + 7);
for (i = 0; i < 64; i++)
oblk[i] = t[i];
}
public static void TransBlock_Up(ShortPtr iblk, ShortPtr oblk, int dcbias, int quant)
{
int i, j, k, l;
for (i = 0; i < 8; i++)
{
l = dcbias;
for (j = 0; j < 8; j++)
{
k = iblk[j * 8 + i];
k = (k - l + (quant / 2)) / quant;
oblk[i * 8 + j] = k;
l = l + (k * quant);
}
}
}
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 TransBlock(ShortPtr iblk, ShortPtr oblk, int dcbias, int tag)
{
int quant;
//if (tag != 0)
//Console.Write("{0} ", tag);
quant = ((tag >> 8) & 255) + 1;
//quant = 1;
switch (tag & 255)
{
case 0:
PDJPG_TransIRDCT.TransBlock(iblk, oblk, dcbias);
break;
case 1:
PDJPG_TransAuIDCT.TransBlock_Left(iblk, oblk, dcbias, quant);
break;
case 2:
PDJPG_TransAuIDCT.TransBlock_Up(iblk, oblk, dcbias, quant);
break;
case 3:
PDJPG_TransAuIDCT.TransBlock_Avg(iblk, oblk, dcbias, quant);
break;
case 4:
PDJPG_TransAuIDCT.TransBlock_Paeth(iblk, oblk, dcbias, quant);
break;
case 5:
PDJPG_TransAuIDCT.TransBlock_Linear(iblk, oblk, dcbias, quant);
break;
case 6:
PDJPG_TransAuIDCT.TransBlock_None(iblk, oblk, dcbias, quant);
break;
default:
break;
}
}
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 void TransBlock_None(ShortPtr iblk, ShortPtr oblk, int dcbias, int quant)
{
int i, j, k, l;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
k = iblk[i * 8 + j] * quant;
oblk[i * 8 + j] = k + dcbias;
}
}
}
public static void TransRDCT_Horiz(ShortPtr iblk, IntPtr oblk)
{
PDJPG_TransRDCT_Ref(
iblk[0], iblk[1], iblk[2], iblk[3],
iblk[4], iblk[5], iblk[6], iblk[7],
out oblk[0], out oblk[1], out oblk[2], out oblk[3],
out oblk[4], out oblk[5], out oblk[6], out oblk[7]);
}
public static void TransBlock_Up(ShortPtr iblk, ShortPtr oblk, int dcbias, int quant)
{
int i, j, k, l;
for (i = 0; i < 8; i++)
{
l = dcbias;
for (j = 0; j < 8; j++)
{
k = iblk[j * 8 + i] * quant;
oblk[j * 8 + i] = k + l;
l += k;
}
}
}
// void TransRDCT(byte *iblk, short *oblk)
public static void TransBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
int s00, s01, s02, s03, s04, s05, s06, s07;
int s10, s11, s12, s13, s14, s15, s16, s17;
int s20, s21, s22, s23, s24, s25, s26, s27;
int s30, s31, s32, s33, s34, s35, s36, s37;
int s40, s41, s42, s43, s44, s45, s46, s47;
int s50, s51, s52, s53, s54, s55, s56, s57;
int s60, s61, s62, s63, s64, s65, s66, s67;
int s70, s71, s72, s73, s74, s75, s76, s77;
int t00, t01, t02, t03, t04, t05, t06, t07;
int t10, t11, t12, t13, t14, t15, t16, t17;
int t20, t21, t22, t23, t24, t25, t26, t27;
int t30, t31, t32, t33, t34, t35, t36, t37;
int t40, t41, t42, t43, t44, t45, t46, t47;
int t50, t51, t52, t53, t54, t55, t56, t57;
int t60, t61, t62, t63, t64, t65, t66, t67;
int t70, t71, t72, t73, t74, t75, t76, t77;
//int i;
TransRDCT_Ref(
iblk[0] - dcbias, iblk[1] - dcbias,
iblk[2] - dcbias, iblk[3] - dcbias,
iblk[4] - dcbias, iblk[5] - dcbias,
iblk[6] - dcbias, iblk[7] - dcbias,
out s00, out s01, out s02, out s03,
out s04, out s05, out s06, out s07);
TransRDCT_Ref(
iblk[8] - dcbias, iblk[9] - dcbias,
iblk[10] - dcbias, iblk[11] - dcbias,
iblk[12] - dcbias, iblk[13] - dcbias,
iblk[14] - dcbias, iblk[15] - dcbias,
out s10, out s11, out s12, out s13,
out s14, out s15, out s16, out s17);
TransRDCT_Ref(
iblk[16] - dcbias, iblk[17] - dcbias,
iblk[18] - dcbias, iblk[19] - dcbias,
iblk[20] - dcbias, iblk[21] - dcbias,
iblk[22] - dcbias, iblk[23] - dcbias,
out s20, out s21, out s22, out s23,
out s24, out s25, out s26, out s27);
TransRDCT_Ref(
iblk[24] - dcbias, iblk[25] - dcbias,
iblk[26] - dcbias, iblk[27] - dcbias,
iblk[28] - dcbias, iblk[29] - dcbias,
iblk[30] - dcbias, iblk[31] - dcbias,
out s30, out s31, out s32, out s33,
out s34, out s35, out s36, out s37);
TransRDCT_Ref(
iblk[32] - dcbias, iblk[33] - dcbias,
iblk[34] - dcbias, iblk[35] - dcbias,
iblk[36] - dcbias, iblk[37] - dcbias,
iblk[38] - dcbias, iblk[39] - dcbias,
out s40, out s41, out s42, out s43,
out s44, out s45, out s46, out s47);
TransRDCT_Ref(
iblk[40] - dcbias, iblk[41] - dcbias,
iblk[42] - dcbias, iblk[43] - dcbias,
iblk[44] - dcbias, iblk[45] - dcbias,
iblk[46] - dcbias, iblk[47] - dcbias,
out s50, out s51, out s52, out s53,
out s54, out s55, out s56, out s57);
TransRDCT_Ref(
iblk[48] - dcbias, iblk[49] - dcbias,
iblk[50] - dcbias, iblk[51] - dcbias,
iblk[52] - dcbias, iblk[53] - dcbias,
iblk[54] - dcbias, iblk[55] - dcbias,
out s60, out s61, out s62, out s63,
out s64, out s65, out s66, out s67);
TransRDCT_Ref(
iblk[56] - dcbias, iblk[57] - dcbias,
iblk[58] - dcbias, iblk[59] - dcbias,
iblk[60] - dcbias, iblk[61] - dcbias,
iblk[62] - dcbias, iblk[63] - dcbias,
out s70, out s71, out s72, out s73,
out s74, out s75, out s76, out s77);
TransRDCT_Ref(s00, s10, s20, s30, s40, s50, s60, s70,
out t00, out t10, out t20, out t30,
out t40, out t50, out t60, out t70);
TransRDCT_Ref(s01, s11, s21, s31, s41, s51, s61, s71,
out t01, out t11, out t21, out t31,
out t41, out t51, out t61, out t71);
TransRDCT_Ref(s02, s12, s22, s32, s42, s52, s62, s72,
out t02, out t12, out t22, out t32,
out t42, out t52, out t62, out t72);
TransRDCT_Ref(s03, s13, s23, s33, s43, s53, s63, s73,
out t03, out t13, out t23, out t33,
out t43, out t53, out t63, out t73);
TransRDCT_Ref(s04, s14, s24, s34, s44, s54, s64, s74,
out t04, out t14, out t24, out t34,
out t44, out t54, out t64, out t74);
TransRDCT_Ref(s05, s15, s25, s35, s45, s55, s65, s75,
out t05, out t15, out t25, out t35,
out t45, out t55, out t65, out t75);
TransRDCT_Ref(s06, s16, s26, s36, s46, s56, s66, s76,
out t06, out t16, out t26, out t36,
out t46, out t56, out t66, out t76);
TransRDCT_Ref(s07, s17, s27, s37, s47, s57, s67, s77,
out t07, out t17, out t27, out t37,
out t47, out t57, out t67, out t77);
oblk[0] = t00; oblk[1] = t01; oblk[2] = t02; oblk[3] = t03;
oblk[4] = t04; oblk[5] = t05; oblk[6] = t06; oblk[7] = t07;
oblk[8] = t10; oblk[9] = t11; oblk[10] = t12; oblk[11] = t13;
oblk[12] = t14; oblk[13] = t15; oblk[14] = t16; oblk[15] = t17;
oblk[16] = t20; oblk[17] = t21; oblk[18] = t22; oblk[19] = t23;
oblk[20] = t24; oblk[21] = t25; oblk[22] = t26; oblk[23] = t27;
oblk[24] = t30; oblk[25] = t31; oblk[26] = t32; oblk[27] = t33;
oblk[28] = t34; oblk[29] = t35; oblk[30] = t36; oblk[31] = t37;
oblk[32] = t40; oblk[33] = t41; oblk[34] = t42; oblk[35] = t43;
oblk[36] = t44; oblk[37] = t45; oblk[38] = t46; oblk[39] = t47;
oblk[40] = t50; oblk[41] = t51; oblk[42] = t52; oblk[43] = t53;
oblk[44] = t54; oblk[45] = t55; oblk[46] = t56; oblk[47] = t57;
oblk[48] = t60; oblk[49] = t61; oblk[50] = t62; oblk[51] = t63;
oblk[52] = t64; oblk[53] = t65; oblk[54] = t66; oblk[55] = t67;
oblk[56] = t70; oblk[57] = t71; oblk[58] = t72; oblk[59] = t73;
oblk[60] = t74; oblk[61] = t75; oblk[62] = t76; oblk[63] = t77;
}
public static void TransIDCT_Horiz(ShortPtr iblk, IntPtr oblk)
{
int a, b, c, d, e, f;
int i, j, k, l;
int m, n, o, p;
a = iblk[0] * 91; b = iblk[4] * 91;
c = iblk[2] * 118; d = iblk[2] * 49;
e = iblk[6] * 118; f = iblk[6] * 49;
i = a + c + b + f; j = a + d - b - e; k = a - d - b + e; l = a - c + b - f;
m = iblk[1] * 126 + iblk[3] * 106 + iblk[5] * 71 + iblk[7] * 25;
n = iblk[1] * 106 - iblk[3] * 25 - iblk[5] * 126 - iblk[7] * 71;
o = iblk[1] * 71 - iblk[3] * 126 + iblk[5] * 25 + iblk[7] * 106;
p = iblk[1] * 25 - iblk[3] * 71 + iblk[5] * 106 - iblk[7] * 126;
oblk[0] = i + m; oblk[1] = j + n; oblk[2] = k + o; oblk[3] = l + p;
oblk[4] = l - p; oblk[5] = k - o; oblk[6] = j - n; oblk[7] = i - m;
}
public static void TransRDCT_Horiz(ShortPtr iblk, IntPtr oblk, int dcbias)
{
int ob0, ob1, ob2, ob3, ob4, ob5, ob6, ob7;
TransRDCT_Ref(
iblk[0] - dcbias, iblk[1] - dcbias, iblk[2] - dcbias, iblk[3] - dcbias,
iblk[4] - dcbias, iblk[5] - dcbias, iblk[6] - dcbias, iblk[7] - dcbias,
out ob0, out ob1, out ob2, out ob3,
out ob4, out ob5, out ob6, out ob7);
oblk[0] = ob0; oblk[1] = ob1;
oblk[2] = ob2; oblk[3] = ob3;
oblk[4] = ob4; oblk[5] = ob5;
oblk[6] = ob6; oblk[7] = ob7;
}
public static void TransBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
int s00, s01, s02, s03, s04, s05, s06, s07;
int s10, s11, s12, s13, s14, s15, s16, s17;
int s20, s21, s22, s23, s24, s25, s26, s27;
int s30, s31, s32, s33, s34, s35, s36, s37;
int s40, s41, s42, s43, s44, s45, s46, s47;
int s50, s51, s52, s53, s54, s55, s56, s57;
int s60, s61, s62, s63, s64, s65, s66, s67;
int s70, s71, s72, s73, s74, s75, s76, s77;
int t00, t01, t02, t03, t04, t05, t06, t07;
int t10, t11, t12, t13, t14, t15, t16, t17;
int t20, t21, t22, t23, t24, t25, t26, t27;
int t30, t31, t32, t33, t34, t35, t36, t37;
int t40, t41, t42, t43, t44, t45, t46, t47;
int t50, t51, t52, t53, t54, t55, t56, t57;
int t60, t61, t62, t63, t64, t65, t66, t67;
int t70, t71, t72, t73, t74, t75, t76, t77;
TransIRDCT_Ref(
iblk[0], iblk[8], iblk[16], iblk[24],
iblk[32], iblk[40], iblk[48], iblk[56],
out s00, out s10, out s20, out s30,
out s40, out s50, out s60, out s70);
TransIRDCT_Ref(
iblk[1], iblk[9], iblk[17], iblk[25],
iblk[33], iblk[41], iblk[49], iblk[57],
out s01, out s11, out s21, out s31,
out s41, out s51, out s61, out s71);
TransIRDCT_Ref(
iblk[2], iblk[10], iblk[18], iblk[26],
iblk[34], iblk[42], iblk[50], iblk[58],
out s02, out s12, out s22, out s32,
out s42, out s52, out s62, out s72);
TransIRDCT_Ref(
iblk[3], iblk[11], iblk[19], iblk[27],
iblk[35], iblk[43], iblk[51], iblk[59],
out s03, out s13, out s23, out s33,
out s43, out s53, out s63, out s73);
TransIRDCT_Ref(
iblk[4], iblk[12], iblk[20], iblk[28],
iblk[36], iblk[44], iblk[52], iblk[60],
out s04, out s14, out s24, out s34,
out s44, out s54, out s64, out s74);
TransIRDCT_Ref(
iblk[5], iblk[13], iblk[21], iblk[29],
iblk[37], iblk[45], iblk[53], iblk[61],
out s05, out s15, out s25, out s35,
out s45, out s55, out s65, out s75);
TransIRDCT_Ref(
iblk[6], iblk[14], iblk[22], iblk[30],
iblk[38], iblk[46], iblk[54], iblk[62],
out s06, out s16, out s26, out s36,
out s46, out s56, out s66, out s76);
TransIRDCT_Ref(
iblk[7], iblk[15], iblk[23], iblk[31],
iblk[39], iblk[47], iblk[55], iblk[63],
out s07, out s17, out s27, out s37,
out s47, out s57, out s67, out s77);
TransIRDCT_Ref(s00, s01, s02, s03, s04, s05, s06, s07,
out t00, out t01, out t02, out t03,
out t04, out t05, out t06, out t07);
TransIRDCT_Ref(s10, s11, s12, s13, s14, s15, s16, s17,
out t10, out t11, out t12, out t13,
out t14, out t15, out t16, out t17);
TransIRDCT_Ref(s20, s21, s22, s23, s24, s25, s26, s27,
out t20, out t21, out t22, out t23,
out t24, out t25, out t26, out t27);
TransIRDCT_Ref(s30, s31, s32, s33, s34, s35, s36, s37,
out t30, out t31, out t32, out t33,
out t34, out t35, out t36, out t37);
TransIRDCT_Ref(s40, s41, s42, s43, s44, s45, s46, s47,
out t40, out t41, out t42, out t43,
out t44, out t45, out t46, out t47);
TransIRDCT_Ref(s50, s51, s52, s53, s54, s55, s56, s57,
out t50, out t51, out t52, out t53,
out t54, out t55, out t56, out t57);
TransIRDCT_Ref(s60, s61, s62, s63, s64, s65, s66, s67,
out t60, out t61, out t62, out t63,
out t64, out t65, out t66, out t67);
TransIRDCT_Ref(s70, s71, s72, s73, s74, s75, s76, s77,
out t70, out t71, out t72, out t73,
out t74, out t75, out t76, out t77);
oblk[0] = t00 + dcbias; oblk[1] = t01 + dcbias;
oblk[2] = t02 + dcbias; oblk[3] = t03 + dcbias;
oblk[4] = t04 + dcbias; oblk[5] = t05 + dcbias;
oblk[6] = t06 + dcbias; oblk[7] = t07 + dcbias;
oblk[8] = t10 + dcbias; oblk[9] = t11 + dcbias;
oblk[10] = t12 + dcbias; oblk[11] = t13 + dcbias;
oblk[12] = t14 + dcbias; oblk[13] = t15 + dcbias;
oblk[14] = t16 + dcbias; oblk[15] = t17 + dcbias;
oblk[16] = t20 + dcbias; oblk[17] = t21 + dcbias;
oblk[18] = t22 + dcbias; oblk[19] = t23 + dcbias;
oblk[20] = t24 + dcbias; oblk[21] = t25 + dcbias;
oblk[22] = t26 + dcbias; oblk[23] = t27 + dcbias;
oblk[24] = t30 + dcbias; oblk[25] = t31 + dcbias;
oblk[26] = t32 + dcbias; oblk[27] = t33 + dcbias;
oblk[28] = t34 + dcbias; oblk[29] = t35 + dcbias;
oblk[30] = t36 + dcbias; oblk[31] = t37 + dcbias;
oblk[32] = t40 + dcbias; oblk[33] = t41 + dcbias;
oblk[34] = t42 + dcbias; oblk[35] = t43 + dcbias;
oblk[36] = t44 + dcbias; oblk[37] = t45 + dcbias;
oblk[38] = t46 + dcbias; oblk[39] = t47 + dcbias;
oblk[40] = t50 + dcbias; oblk[41] = t51 + dcbias;
oblk[42] = t52 + dcbias; oblk[43] = t53 + dcbias;
oblk[44] = t54 + dcbias; oblk[45] = t55 + dcbias;
oblk[46] = t56 + dcbias; oblk[47] = t57 + dcbias;
oblk[48] = t60 + dcbias; oblk[49] = t61 + dcbias;
oblk[50] = t62 + dcbias; oblk[51] = t63 + dcbias;
oblk[52] = t64 + dcbias; oblk[53] = t65 + dcbias;
oblk[54] = t66 + dcbias; oblk[55] = t67 + dcbias;
oblk[56] = t70 + dcbias; oblk[57] = t71 + dcbias;
oblk[58] = t72 + dcbias; oblk[59] = t73 + dcbias;
oblk[60] = t74 + dcbias; oblk[61] = t75 + dcbias;
oblk[62] = t76 + dcbias; oblk[63] = t77 + dcbias;
}
public static void TransMegaBlock(ShortPtr iblk, ShortPtr oblk, int dcbias)
{
IntPtr s = new IntPtr(PDJPG.DCTSZ2 * PDJPG.DCTSZ2);
IntPtr t = new IntPtr(PDJPG.DCTSZ2 * PDJPG.DCTSZ2);
int i;
for (i = 0; i < 64; i++)
{
TransBasicBlock(iblk + (i * 64), s + (i * 64), dcbias);
}
#if true
TransRDCT_Step(s + 0 * 512, s + 0 * 512, 64);
TransRDCT_Step(s + 1 * 512, s + 1 * 512, 64);
TransRDCT_Step(s + 2 * 512, s + 2 * 512, 64);
TransRDCT_Step(s + 3 * 512, s + 3 * 512, 64);
TransRDCT_Step(s + 4 * 512, s + 4 * 512, 64);
TransRDCT_Step(s + 5 * 512, s + 5 * 512, 64);
TransRDCT_Step(s + 6 * 512, s + 6 * 512, 64);
TransRDCT_Step(s + 7 * 512, s + 7 * 512, 64);
TransRDCT_Step(s + 0 * 64, s + 0 * 64, 512);
TransRDCT_Step(s + 1 * 64, s + 1 * 64, 512);
TransRDCT_Step(s + 2 * 64, s + 2 * 64, 512);
TransRDCT_Step(s + 3 * 64, s + 3 * 64, 512);
TransRDCT_Step(s + 4 * 64, s + 4 * 64, 512);
TransRDCT_Step(s + 5 * 64, s + 5 * 64, 512);
TransRDCT_Step(s + 6 * 64, s + 6 * 64, 512);
TransRDCT_Step(s + 7 * 64, s + 7 * 64, 512);
#endif
#if false
for (i = 0; i < 64; i++)
{
TransRDCT_Step(s + 0 * 512 + i, s + 0 * 512 + i, 64);
TransRDCT_Step(s + 1 * 512 + i, s + 1 * 512 + i, 64);
TransRDCT_Step(s + 2 * 512 + i, s + 2 * 512 + i, 64);
TransRDCT_Step(s + 3 * 512 + i, s + 3 * 512 + i, 64);
TransRDCT_Step(s + 4 * 512 + i, s + 4 * 512 + i, 64);
TransRDCT_Step(s + 5 * 512 + i, s + 5 * 512 + i, 64);
TransRDCT_Step(s + 6 * 512 + i, s + 6 * 512 + i, 64);
TransRDCT_Step(s + 7 * 512 + i, s + 7 * 512 + i, 64);
TransRDCT_Step(s + 0 * 64 + i, s + 0 * 64 + i, 512);
TransRDCT_Step(s + 1 * 64 + i, s + 1 * 64 + i, 512);
TransRDCT_Step(s + 2 * 64 + i, s + 2 * 64 + i, 512);
TransRDCT_Step(s + 3 * 64 + i, s + 3 * 64 + i, 512);
TransRDCT_Step(s + 4 * 64 + i, s + 4 * 64 + i, 512);
TransRDCT_Step(s + 5 * 64 + i, s + 5 * 64 + i, 512);
TransRDCT_Step(s + 6 * 64 + i, s + 6 * 64 + i, 512);
TransRDCT_Step(s + 7 * 64 + i, s + 7 * 64 + i, 512);
}
#endif
for (i = 0; i < 4096; i++)
{
oblk[i] = s[i];
}
}
public static void TransBlock_Avg(ShortPtr iblk, ShortPtr oblk, int dcbias, int quant)
{
short[] tblk = new short[64];
int a, b, c;
int i, j, k, l;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
//a = (j > 0) ? iblk[(i - 0) * 8 + (j - 1)] : dcbias;
//b = (i > 0) ? iblk[(i - 1) * 8 + (j - 0)] : dcbias;
// c = ((i > 0) && (j > 0)) ? iblk[(i - 1) * 8 + (j - 1)] : dcbias;
a = (j > 0) ? tblk[(i - 0) * 8 + (j - 1)] : dcbias;
b = (i > 0) ? tblk[(i - 1) * 8 + (j - 0)] : dcbias;
l = (a + b) / 2;
k = iblk[i * 8 + j];
k = (k - l + (quant / 2)) / quant;
oblk[i * 8 + j] = k;
l = l + (k * quant);
tblk[i * 8 + j] = (short)l;
}
}
}
// void TransRDCT_Horiz(byte *iblk, int *oblk)
public static void TransRDCT_Horiz(ShortPtr iblk, IntPtr oblk, int dcbias)
{
int[] ib = new int[8];
ib[0] = iblk[2] - dcbias; ib[1] = iblk[7] - dcbias;
ib[2] = iblk[4] - dcbias; ib[3] = iblk[3] - dcbias;
ib[4] = iblk[6] - dcbias; ib[5] = iblk[0] - dcbias;
ib[6] = iblk[1] - dcbias; ib[7] = iblk[5] - dcbias;
ib[7] = (-ib[7]) + FIX14TOI(
ib[0] * FLTOFIX14(1.1648) + ib[1] * FLTOFIX14(-2.8234) +
ib[2] * FLTOFIX14(0.5375) + ib[3] * FLTOFIX14(-0.6058) +
ib[4] * FLTOFIX14(1.2228) + ib[5] * FLTOFIX14(-0.3805) +
ib[6] * FLTOFIX14(0.0288));
ib[0] = ib[0] + FIX14TOI(
ib[1] * FLTOFIX14(-1.1129) + ib[2] * FLTOFIX14(0.0570) +
ib[3] * FLTOFIX14(-0.4712) + ib[4] * FLTOFIX14(0.1029) +
ib[5] * FLTOFIX14(0.0156) + ib[6] * FLTOFIX14(-0.4486) +
ib[7] * FLTOFIX14(-0.4619));
ib[1] = ib[1] + FIX14TOI(
ib[0] * FLTOFIX14(-0.0685) + ib[2] * FLTOFIX14(0.2708) +
ib[3] * FLTOFIX14(-0.2708) + ib[4] * FLTOFIX14(-0.2235) +
ib[5] * FLTOFIX14(0.2568) + ib[6] * FLTOFIX14(-0.3205) +
ib[7] * FLTOFIX14(0.3841));
ib[2] = ib[2] + FIX14TOI(
ib[0] * FLTOFIX14(-0.0364) + ib[1] * FLTOFIX14(-1.7104) +
ib[3] * FLTOFIX14(-1.0000) + ib[4] * FLTOFIX14(0.3066) +
ib[5] * FLTOFIX14(0.6671) + ib[6] * FLTOFIX14(-0.5953) +
ib[7] * FLTOFIX14(0.2039));
ib[3] = ib[3] + FIX14TOI(
ib[0] * FLTOFIX14(0.7957) + ib[1] * FLTOFIX14(0.9664) +
ib[2] * FLTOFIX14(0.4439) + ib[4] * FLTOFIX14(0.6173) +
ib[5] * FLTOFIX14(-0.1422) + ib[6] * FLTOFIX14(1.0378) +
ib[7] * FLTOFIX14(-0.1700));
ib[4] = ib[4] + FIX14TOI(
ib[0] * FLTOFIX14(0.4591) + ib[1] * FLTOFIX14(0.4108) +
ib[2] * FLTOFIX14(-0.2073) + ib[3] * FLTOFIX14(-1.0824) +
ib[5] * FLTOFIX14(0.7071) + ib[6] * FLTOFIX14(0.8873) +
ib[7] * FLTOFIX14(-0.2517));
ib[5] = ib[5] + FIX14TOI(
ib[0] * FLTOFIX14(-0.6573) + ib[1] * FLTOFIX14(0.5810) +
ib[2] * FLTOFIX14(-0.2931) + ib[3] * FLTOFIX14(-0.5307) +
ib[4] * FLTOFIX14(-0.8730) + ib[6] * FLTOFIX14(-0.1594) +
ib[7] * FLTOFIX14(-0.3560));
ib[6] = ib[6] + FIX14TOI(
ib[0] * FLTOFIX14(1.0024) + ib[1] * FLTOFIX14(-0.7180) +
ib[2] * FLTOFIX14(-0.0928) + ib[3] * FLTOFIX14(-0.0318) +
ib[4] * FLTOFIX14(0.4170) + ib[5] * FLTOFIX14(1.1665) +
ib[7] * FLTOFIX14(0.4904));
ib[7] = ib[7] + FIX14TOI(
ib[0] * FLTOFIX14(1.1020) + ib[1] * FLTOFIX14(-2.0306) +
ib[2] * FLTOFIX14(-0.3881) + ib[3] * FLTOFIX14(0.6561) +
ib[4] * FLTOFIX14(1.2405) + ib[5] * FLTOFIX14(1.6577) +
ib[6] * FLTOFIX14(-1.1914));
oblk[0] = ib[3]; oblk[1] = ib[6];
oblk[2] = ib[4]; oblk[3] = ib[2];
oblk[4] = ib[5]; oblk[5] = ib[7];
oblk[6] = ib[0]; oblk[7] = ib[1];
}
