private static int do_protectedmain() { BytePtr code = null; int status; StkId oldCBase = CBase; jmp_buf myErrorJmp = new jmp_buf(); jmp_buf oldErr = errorJmp; errorJmp = myErrorJmp; try //if (setjmp(myErrorJmp) == 0) { Object_ f = new Object_(); lua_parse(ref code); tag(f, lua_Type.LUA_T_FUNCTION); bvalue(f, code); do_call(f, CBase, 0, CBase); status = 0; } catch (LongjmpException) { //else { status = 1; } if (code != null) { luaI_free_BytePtr(ref code); } errorJmp = oldErr; CBase = oldCBase; top = new ObjectRef(stack, CBase); return(status); }
public static BytePtr PDJPG_Decode(BytePtr buf, int sz, out int xs, out int ys) { PDJPG_Context ctx; BytePtr obuf; BytePtr otbuf, otbuf2; BytePtr csl; int i, n, sz1; ctx = PDJPG_AllocContext(); obuf = PDJPG_DecodeCtx(ctx, buf, sz, out xs, out ys); // ctx.jpg_imgbuf=null; csl = PDJPG_DecodeScanForComponentLayer(buf, sz, "Alpha"); if (!csl.isNull) { sz1 = sz - ((BytePtr)csl - buf); otbuf = (BytePtr)PDJPG_DecodeLDatCtx(ctx, (BytePtr)csl, sz1, out xs, out ys); otbuf2 = (BytePtr)obuf; n = ctx.xs * ctx.ys; for (i = 0; i < n; i++) { otbuf2[i * 4 + 3] = otbuf[i * 4 + 1]; } } PDJPG_FreeContext(ctx); return (obuf); }
public static BytePtr memcpy(BytePtr ptr1, BytePtr ptr2, uint size) { for (int i = 0; i < size; i++) { ptr1[i] = ptr2[i]; } return(ptr1); }
public void set(Value v) { this.f = v.f; this.n = v.n; this.s = v.s; this.b = v.b; this.a = v.a; this.u = v.u; this.__name__ = v.__name__; }
public void set(YYSTYPE s) { this.vInt = s.vInt; this.vLong = s.vLong; this.vFloat = s.vFloat; this.vWord = s.vWord; if (s.pByte != null) { this.pByte = new BytePtr(s.pByte); } else { this.pByte = null; } }
public static BytePtr realloc_BytePtr(BytePtr obj, uint size) { byte[] ret = new byte[size]; for (int i = 0; i < size; ++i) { if (i < obj.chars.Length) { ret[i] = obj[i]; } else { ret[i] = (Byte)0; } } if (obj.index != 0) { throw new Exception("realloc_BytePtr not zero index"); } return(new BytePtr(ret, obj.index)); }
protected void LoadDocumentLayer(Document doc, BytePtr ibuf, int sz, string name) { BitmapLayer layer; Bitmap bmp; PDJPG_LayerInfo linf; byte[] rgba; byte[] norm; byte[] spec; byte[] luma; int xs, ys, ox, oy, ln, fl; // int i, j; rgba = new byte[4096 * 4096 * 4]; norm = new byte[4096 * 4096 * 4]; spec = new byte[4096 * 4096 * 4]; luma = new byte[4096 * 4096 * 4]; PDJPG.PDJPG_DecodeComponent(ibuf, sz, rgba, norm, spec, luma, out xs, out ys, out linf); fl = linf.flags; //PDJPG_DecodeHasComponent() ln = doc.Layers.Count; //doc.Layers.Insert(ln, null); if (true) { //layer = new BitmapLayer(xs, ys); layer = new BitmapLayer(doc.Width, doc.Height); layer.Name = name; layer.Opacity = linf.alpha; layer.Visible = true; if((fl&PDJPG.PDJPG_BCSFL_LAYER_HIDDEN)!=0) layer.Visible = false; if ((fl & PDJPG.PDJPG_BCSFL_ALPHACYAN) != 0) { BlendByteBufferInverseTransparentColor(rgba, xs, ys); } //bmp = BitmapFromByteBuffer(rgba, xs, ys); bmp = BitmapFromByteBuffer(rgba, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy); layer.Surface.CopyFromGdipBitmap(bmp, false); doc.Layers.Insert(ln++, layer); } if (PDJPG.PDJPG_DecodeHasComponent(ibuf, sz, "XYZ")) { //layer = new BitmapLayer(xs, ys); layer = new BitmapLayer(doc.Width, doc.Height); layer.Name = name + "::Normal"; layer.Opacity = linf.alpha; layer.Visible = false; //bmp = BitmapFromByteBufferRGB(norm, xs, ys); bmp = BitmapFromByteBufferRGB(norm, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy); layer.Surface.CopyFromGdipBitmap(bmp, false); doc.Layers.Insert(ln++, layer); } if (PDJPG.PDJPG_DecodeHasComponent(ibuf, sz, "SpRGB")) { //layer = new BitmapLayer(xs, ys); layer = new BitmapLayer(doc.Width, doc.Height); layer.Name = name + "::Specular"; layer.Opacity = linf.alpha; layer.Visible = false; //bmp = BitmapFromByteBufferRGB(spec, xs, ys); bmp = BitmapFromByteBufferRGB(spec, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy); layer.Surface.CopyFromGdipBitmap(bmp, false); doc.Layers.Insert(ln++, layer); } if (PDJPG.PDJPG_DecodeHasComponent(ibuf, sz, "LuRGB")) { //layer = new BitmapLayer(xs, ys); layer = new BitmapLayer(doc.Width, doc.Height); layer.Name = name + "::Luma"; layer.Opacity = linf.alpha; layer.Visible = false; //bmp = BitmapFromByteBufferRGB(luma, xs, ys); bmp = BitmapFromByteBufferRGB(luma, xs, ys, doc.Width, doc.Height, linf.orgx, linf.orgy); layer.Surface.CopyFromGdipBitmap(bmp, false); doc.Layers.Insert(ln++, layer); } }
public static BytePtr PDJPG_EncodeEndLayeredCtx( PDJPG_Context ctx, BytePtr ct) { ct.emit(0xFF); ct.emit(JPG.JPG_EOI); return ct; }
public static int PDJPG_EncodeComponentCtx( PDJPG_Context ctx, byte[] rgba, byte[] norm, byte[] spec, byte[] luma, BytePtr obuf, int xs, int ys, int qf) { return (PDJPG_EncodeComponentCtxI(ctx, rgba, norm, spec, luma, null, obuf, xs, ys, qf)); }
public static int PDJPG_EncodeComponentCtxI2( PDJPG_Context ctx, byte[] rgba, byte[] norm, byte[] spec, byte[] luma, byte[] lebe, BytePtr obuf, int xs, int ys, int qf, string tlname, PDJPG_LayerInfo linf) { byte[] tbuf; BytePtr ct; int i, j, k, n; if (rgba == null) return (-1); if (linf != null) { ctx.bcst_orgx = linf.orgx; ctx.bcst_orgy = linf.orgy; ctx.bcst_alpha = linf.alpha; ctx.bcst_blend = linf.blend; ctx.bcst_flags = (uint)linf.flags; ctx.bcst_minx = linf.minx; ctx.bcst_miny = linf.miny; ctx.bcst_maxx = linf.maxx; ctx.bcst_maxy = linf.maxy; } else { ctx.bcst_orgx = 0; ctx.bcst_orgy = 0; ctx.bcst_alpha = 255; ctx.bcst_blend = 0; ctx.bcst_flags = 0; ctx.bcst_minx = 0; ctx.bcst_miny = 0; ctx.bcst_maxx = 0; ctx.bcst_maxy = 0; } n = xs * ys; tbuf = new byte[xs * ys * 4]; ct = obuf; //ct.emit(0xFF); //ct.emit(JPG.JPG_SOI); //ct = PDJPG_EmitMarkerJFIF(ctx, ct); if (tlname != null) { ct = PDJPG_EmitTagLayer(ctx, ct, tlname); ct = PDJPG_EmitComponentLayer(ctx, ct, "RGB"); i = PDJPG_EncodeLDatCtx(ctx, rgba, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } else { ct = PDJPG_EmitComponentLayer(ctx, ct, "RGB"); // i=PDJPG_EncodeCtx(ctx, rgba, ct, xs, ys, qf, 0); i = PDJPG_EncodeBaseCtx(ctx, rgba, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } // if((ct[-2]==0xFF) && (ct[-2]==JPG_EOI)) // { ct-=2; } if (norm != null) { for (i = 0; i < n; i++) { tbuf[i * 4 + 0] = norm[i * 4 + 0]; tbuf[i * 4 + 1] = norm[i * 4 + 2]; tbuf[i * 4 + 2] = norm[i * 4 + 1]; tbuf[i * 4 + 3] = 255; } ct = PDJPG_EmitComponentLayer(ctx, ct, "XYZ"); i = PDJPG_EncodeLDatCtx(ctx, tbuf, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } if (spec != null) { ct = PDJPG_EmitComponentLayer(ctx, ct, "SpRGB"); i = PDJPG_EncodeLDatCtx(ctx, spec, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } if ((norm != null) || (spec != null)) { for (i = 0; i < n; i++) { j = rgba[i * 4 + 3]; tbuf[i * 4 + 0] = (byte)((norm != null) ? norm[i * 4 + 3] : j); tbuf[i * 4 + 1] = rgba[i * 4 + 3]; tbuf[i * 4 + 2] = (byte)((spec != null) ? spec[i * 4 + 3] : j); tbuf[i * 4 + 3] = 255; } ct = PDJPG_EmitComponentLayer(ctx, ct, "DASe"); i = PDJPG_EncodeLDatCtx(ctx, tbuf, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } else { k = 0; for (i = 0; i < n; i++) { j = rgba[i * 4 + 3]; if (j != 255) k = 1; tbuf[i * 4 + 0] = (byte)j; tbuf[i * 4 + 1] = (byte)j; tbuf[i * 4 + 2] = (byte)j; tbuf[i * 4 + 3] = 255; } if (k != 0) { ct = PDJPG_EmitComponentLayer(ctx, ct, "Alpha"); i = PDJPG_EncodeLDatCtx(ctx, tbuf, ct, xs, ys, qf, PDJPG_YYYA); if (i < 0) { return (i); } ct += i; } } if (luma != null) { ct = PDJPG_EmitComponentLayer(ctx, ct, "LuRGB"); i = PDJPG_EncodeLDatCtx(ctx, luma, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } if (lebe != null) { ct = PDJPG_EmitComponentLayer(ctx, ct, "LeBe"); i = PDJPG_EncodeLDatCtx(ctx, lebe, ct, xs, ys, qf, 0); if (i < 0) { return (i); } ct += i; } //ct.emit(0xFF); //ct.emit(JPG.JPG_EOI); //free(tbuf); return (ct - obuf); }
public static int PDJPG_Encode( byte[] ibuf, BytePtr obuf, int xs, int ys, int qf) { PDJPG_Context ctx; int sz; ctx = PDJPG_AllocContext(); sz = PDJPG_EncodeCtx(ctx, ibuf, obuf, xs, ys, qf, 0); PDJPG_FreeContext(ctx); return (sz); }
public static BytePtr PDJPG_EncodeBeginLayeredCtx( PDJPG_Context ctx, BytePtr ct, int xs, int ys, int qf) { ct.emit(0xFF); ct.emit(JPG.JPG_SOI); ct = PDJPG_EmitMarkerJFIF(ctx, ct); return ct; }
public static 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 BytePtr PDJPG_EmitMarkerJFIF(PDJPG_Context ctx, BytePtr ct) { BytePtr ctt; int i; if (ctx.jpg_clrtrans != PDJPG_CLRS_YCBCR) return (ct); //ctx.huff.ct = ct; ctx.huff.win = 0; ctx.huff.pos = 0; //ctx.huff.InitOutputStream(ctx, ct); ct.emit(0xFF); ct.emit(JPG.JPG_APP0); ctt = ct; ct.emit(0x00); ct.emit(0x00); ct.EmitString("JFIF"); //PDJPG_WriteString(ctx, "JFIF"); ct.emit(0x01); //version high ct.emit(0x02); //version low ct.emit(0x00); //no units ct.emit(0x00); //X density ct.emit(0x01); ct.emit(0x00); //Y density ct.emit(0x01); ct.emit(0x00); //thumbnail ct.emit(0x00); // ctx.huff.WriteString(ctx, name); i = ct - ctt; ctt[0] = (i >> 8) & 0xFF; ctt[1] = i & 0xFF; return (ct); }
public static int PDJPG_EncodeCtx_MegablockInner( PDJPG_Context ctx, BytePtr obuf, int xs, int ys, int qfl) { // static BytePtr yb=null, *ub, *vb; // static short *ydb=null, *udb, *vdb; // static int lxs=0, lys=0; IntPtr dcs = new IntPtr(256); IntPtr acs = new IntPtr(256); IntPtr dcsuv = new IntPtr(256); IntPtr acsuv = new IntPtr(256); ShortPtr tp; int xs2, ys2, xs3, ys3, qf; // int cr, cg, cb, cy, cu, cv; int i, j, k, l; qf = qfl & 255; xs2 = ctx.xs2; ys2 = ctx.ys2; xs3 = ctx.xs3; ys3 = ctx.ys3; // printf("M1\n"); // if(qf==110) if (ctx.jpg_rdct) { // printf("PDJPG_EncodeCtx: Lossless Detect\n"); PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128); PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128); PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128); } else { PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128); PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128); PDJPG_FilterImageMegablockRDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128); //PDJPG_FilterImageDCT(new ShortPtr(ctx.yb), new ShortPtr(ctx.ydb), xs2, ys2, 128); //PDJPG_FilterImageDCT(new ShortPtr(ctx.ub), new ShortPtr(ctx.udb), xs3, ys3, 128); //PDJPG_FilterImageDCT(new ShortPtr(ctx.vb), new ShortPtr(ctx.vdb), xs3, ys3, 128); } j = (xs2 / 64) * (ys2 / 64); PDJPG_MakeMegaQuantTabInputY(ctx.ydb, j, new BytePtr(ctx.jpg_qt, 0 * 256), qf / 100.0); j = (xs3 / 64) * (ys3 / 64); PDJPG_MakeMegaQuantTabInputUV(ctx.udb, j, new BytePtr(ctx.jpg_qt, 1 * 256), qf / 100.0); PDJPG_MakeMegaQuantTabInputUV(ctx.vdb, j, new BytePtr(ctx.jpg_qt, 2 * 256), qf / 100.0); for (i = 0; i < 128; i++) ctx.jpg_qt[1 * 256 + i] = (byte)((ctx.jpg_qt[1 * 256 + i] + ctx.jpg_qt[2 * 256 + i]) / 2); PDJPG_SetupQuantTabDivFP(ctx, 0); PDJPG_SetupQuantTabDivFP(ctx, 1); // free(yb); // free(ub); // free(vb); if (ctx.jpg_mono || !ctx.jpg_is420) { j = (xs2 / 64) * (ys2 / 64); k = 0; for (i = 0; i < j; i++) { ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.ydb, i * 4096), new ShortPtr(ctx.ydb, i * 4096), 0); ctx.ydb[i * 4096 + 0] -= (short)k; k = ctx.ydb[i * 4096 + 0] + k; } } if (!ctx.jpg_mono && ctx.jpg_is420) { l = 0; for (i = 0; i <= (ys3 / 64); i++) for (j = 0; j < (xs3 / 64); j++) { tp = new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 0) * 4096); ctx.block.QuantMegaBlock(ctx, tp, tp, 0); tp[0] -= l; l = tp[0] + l; tp = new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 1) * 4096); ctx.block.QuantMegaBlock(ctx, tp, tp, 0); tp[0] -= l; l = tp[0] + l; tp = new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 0) * 4096); ctx.block.QuantMegaBlock(ctx, tp, tp, 0); tp[0] -= l; l = tp[0] + l; tp = new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 1) * 4096); ctx.block.QuantMegaBlock(ctx, tp, tp, 0); tp[0] -= l; l = tp[0] + l; } } j = (xs3 / 64) * (ys3 / 64); k = 0; l = 0; for (i = 0; i < j; i++) { ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.udb, i * 4096), new ShortPtr(ctx.udb, i * 4096), 1); ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.vdb, i * 4096), new ShortPtr(ctx.vdb, i * 4096), 1); ctx.udb[i * 4096 + 0] -= (short)k; k = ctx.udb[i * 4096 + 0] + k; ctx.vdb[i * 4096 + 0] -= (short)l; l = ctx.vdb[i * 4096 + 0] + l; } if (ctx.jpg_yuvw) { j = (xs3 / 64) * (ys3 / 64); k = 0; for (i = 0; i < j; i++) { ctx.block.QuantMegaBlock(ctx, new ShortPtr(ctx.wdb, i * 4096), new ShortPtr(ctx.wdb, i * 4096), 1); ctx.wdb[i * 4096 + 0] -= (short)k; k = ctx.wdb[i * 4096 + 0] + k; } } // printf("M2\n"); for (i = 0; i < 256; i++) dcs[i] = 0; for (i = 0; i < 256; i++) acs[i] = 0; for (i = 0; i < 256; i++) dcsuv[i] = 0; for (i = 0; i < 256; i++) acsuv[i] = 0; j = (xs2 / 64) * (ys2 / 64); k = (xs3 / 64) * (ys3 / 64); for (i = 0; i < j; i++) ctx.block.StatMegaBlock(new ShortPtr(ctx.ydb, i * 4096), dcs, acs); for (i = 0; i < k; i++) ctx.block.StatMegaBlock(new ShortPtr(ctx.udb, i * 4096), dcsuv, acsuv); for (i = 0; i < k; i++) ctx.block.StatMegaBlock(new ShortPtr(ctx.vdb, i * 4096), dcsuv, acsuv); if (ctx.jpg_yuvw) { for (i = 0; i < k; i++)ctx.block.StatMegaBlock(new ShortPtr(ctx.wdb, i * 4096), dcsuv, acsuv); } // ctx.huff.BuildLengths(dcs, 256, ctx.huff.len+0*256, 16); // ctx.huff.BuildLengths(acs, 256, ctx.huff.len+1*256, 16); // ctx.huff.BuildLengths(dcsuv, 256, ctx.huff.len+2*256, 16); // ctx.huff.BuildLengths(acsuv, 256, ctx.huff.len+3*256, 16); //ctx.huff.BuildLengthsAdjust(dcs, 256, new BytePtr(ctx.huff.len, 0 * 256), 16); //ctx.huff.BuildLengthsAdjust(acs, 256, new BytePtr(ctx.huff.len, 1 * 256), 16); //ctx.huff.BuildLengthsAdjust(dcsuv, 256, new BytePtr(ctx.huff.len, 2 * 256), 16); //ctx.huff.BuildLengthsAdjust(acsuv, 256, new BytePtr(ctx.huff.len, 3 * 256), 16); ctx.huff.BuildTable(dcs, 0); ctx.huff.BuildTable(acs, 1); ctx.huff.BuildTable(dcsuv, 2); ctx.huff.BuildTable(acsuv, 3); //ctx.huff.ct = obuf; //ctx.huff.win = 0; //ctx.huff.pos = 0; ctx.huff.InitOutputStream(ctx, obuf); if ((qfl & PDJPG_QFL_NOSOI) == 0) { ctx.huff.ct.emit(0xFF); ctx.huff.ct.emit(JPG.JPG_SOI); } PDJPG_EmitMarkerBCST(ctx); PDJPG_EmitDQT(ctx, 0); if (!ctx.jpg_mono) PDJPG_EmitDQT(ctx, 1); PDJPG_EmitSOF(ctx, xs, ys); ctx.huff.EmitDHT(ctx, 0); ctx.huff.EmitDHT(ctx, 1); if (!ctx.jpg_mono) { ctx.huff.EmitDHT(ctx, 2); ctx.huff.EmitDHT(ctx, 3); } PDJPG_EmitSOS(ctx); ctx.huff.InitOutputStream(ctx, ctx.huff.ct); //ctx.huff.win = 0; //ctx.huff.pos = 0; if (ctx.jpg_mono) { j = (xs2 / 64) * (ys2 / 64); for (i = 0; i < j; i++) ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, i * 4096), 0, 1); } else if (ctx.jpg_is420) { for (i = 0; i <= (ys3 / 64); i++) for (j = 0; j < (xs3 / 64); j++) { ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 0) * 4096), 0, 1); ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, ((i * 2 + 0) * (xs2 / 64) + j * 2 + 1) * 4096), 0, 1); ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 0) * 4096), 0, 1); ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, ((i * 2 + 1) * (xs2 / 64) + j * 2 + 1) * 4096), 0, 1); k = i * (xs3 / 64) + j; ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.udb, k * 4096), 2, 3); ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.vdb, k * 4096), 2, 3); if (ctx.jpg_yuvw) { ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.wdb, k * 4096), 2, 3); } } } else { j = (xs2 / 64) * (ys2 / 64); for (i = 0; i < j; i++) { ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.ydb, i * 4096), 0, 1); ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.udb, i * 4096), 2, 3); ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.vdb, i * 4096), 2, 3); if (ctx.jpg_yuvw) { ctx.block.EncodeMegaBlock(ctx, new ShortPtr(ctx.wdb, i * 4096), 2, 3); } } } ctx.huff.FlushBits(ctx); if ((qfl & PDJPG_QFL_NOSOI) == 0) { ctx.huff.ct.emit(0xFF); ctx.huff.ct.emit(JPG.JPG_EOI); } // printf("M3\n"); i = ctx.huff.ct - obuf; return (i); }
public static 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 bvalue(Object_ o, BytePtr b) { o.value.b = (b != null ? new BytePtr(b) : null); }
public static void s_bvalue(int i, BytePtr ptr) { bvalue(s_object(i), ptr); }
/* ** Execute the given opcode, until a RET. Parameters are between ** [stack+base,top). Returns n such that the the results are between ** [stack+n,top). */ private static StkId lua_execute(BytePtr pc, StkId @base) { //pc = new BytePtr(pc); lua_checkstack(STACKGAP + MAX_TEMPS + @base); while (true) { #if MY_DEBUG //printf(">>> %d,", ObjectRef.minus(top, stack)); #endif OpCode opcode; opcode = (OpCode)pc[0]; pc.inc(); switch (opcode) { case OpCode.PUSHNIL: tag(top.get(), lua_Type.LUA_T_NIL); top.inc(); break; case OpCode.PUSH0: case OpCode.PUSH1: case OpCode.PUSH2: tag(top.get(), lua_Type.LUA_T_NUMBER); nvalue(top.get(), opcode - OpCode.PUSH0); top.inc(); break; case OpCode.PUSHBYTE: tag(top.get(), lua_Type.LUA_T_NUMBER); nvalue(top.get(), pc[0]); top.inc(); pc.inc(); break; case OpCode.PUSHWORD: { CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), lua_Type.LUA_T_NUMBER); nvalue(top.get(), code.w); top.inc(); } break; case OpCode.PUSHFLOAT: { CodeFloat code = new CodeFloat(); get_float(code, pc); tag(top.get(), lua_Type.LUA_T_NUMBER); nvalue(top.get(), code.f); top.inc(); } break; case OpCode.PUSHSTRING: { CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), lua_Type.LUA_T_STRING); tsvalue(top.get(), lua_constant[code.w]); top.inc(); } break; case OpCode.PUSHFUNCTION: { CodeCode code = new CodeCode(); get_code(code, pc); tag(top.get(), lua_Type.LUA_T_FUNCTION); bvalue(top.get(), new BytePtr(code.b, 0)); top.inc(); } break; case OpCode.PUSHLOCAL0: case OpCode.PUSHLOCAL1: case OpCode.PUSHLOCAL2: case OpCode.PUSHLOCAL3: case OpCode.PUSHLOCAL4: case OpCode.PUSHLOCAL5: case OpCode.PUSHLOCAL6: case OpCode.PUSHLOCAL7: case OpCode.PUSHLOCAL8: case OpCode.PUSHLOCAL9: top.get().set(stack[(@base) + (int)(opcode - OpCode.PUSHLOCAL0)]); top.inc(); break; case OpCode.PUSHLOCAL: top.get().set(stack[(@base) + pc[0]]); top.inc(); pc.inc(); break; case OpCode.PUSHGLOBAL: { CodeWord code = new CodeWord(); get_word(code, pc); top.get().set(s_object(code.w)); top.inc(); } break; case OpCode.PUSHINDEXED: pushsubscript(); break; case OpCode.PUSHSELF: { Object_ receiver = top.get(-1); CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), lua_Type.LUA_T_STRING); tsvalue(top.get(), lua_constant[code.w]); top.inc(); pushsubscript(); top.get().set(receiver); top.inc(); break; } case OpCode.STORELOCAL0: case OpCode.STORELOCAL1: case OpCode.STORELOCAL2: case OpCode.STORELOCAL3: case OpCode.STORELOCAL4: case OpCode.STORELOCAL5: case OpCode.STORELOCAL6: case OpCode.STORELOCAL7: case OpCode.STORELOCAL8: case OpCode.STORELOCAL9: top.dec(); stack[(@base) + (int)(opcode - OpCode.STORELOCAL0)].set(top.get()); break; case OpCode.STORELOCAL: top.dec(); stack[(@base) + pc[0]].set(top.get()); pc.inc(); break; case OpCode.STOREGLOBAL: { CodeWord code = new CodeWord(); get_word(code, pc); top.dec(); s_object(code.w, top.get(0)); } break; case OpCode.STOREINDEXED0: storesubscript(); break; case OpCode.STOREINDEXED: { int n = pc[0]; pc.inc(); if (tag(top.get(-3 - n)) != lua_Type.LUA_T_ARRAY) { top.get(+1).set(top.get(-1)); top.get().set(top.get(-2 - n)); top.get(-1).set(top.get(-3 - n)); top.add(2); do_call(luaI_fallBacks[FB_SETTABLE].function, ObjectRef.minus(top, stack) - 3, 0, ObjectRef.minus(top, stack) - 3); } else { Object_ h = lua_hashdefine(avalue(top.get(-3 - n)), top.get(-2 - n)); h.set(top.get(-1)); top.dec(); } } break; case OpCode.STORELIST0: case OpCode.STORELIST: { int m, n; Object_ arr; if (opcode == OpCode.STORELIST0) { m = 0; } else { m = pc[0] * FIELDS_PER_FLUSH; pc.inc(); } n = pc[0]; pc.inc(); arr = top.get(-n - 1); while (n != 0) { tag(top.get(), lua_Type.LUA_T_NUMBER); nvalue(top.get(), n + m); lua_hashdefine(avalue(arr), top.get()).set(top.get(-1)); top.dec(); n--; } } break; case OpCode.STORERECORD: { int n = pc[0]; pc.inc(); Object_ arr = top.get(-n - 1); while (n != 0) { CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), lua_Type.LUA_T_STRING); tsvalue(top.get(), lua_constant[code.w]); lua_hashdefine(avalue(arr), top.get()).set(top.get(-1)); top.dec(); n--; } } break; case OpCode.ADJUST0: adjust_top(@base); break; case OpCode.ADJUST: adjust_top(@base + pc[0]); pc.inc(); break; case OpCode.CREATEARRAY: { CodeWord size = new CodeWord(); get_word(size, pc); avalue(top.get(), lua_createarray(size.w)); tag(top.get(), lua_Type.LUA_T_ARRAY); top.inc(); } break; case OpCode.EQOP: { int res = lua_equalObj(top.get(-2), top.get(-1)); top.dec(); tag(top.get(-1), res != 0 ? lua_Type.LUA_T_NUMBER : lua_Type.LUA_T_NIL); nvalue(top.get(-1), 1); } break; case OpCode.LTOP: comparison(lua_Type.LUA_T_NUMBER, lua_Type.LUA_T_NIL, lua_Type.LUA_T_NIL, "lt"); break; case OpCode.LEOP: comparison(lua_Type.LUA_T_NUMBER, lua_Type.LUA_T_NUMBER, lua_Type.LUA_T_NIL, "le"); break; case OpCode.GTOP: comparison(lua_Type.LUA_T_NIL, lua_Type.LUA_T_NIL, lua_Type.LUA_T_NUMBER, "gt"); break; case OpCode.GEOP: comparison(lua_Type.LUA_T_NIL, lua_Type.LUA_T_NUMBER, lua_Type.LUA_T_NUMBER, "ge"); break; case OpCode.ADDOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { call_arith("add"); } else { nvalue(l, nvalue(l) + nvalue(r)); top.dec(); } } break; case OpCode.SUBOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { call_arith("sub"); } else { nvalue(l, nvalue(l) - nvalue(r)); top.dec(); } } break; case OpCode.MULTOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { call_arith("mul"); } else { nvalue(l, nvalue(l) * nvalue(r)); top.dec(); } } break; case OpCode.DIVOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { call_arith("div"); } else { nvalue(l, nvalue(l) / nvalue(r)); top.dec(); } } break; case OpCode.POWOP: call_arith("pow"); break; case OpCode.CONCOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tostring(r) || tostring(l)) { do_call(luaI_fallBacks[FB_CONCAT].function, ObjectRef.minus(top, stack) - 2, 1, ObjectRef.minus(top, stack) - 2); } else { tsvalue(l, lua_createstring(lua_strconc(svalue(l), svalue(r)))); top.dec(); } } break; case OpCode.MINUSOP: if (tonumber(top.get(-1))) { tag(top.get(), lua_Type.LUA_T_NIL); top.inc(); call_arith("unm"); } else { nvalue(top.get(-1), -nvalue(top.get(-1))); } break; case OpCode.NOTOP: tag(top.get(-1), (tag(top.get(-1)) == lua_Type.LUA_T_NIL) ? lua_Type.LUA_T_NUMBER : lua_Type.LUA_T_NIL); nvalue(top.get(-1), 1); break; case OpCode.ONTJMP: { CodeWord code = new CodeWord(); get_word(code, pc); if (tag(top.get(-1)) != lua_Type.LUA_T_NIL) { pc += code.w; } } break; case OpCode.ONFJMP: { CodeWord code = new CodeWord(); get_word(code, pc); if (tag(top.get(-1)) == lua_Type.LUA_T_NIL) { pc += code.w; } } break; case OpCode.JMP: { CodeWord code = new CodeWord(); get_word(code, pc); pc += code.w; } break; case OpCode.UPJMP: { CodeWord code = new CodeWord(); get_word(code, pc); pc -= code.w; } break; case OpCode.IFFJMP: { CodeWord code = new CodeWord(); get_word(code, pc); top.dec(); if (tag(top.get()) == lua_Type.LUA_T_NIL) { pc += code.w; } } break; case OpCode.IFFUPJMP: { CodeWord code = new CodeWord(); get_word(code, pc); top.dec(); if (tag(top.get()) == lua_Type.LUA_T_NIL) { pc -= code.w; } } break; case OpCode.POP: top.dec(); break; case OpCode.CALLFUNC: { int nParams = pc[0]; pc.inc(); int nResults = pc[0]; pc.inc(); Object_ func = top.get(-1 - nParams); /* function is below parameters */ StkId newBase = ObjectRef.minus(top, stack) - nParams; do_call(func, newBase, nResults, newBase - 1); } break; case OpCode.RETCODE0: return(@base); case OpCode.RETCODE: return(@base + pc[0]); case OpCode.SETFUNCTION: { CodeCode file = new CodeCode(); CodeWord func = new CodeWord(); get_code(file, pc); get_word(func, pc); lua_pushfunction(new CharPtr(file.b), func.w); } break; case OpCode.SETLINE: { CodeWord code = new CodeWord(); get_word(code, pc); lua_debugline = code.w; } break; case OpCode.RESET: lua_popfunction(); break; default: lua_error("internal error - opcode doesn't match"); break; } } }
public static void get_word(CodeWord code, BytePtr pc) { code.m.c1 = (Byte)pc[0]; pc.inc(); code.m.c2 = (Byte)pc[0]; pc.inc(); }
public static void get_float(CodeFloat code, BytePtr pc) { code.m.c1 = (Byte)pc[0]; pc.inc(); code.m.c2 = (Byte)pc[0]; pc.inc(); code.m.c3 = (Byte)pc[0]; pc.inc(); code.m.c4 = (Byte)pc[0]; pc.inc(); }
public static void get_code(CodeCode code, BytePtr pc) { code.m.c1 = (Byte)pc[0]; pc.inc(); code.m.c2 = (Byte)pc[0]; pc.inc(); code.m.c3 = (Byte)pc[0]; pc.inc(); code.m.c4 = (Byte)pc[0]; pc.inc(); }
public static int PDJPG_EncodeFloatComponentCtx(PDJPG_Context ctx, float[] rgba, float[] norm, float[] spec, float[] luma, BytePtr obuf, int xs, int ys, int qf) { byte[] trgba, tnorm, tspec, tluma, tlebe; int i, j, n; double f; n = xs * ys; if (ctx.imgbuf_rgba == null) ctx.imgbuf_rgba = new byte[4 * n]; if (ctx.imgbuf_norm == null) ctx.imgbuf_norm = new byte[4 * n]; if (ctx.imgbuf_spec == null) ctx.imgbuf_spec = new byte[4 * n]; if (ctx.imgbuf_luma == null) ctx.imgbuf_luma = new byte[4 * n]; if (ctx.imgbuf_lebe == null) { ctx.imgbuf_lebe = new byte[4 * n]; BytePtr.memset(ctx.imgbuf_lebe, 192, 4 * n); } trgba = ctx.imgbuf_rgba; tnorm = ctx.imgbuf_norm; tspec = ctx.imgbuf_spec; tluma = ctx.imgbuf_luma; tlebe = ctx.imgbuf_lebe; if (rgba != null) { for (i = 0; i < n; i++) { PDJPG_EncodeFloatPixel(new FloatPtr(rgba, i * 4), new BytePtr(trgba, i * 4), new BytePtr(tlebe, i * 4 + 0)); } } if (norm != null) { for (i = 0; i < n; i++) { // f=(1.0/256)*pdjpg_scltab[tlebe[i*4+0]]; j = PDJPG_CalcComponentValueExponent(norm[i * 4 + 3]); f = 255 / pdjpg_scltab[j]; tnorm[i * 4 + 0] = (byte)(norm[i * 4 + 0] * 255); tnorm[i * 4 + 1] = (byte)(norm[i * 4 + 1] * 255); tnorm[i * 4 + 2] = (byte)(norm[i * 4 + 2] * 255); tnorm[i * 4 + 3] = (byte)(norm[i * 4 + 3] * f); tlebe[i * 4 + 3] = (byte)j; } } if (spec != null) { for (i = 0; i < n; i++) { tspec[i * 4 + 0] = (byte)(spec[i * 4 + 0] * 255); tspec[i * 4 + 1] = (byte)(spec[i * 4 + 1] * 255); tspec[i * 4 + 2] = (byte)(spec[i * 4 + 2] * 255); tspec[i * 4 + 3] = (byte)(spec[i * 4 + 3] * 255); } } if (luma != null) { for (i = 0; i < n; i++) { PDJPG_EncodeFloatPixel(new FloatPtr(luma, i * 4), new BytePtr(tluma, i * 4), new BytePtr(tlebe, i * 4 + 1)); } } i = PDJPG_EncodeComponentCtxI(ctx, trgba, tnorm, tspec, tluma, tlebe, obuf, xs, ys, qf); return (i); }
//static void pdjpg_getPixel2_RGBA(BytePtr rgb, // int *ra, int *ga, int *ba, // int *rb, int *gb, int *bb) //{ // *ra=rgb[0]; *ga=rgb[1]; *ba=rgb[2]; // *ra=rgb[4]; *ga=rgb[5]; *ba=rgb[6]; //} #endif #if false public static int PDJPG_EncodeFast( BytePtr ibuf, BytePtr obuf, int xs, int ys, int qf) { int sz; if (st_ctx == null) st_ctx = PDJPG_AllocContext(); sz = PDJPG_EncodeFastCtx(st_ctx, ibuf, obuf, xs, ys, qf, 0); // PDJPG_FreeContext(ctx); return (sz); }
public static void PDJPG_EncodeFloatPixel(FloatPtr ipix, BytePtr opix, BytePtr oexp) { double f, g; int i, j, k; if ((ipix[0] >= 0) && (ipix[0] <= 1) && (ipix[1] >= 0) && (ipix[1] <= 1) && (ipix[2] >= 0) && (ipix[2] <= 1)) { oexp[0] = 192; opix[0] = (byte)(ipix[0] * 255); opix[1] = (byte)(ipix[1] * 255); opix[2] = (byte)(ipix[2] * 255); return; } f = ipix[1]; if (Math.Abs(ipix[0]) > Math.Abs(f)) f = ipix[0]; if (Math.Abs(ipix[2]) > Math.Abs(f)) f = ipix[2]; if (f >= 0) { f = Math.Log(f) / Math.Log(2.0); i = (int)(pdjpg_ssqrt(f * 240) + 0.5); if (i > 63) i = 63; if (i < (-63)) i = -63; j = 192 + i; g = pdjpg_scltab[j]; oexp[0] = (byte)j; f = 255 / g; k = (int)(ipix[0] * f); k = (k < 0) ? 0 : ((k <= 255) ? k : 255); opix[0] = (byte)k; k = (int)(ipix[1] * f); k = (k < 0) ? 0 : ((k <= 255) ? k : 255); opix[1] = (byte)k; k = (int)(ipix[2] * f); k = (k < 0) ? 0 : ((k <= 255) ? k : 255); opix[2] = (byte)k; return; } else { f = Math.Log(-f) / Math.Log(2.0); i = (int)(pdjpg_ssqrt(f * 240) + 0.5); if (i > 63) i = 63; if (i < (-63)) i = -63; j = 63 - i; g = pdjpg_scltab[j]; oexp[0] = (byte)j; f = 255 / g; k = (int)(ipix[0] * f); k = (k < 0) ? 0 : ((k <= 255) ? k : 255); opix[0] = (byte)k; k = (int)(ipix[1] * f); k = (k < 0) ? 0 : ((k <= 255) ? k : 255); opix[1] = (byte)k; k = (int)(ipix[2] * f); k = (k < 0) ? 0 : ((k <= 255) ? k : 255); opix[2] = (byte)k; return; } }
public static void PDJPG_EmitMarkerDMLT_DHT(PDJPG_Context ctx, int tab) { BytePtr tbuf, ct1; int i; tbuf = new BytePtr(65536); ct1 = ctx.huff.EmitMiniHufftabBuf(ctx, tbuf, tab); i = ct1 - tbuf; ctx.huff.ct.emit(PDJPG_DMLT_DHT0 + tab); ctx.huff.ct.EmitUVLI((ulong)i); BytePtr.memcpy(ctx.huff.ct, tbuf, i); ctx.huff.ct += i; }
public static int PDJPG_EncodeLDatCtx( PDJPG_Context ctx, byte[] ibuf, BytePtr obuf, int xs, int ys, int qf, int pf) { BytePtr tbuf, cts; int i, j, sz, tsz; // if(!ctx)ctx=PDJPG_AllocContext(); tbuf = new BytePtr(1 << 20); sz = PDJPG_EncodeCtx(ctx, ibuf, tbuf, xs, ys, qf, pf); sz = PDJPG_EscapeEncodeSingleBuffer(tbuf, sz); cts = tbuf; tsz = sz; //ctx.huff.ct = obuf; ctx.huff.win = 0; ctx.huff.pos = 0; ctx.huff.InitOutputStream(ctx, obuf); while (tsz >= 65528) { i = 65529; if (cts[i - 1] == 0xFF) i--; j = i + 6; ctx.huff.ct.emit(0xFF); ctx.huff.ct.emit(JPG.JPG_APP12); ctx.huff.ct.emit((j >> 8) & 0xFF); ctx.huff.ct.emit(j & 0xFF); ctx.huff.ct.emit('L'); ctx.huff.ct.emit('D'); ctx.huff.ct.emit('A'); ctx.huff.ct.emit('T'); BytePtr.memcpy(ctx.huff.ct, cts, i); cts += i; ctx.huff.ct += i; tsz -= i; } if ((tsz > 0) && (tsz < 65528)) { i = tsz + 6; ctx.huff.ct.emit(0xFF); ctx.huff.ct.emit(JPG.JPG_APP12); ctx.huff.ct.emit((i >> 8) & 0xFF); ctx.huff.ct.emit(i & 0xFF); ctx.huff.ct.emit('L'); ctx.huff.ct.emit('D'); ctx.huff.ct.emit('A'); ctx.huff.ct.emit('T'); BytePtr.memcpy(ctx.huff.ct, cts, tsz); ctx.huff.ct += tsz; } sz = ctx.huff.ct - obuf; //free(tbuf); return (sz); }
public static void PDJPG_EmitMarkerDMLT_DQT(PDJPG_Context ctx, int n) { BytePtr tbuf, ct1, ct2; int i, j, k, l, nb; #if false nb = 1; for (i = 0; i < 64; i++) { j=ctx.jpg_qt[n * 64 + i]; while (j >= (1 << nb)) nb++; } #endif nb = 4; tbuf = new BytePtr(65536); ct2 = ctx.huff.ct; ctx.huff.InitOutputStream(ctx, tbuf); ctx.huff.WriteNBits(ctx, 0, 4); //reserved ctx.huff.WriteNBits(ctx, nb, 4); //DQT bits l = 0; for (i = 0; i < 64; i++) { //ctx.huff.WriteNBits(ctx, ctx.jpg_qt[n * 64 + pdjpg_zigzag2[i]], nb); k = ctx.jpg_qt[n * 64 + pdjpg_zigzag2[i]]; ((PDJHUFF)ctx.huff).WriteSRice(ctx, k - l, nb); l = k; } // WriteNBits(ctx, 1, 4); // WriteNBits(ctx, 2, 4); // BSXRP_EncodeCodeLengths(ctx, new BytePtr(len, tab * 256), 256); ctx.huff.FlushBits(ctx); ct1 = ctx.huff.ct; ctx.huff.ct = ct2; i = ct1 - tbuf; ctx.huff.ct.emit(PDJPG_DMLT_DQT0 + n); ctx.huff.ct.EmitUVLI((ulong)i); BytePtr.memcpy(ctx.huff.ct, tbuf, i); ctx.huff.ct += i; }
public static int PDJPG_EscapeDecodeSingleBuffer(BytePtr buf, int sz) { BytePtr cs, ct, cse, cte; cs = buf; cse = buf + sz; ct = buf; cte = buf + sz; while ((cs < cse) && (ct < cte)) { if ((cs[0] == 0xFF) && (cs[1] == 0x00)) { cs += 2; ct.emit(0xFF); continue; } if ((cs[0] == 0xFF) && (cs[1] <= 0x0F)) { ct.emit(0xFF); ct.emit(cs[1] - 1); cs += 2; continue; } ct.emit(cs.next()); } if (ct >= cte) return (-1); return (ct - buf); }
public static BytePtr PDJPG_EmitTagLayer(PDJPG_Context ctx, BytePtr ct, string name) { BytePtr ctt; int i; //ctx.huff.ct = ct; ctx.huff.win = 0; ctx.huff.pos = 0; //ctx.huff.InitOutputStream(ctx, ct); ct.emit(0xFF); ct.emit(JPG.JPG_APP11); ctt = ct; ct.emit(0x00); ct.emit(0x00); ct.EmitString("TagLayer"); ct.EmitString(name); i = ct - ctt; ctt[0] = (i >> 8) & 0xFF; ctt[1] = i & 0xFF; return (ct); }
public static int PDJPG_EscapeEncodeBuffer(BytePtr ibuf, int isz, BytePtr obuf, int osz) { BytePtr cs, ct, cse, cte; cs = ibuf; cse = ibuf + isz; ct = obuf; cte = obuf + osz; while ((cs < cse) && (ct < cte)) { if (cs[0] == 0xFF) { cs++; ct.emit(0xFF); ct.emit(0x00); continue; } ct.emit(cs.next()); } if (ct >= cte) return (-1); return (ct - obuf); }
public static int PDJPG_EncodeBaseCtx( PDJPG_Context ctx, byte[] ibuf, BytePtr obuf, int xs, int ys, int qf, int pf) { BytePtr tbuf, cs, cse, ct; int sz; tbuf = new BytePtr(1 << 24); sz = PDJPG_EncodeCtx(ctx, ibuf, tbuf, xs, ys, qf, pf); cs = tbuf; cse = tbuf + sz; ct = obuf; if ((cs[0] == 0xFF) && (cs[1] == JPG.JPG_SOI)) cs += 2; while (cs < cse) { if ((cs[0] == 0xFF) && (cs[1] == JPG.JPG_EOI)) break; ct.emit(cs.next()); } //free(tbuf); return (ct - obuf); }
public static int PDJPG_EscapeEncodeSingleBuffer(BytePtr buf, int sz) { BytePtr tbuf; int i; tbuf = new BytePtr(sz * 2); i = PDJPG_EscapeEncodeBuffer(buf, sz, tbuf, sz * 2); if (i < 0) return (i); BytePtr.memcpy(buf, tbuf, i); // free(tbuf); return (i); }
public static int PDJPG_EncodeComponent( byte[] rgba, byte[] norm, byte[] spec, byte[] luma, BytePtr obuf, int xs, int ys, int qf) { PDJPG_Context ctx; int sz; ctx = PDJPG_AllocContext(); sz = PDJPG_EncodeComponentCtx(ctx, rgba, norm, spec, luma, obuf, xs, ys, qf); PDJPG_FreeContext(ctx); return (sz); }
public static void PDJPG_MakeQuantTabFastIJG_Y( short[] inv, int cnt, BytePtr tab, double qf) { double s, q; int i, j; q = (qf * 100); s = (q < 50) ? 5000 / q : (200 - 2 * q); for (i = 0; i < 64; i++) { j = (int)((s * pdjpg_ijg_qtab_y[i] + 50) / 100); j = (j < 1) ? 1 : ((j < 256) ? j : 255); tab[i] = j; } }
public static int PDJPG_EncodeComponentCtxI(PDJPG_Context ctx, byte[] rgba, byte[] norm, byte[] spec, byte[] luma, byte[] lebe, BytePtr obuf, int xs, int ys, int qf) { int i; BytePtr ct; ct = obuf; ct = PDJPG_EncodeBeginLayeredCtx(ctx, ct, xs, ys, qf); i = PDJPG_EncodeComponentCtxI2(ctx, rgba, norm, spec, luma, lebe, ct, xs, ys, qf, null, null); ct += i; ct = PDJPG_EncodeEndLayeredCtx(ctx, ct); //free(tbuf); return (ct - obuf); }
public static void PDJPG_MakeQuantTabInput(short[] inv, int cnt, BytePtr tab, double q) { PDJPG_MakeQuantTabInput_AA(inv, cnt, tab, q); }
public static void luaI_free_BytePtr(ref BytePtr block) { block = null; //*((int *)block) = -1; /* to catch errors */ //free(block); }
public static void PDJPG_MakeQuantTabInputFast( short[] inv, int cnt, BytePtr tab, double q) { int i; // PDJPG_MakeQuantTabInput(in, cnt, tab, q); i = cnt / 16; if (i < 1) i = 1; PDJPG_MakeQuantTabInput(inv, i, tab, q); }
// public CharPtr(string str) // { // this.chars = (str + '\0').ToCharArray(); // this.index = 0; // } public BytePtr(BytePtr ptr) { this.chars = ptr.chars; this.index = ptr.index; }
public static void PDJPG_MakeQuantTabInput_AA(short[] inv, int cnt, BytePtr tab, double q) { // static double deltas[DCTSZ2]; double[] deltas = new double[DCTSZ2]; double f, g, te; int i, j, k; if (q >= 1) { for (i = 0; i < DCTSZ2; i++) tab[i] = 1; return; } for (j = 0; j < DCTSZ2; j++) deltas[j] = 0; #if false for (i = 0; i < cnt; i++) for (j = 0; j < DCTSZ2; j++) deltas[j] += Math.Abs(inv[i * DCTSZ2 + j] * 1.0); for (j = 0; j < DCTSZ2; j++) deltas[j] /= cnt; #endif #if true for (i = 0; i < cnt; i++) for (j = 0; j < DCTSZ2; j++) { k = inv[i * DCTSZ2 + j]; deltas[j] += k*k; } for (j = 0; j < DCTSZ2; j++) { deltas[j] = Math.Sqrt(deltas[j] / cnt); } #endif te = 0; for (j = 0; j < DCTSZ2; j++) te += deltas[j]; for (i = 0; i < DCTSZ; i++) { for (j = 0; j < DCTSZ; j++) { f = deltas[i * DCTSZ + j]; f = f / te; if (f < 0.00001) f = 0.00001; g = (1.0 - q); f = 10 * g * g * g / f; k = (int)f; if (k < 1) k = 1; if (k > 255) k = 255; // printf("%f/%f %d\n", deltas[i*DCTSZ+j], te, k); // if(f<1)f=1; // if(f>255)f=255; tab[i * DCTSZ + j] = (byte)k; } } #if false if (tab[DCTSZ2 - 3] > 1) tab[DCTSZ2 - 3] = (byte)(tab[DCTSZ2 - 3] * 0.75); if (tab[DCTSZ2 - 2] > 1) tab[DCTSZ2 - 2] = (byte)(tab[DCTSZ2 - 2] * 0.75); if (tab[DCTSZ2 - 1] > 1) tab[DCTSZ2 - 1] = (byte)(tab[DCTSZ2 - 1] * 0.5); #endif }
public BytePtr(BytePtr ptr, int index) { this.chars = ptr.chars; this.index = index; }
public static int PDJPG_GetImgBlk(char *blk, int xo, int yo, BytePtr img, int xs, int ys) { BytePtr cs; char *ct; int i, j, k; cs=img+(yo*xs+xo); ct=blk; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); ct+=8; cs+=xs; memcpy8(ct, cs); // ct+=8; cs+=xs; return(0); }
/* ** Execute the given opcode. Return 0 in success or 1 on error. */ public static int lua_execute(BytePtr pc) { ObjectRef oldbase = new ObjectRef(@base); @base = new ObjectRef(top); while (true) { OpCode opcode; opcode = (OpCode)pc[0]; pc.inc(); switch (opcode) { case OpCode.PUSHNIL: tag(top.get(), Type.T_NIL); top.inc(); break; case OpCode.PUSH0: tag(top.get(), Type.T_NUMBER); nvalue(top.get(), 0); top.inc(); break; case OpCode.PUSH1: tag(top.get(), Type.T_NUMBER); nvalue(top.get(), 1); top.inc(); break; case OpCode.PUSH2: tag(top.get(), Type.T_NUMBER); nvalue(top.get(), 2); top.inc(); break; case OpCode.PUSHBYTE: tag(top.get(), Type.T_NUMBER); nvalue(top.get(), pc[0]); pc.inc(); top.inc(); break; case OpCode.PUSHWORD: { CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), Type.T_NUMBER); nvalue(top.get(), code.w); top.inc(); } break; case OpCode.PUSHFLOAT: { CodeFloat code = new CodeFloat(); get_float(code, pc); tag(top.get(), Type.T_NUMBER); nvalue(top.get(), code.f); top.inc(); } break; case OpCode.PUSHSTRING: { CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), Type.T_STRING); svalue(top.get(), lua_constant[code.w]); top.inc(); } break; case OpCode.PUSHLOCAL0: case OpCode.PUSHLOCAL1: case OpCode.PUSHLOCAL2: case OpCode.PUSHLOCAL3: case OpCode.PUSHLOCAL4: case OpCode.PUSHLOCAL5: case OpCode.PUSHLOCAL6: case OpCode.PUSHLOCAL7: case OpCode.PUSHLOCAL8: case OpCode.PUSHLOCAL9: top.set(0, @base.get((int)(opcode - OpCode.PUSHLOCAL0))); top.inc(); break; case OpCode.PUSHLOCAL: top.set(0, @base.get(pc[0])); top.inc(); pc.inc(); break; case OpCode.PUSHGLOBAL: { CodeWord code = new CodeWord(); get_word(code, pc); top.set(0, s_object(code.w)); top.inc(); } break; case OpCode.PUSHINDEXED: top.dec(); if (tag(top.get(-1)) != Type.T_ARRAY) { lua_reportbug("indexed expression not a table"); return(1); } { Object_ h = lua_hashdefine(avalue(top.get(-1)), top.get()); if (h == null) { return(1); } top.set(-1, h); } break; case OpCode.PUSHMARK: tag(top.get(), Type.T_MARK); top.inc(); break; case OpCode.PUSHOBJECT: top.set(0, top.get(-3)); top.inc(); break; case OpCode.STORELOCAL0: case OpCode.STORELOCAL1: case OpCode.STORELOCAL2: case OpCode.STORELOCAL3: case OpCode.STORELOCAL4: case OpCode.STORELOCAL5: case OpCode.STORELOCAL6: case OpCode.STORELOCAL7: case OpCode.STORELOCAL8: case OpCode.STORELOCAL9: top.dec(); @base.set((int)(opcode - OpCode.STORELOCAL0), top.get()); break; case OpCode.STORELOCAL: top.dec(); @base.set(pc[0], top.get()); pc.inc(); break; case OpCode.STOREGLOBAL: { CodeWord code = new CodeWord(); get_word(code, pc); top.dec(); s_object(code.w, top.get()); } break; case OpCode.STOREINDEXED0: if (tag(top.get(-3)) != Type.T_ARRAY) { lua_reportbug("indexed expression not a table"); return(1); } { Object_ h = lua_hashdefine(avalue(top.get(-3)), top.get(-2)); if (h == null) { return(1); } h.set(top.get(-1)); } top.add(-3); break; case OpCode.STOREINDEXED: { int n = pc[0]; pc.inc(); if (tag(top.get(-3 - n)) != Type.T_ARRAY) { lua_reportbug("indexed expression not a table"); return(1); } { Object_ h = lua_hashdefine(avalue(top.get(-3 - n)), top.get(-2 - n)); if (h == null) { return(1); } h.set(top.get(-1)); } top.dec(); } break; case OpCode.STORELIST0: case OpCode.STORELIST: { int m, n; Object_ arr; if (opcode == OpCode.STORELIST0) { m = 0; } else { m = pc[0] * FIELDS_PER_FLUSH; pc.inc(); } n = pc[0]; pc.inc(); arr = top.get(-n - 1); if (tag(arr) != Type.T_ARRAY) { lua_reportbug("internal error - table expected"); return(1); } while (n != 0) { tag(top.get(), Type.T_NUMBER); nvalue(top.get(), n + m); lua_hashdefine(avalue(arr), top.get()).set(top.get(-1)); top.dec(); n--; } } break; case OpCode.STORERECORD: { int n = pc[0]; pc.inc(); Object_ arr = top.get(-n - 1); if (tag(arr) != Type.T_ARRAY) { lua_reportbug("internal error - table expected"); return(1); } while (n != 0) { CodeWord code = new CodeWord(); get_word(code, pc); tag(top.get(), Type.T_STRING); svalue(top.get(), lua_constant[code.w]); (lua_hashdefine(avalue(arr), top.get())).set(top.get(-1)); top.dec(); n--; } } break; case OpCode.ADJUST: { ObjectRef newtop = @base.getRef(pc[0]); pc.inc(); while (top.isLessThan(newtop.get())) { tag(top.get(), Type.T_NIL); top.inc(); } top = newtop; /* top could be bigger than newtop */ } break; case OpCode.CREATEARRAY: if (tag(top.get(-1)) == Type.T_NIL) { nvalue(top.get(-1), 101); } else { if (tonumber(top.get(-1))) { return(1); } if (nvalue(top.get(-1)) <= 0) { nvalue(top.get(-1), 101); } } avalue(top.get(-1), (Hash)lua_createarray((int)nvalue(top.get(-1)))); if (avalue(top.get(-1)) == null) { return(1); } tag(top.get(-1), Type.T_ARRAY); break; case OpCode.EQOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); top.dec(); if (tag(l) != tag(r)) { tag(top.get(-1), Type.T_NIL); } else { switch (tag(l)) { case Type.T_NIL: tag(top.get(-1), Type.T_NUMBER); break; case Type.T_NUMBER: tag(top.get(-1), (nvalue(l) == nvalue(r)) ? Type.T_NUMBER : Type.T_NIL); break; case Type.T_ARRAY: tag(top.get(-1), (avalue(l) == avalue(r)) ? Type.T_NUMBER : Type.T_NIL); break; case Type.T_FUNCTION: tag(top.get(-1), (bvalue(l) == bvalue(r)) ? Type.T_NUMBER : Type.T_NIL); break; case Type.T_CFUNCTION: tag(top.get(-1), (fvalue(l) == fvalue(r)) ? Type.T_NUMBER : Type.T_NIL); break; case Type.T_USERDATA: tag(top.get(-1), (uvalue(l) == uvalue(r)) ? Type.T_NUMBER : Type.T_NIL); break; case Type.T_STRING: tag(top.get(-1), (strcmp(svalue(l), svalue(r)) == 0) ? Type.T_NUMBER : Type.T_NIL); break; case Type.T_MARK: return(1); } } nvalue(top.get(-1), 1); } break; case OpCode.LTOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); top.dec(); if (tag(l) == Type.T_NUMBER && tag(r) == Type.T_NUMBER) { tag(top.get(-1), (nvalue(l) < nvalue(r)) ? Type.T_NUMBER : Type.T_NIL); } else { if (tostring(l) || tostring(r)) { return(1); } tag(top.get(-1), (strcmp(svalue(l), svalue(r)) < 0) ? Type.T_NUMBER : Type.T_NIL); } nvalue(top.get(-1), 1); } break; case OpCode.LEOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); top.dec(); if (tag(l) == Type.T_NUMBER && tag(r) == Type.T_NUMBER) { tag(top.get(-1), (nvalue(l) <= nvalue(r)) ? Type.T_NUMBER : Type.T_NIL); } else { if (tostring(l) || tostring(r)) { return(1); } tag(top.get(-1), (strcmp(svalue(l), svalue(r)) <= 0) ? Type.T_NUMBER : Type.T_NIL); } nvalue(top.get(-1), 1); } break; case OpCode.ADDOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { return(1); } nvalue(l, nvalue(l) + nvalue(r)); top.dec(); } break; case OpCode.SUBOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { return(1); } nvalue(l, nvalue(l) - nvalue(r)); top.dec(); } break; case OpCode.MULTOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { return(1); } nvalue(l, nvalue(l) * nvalue(r)); top.dec(); } break; case OpCode.DIVOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tonumber(r) || tonumber(l)) { return(1); } nvalue(l, nvalue(l) / nvalue(r)); top.dec(); } break; case OpCode.CONCOP: { Object_ l = top.get(-2); Object_ r = top.get(-1); if (tostring(r) || tostring(l)) { return(1); } svalue(l, lua_createstring(lua_strconc(svalue(l), svalue(r)))); if (svalue(l) == null) { return(1); } top.dec(); } break; case OpCode.MINUSOP: if (tonumber(top.get(-1))) { return(1); } nvalue(top.get(-1), -nvalue(top.get(-1))); break; case OpCode.NOTOP: tag(top.get(-1), tag(top.get(-1)) == Type.T_NIL ? Type.T_NUMBER : Type.T_NIL); break; case OpCode.ONTJMP: { CodeWord code = new CodeWord(); get_word(code, pc); if (tag(top.get(-1)) != Type.T_NIL) { pc += code.w; } } break; case OpCode.ONFJMP: { CodeWord code = new CodeWord(); get_word(code, pc); if (tag(top.get(-1)) == Type.T_NIL) { pc += code.w; } } break; case OpCode.JMP: { CodeWord code = new CodeWord(); get_word(code, pc); pc += code.w; } break; case OpCode.UPJMP: { CodeWord code = new CodeWord(); get_word(code, pc); pc -= code.w; } break; case OpCode.IFFJMP: { CodeWord code = new CodeWord(); get_word(code, pc); top.dec(); if (tag(top.get()) == Type.T_NIL) { pc += code.w; } } break; case OpCode.IFFUPJMP: { CodeWord code = new CodeWord(); get_word(code, pc); top.dec(); if (tag(top.get()) == Type.T_NIL) { pc -= code.w; } } break; case OpCode.POP: top.dec(); break; case OpCode.CALLFUNC: { // if (pc.chars != code.chars && pc.index == 4454) // { // Console.WriteLine("================="); // } BytePtr newpc; ObjectRef b_ = top.getRef(-1); while (tag(b_.get()) != Type.T_MARK) { b_.dec(); } // if (b_.obj == stack) // { // Console.WriteLine("================"); // } if (tag(b_.get(-1)) == Type.T_FUNCTION) { lua_debugline = 0; /* always reset debug flag */ newpc = bvalue(b_.get(-1)); bvalue(b_.get(-1), pc); /* store return code */ nvalue(b_.get(), @base.minus(stack)); /* store base value */ @base = b_.getRef(+1); pc = new BytePtr(newpc); if (MAXSTACK - @base.minus(stack) < STACKGAP) { lua_error("stack overflow"); return(1); } } else if (tag(b_.get(-1)) == Type.T_CFUNCTION) { int nparam; lua_debugline = 0; // always reset debug flag nvalue(b_.get(), @base.minus(stack)); // store base value @base = b_.getRef(+1); nparam = top.minus(@base); // number of parameters (fvalue(b_.get(-1)))(); // call C function /* shift returned values */ { int i; int nretval = top.minus(@base) - nparam; top = @base.getRef(-2); @base = new ObjectRef(stack, (int)nvalue(@base.get(-1))); for (i = 0; i < nretval; i++) { top.get().set(top.get(nparam + 2)); top.inc(); } } } else { lua_reportbug("call expression not a function"); return(1); } } break; case OpCode.RETCODE: { int i; int shift = pc[0]; pc.inc(); int nretval = top.minus(@base) - shift; top.setRef(@base.get(-2)); pc = bvalue(@base.get(-2)); @base = new ObjectRef(stack, (int)nvalue(@base.get(-1))); //FIXME:???new ObjectRef??? for (i = 0; i < nretval; i++) { top.get().set(top.get(shift + 2)); top.inc(); } } break; case OpCode.HALT: @base = new ObjectRef(oldbase); return(0); // success case OpCode.SETFUNCTION: { CodeWord file = new CodeWord(), func = new CodeWord(); get_word(file, pc); get_word(func, pc); if (0 != lua_pushfunction(file.w, func.w)) { return(1); } } break; case OpCode.SETLINE: { CodeWord code = new CodeWord(); get_word(code, pc); lua_debugline = code.w; } break; case OpCode.RESET: lua_popfunction(); break; default: lua_error("internal error - opcode didn't match"); return(1); } } }
public static void PDJPG_MakeMegaQuantTabInputY(short[] inv, int cnt, BytePtr tab, double q) { BytePtr taba, tabb; int i; //PDJPG_MakeQuantTabInput_AA(inv, cnt, tab, q); //PDJPG_MakeQuantTabFastIJG_Y(inv, cnt, tab, q); taba = new BytePtr(64); tabb = new BytePtr(64); PDJPG_MakeQuantTabInput_AA(inv, cnt*64, taba, q); PDJPG_MakeQuantTabFastIJG_Y(inv, cnt*64, tabb, q); for (i = 0; i < 64; i++) tab[i] = (taba[i] + tabb[i]) / 2; for (i = 0; i < 64; i++) tab[64+i] = (taba[i] + tabb[i]) / 2; }