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]; }