byte getPel(Picture pic, int plane, int x, int y) { if (x < 0) x = 0; if (y < 0) y = 0; int w = pic.getPlaneWidth(plane); if (x > w - 1) x = w - 1; int h = pic.getPlaneHeight(plane); if (y > h - 1) y = h - 1; return pic.getData()[plane][x + y * w]; }
private PictureHiBD toPictureHiBDInternal(PictureHiBD pic) { int[][] dstData = pic.getData(); for (int i = 0; i < data.length; i++) { int planeSize = getPlaneWidth(i) * getPlaneHeight(i); for (int j = 0; j < planeSize; j++) { dstData[i][j] = (data[i][j] + 128) << lowBitsNum; } } if (lowBits != null) { for (int i = 0; i < lowBits.length; i++) { int planeSize = getPlaneWidth(i) * getPlaneHeight(i); for (int j = 0; j < planeSize; j++) { dstData[i][j] += lowBits[i][j]; } } } return pic; }
private void split(Picture in, Picture out, int mbX, int mbY, int sliceMbCount, int vStep, int vOffset) { byte[][] inData = in.getData(); byte[][] inhbdData = in.getLowBits(); byte[][] outData = out.getData(); byte[][] outhbdData = out.getLowBits(); doSplit(inData[0], outData[0], in.getPlaneWidth(0), mbX, mbY, sliceMbCount, 0, vStep, vOffset); doSplit(inData[1], outData[1], in.getPlaneWidth(1), mbX, mbY, sliceMbCount, 1, vStep, vOffset); doSplit(inData[2], outData[2], in.getPlaneWidth(2), mbX, mbY, sliceMbCount, 1, vStep, vOffset); if (in.getLowBits() != null) { doSplit(inhbdData[0], outhbdData[0], in.getPlaneWidth(0), mbX, mbY, sliceMbCount, 0, vStep, vOffset); doSplit(inhbdData[1], outhbdData[1], in.getPlaneWidth(1), mbX, mbY, sliceMbCount, 1, vStep, vOffset); doSplit(inhbdData[2], outhbdData[2], in.getPlaneWidth(2), mbX, mbY, sliceMbCount, 1, vStep, vOffset); } }
public static void putPix(Picture p, Macroblock mb, int x, int y) { byte[] plane0 = p.getPlaneData(0); int dsto0 = ((y << 4)) * p.getWidth() + (x << 4); for (int row = 0, srco = 0; row < 16; row++, dsto0 += p.getWidth()) { for (int col = 0; col < 16; col++, srco++) { plane0[dsto0 + col] = mb.pred[0][srco]; } } for (int pl = 1; pl < 3; pl++) { byte[] plane = p.getPlaneData(pl); int dsto = ((y << 3)) * p.getPlaneWidth(pl) + (x << 3); for (int row = 0, srco = 0; row < 8; row++, dsto += p.getPlaneWidth(pl)) { for (int col = 0; col < 8; col++, srco++) { plane[dsto + col] = mb.pred[pl][srco]; } } } }
public void putMacroblock(Picture tgt, Picture decoded, int mbX, int mbY) { byte[] luma = tgt.getPlaneData(0); int stride = tgt.getPlaneWidth(0); byte[] cb = tgt.getPlaneData(1); byte[] cr = tgt.getPlaneData(2); int strideChroma = tgt.getPlaneWidth(1); int dOff = 0; for (int i = 0; i < 16; i++) { arraycopy(decoded.getPlaneData(0), dOff, luma, (mbY * 16 + i) * stride + mbX * 16, 16); dOff += 16; } for (int i = 0; i < 8; i++) { arraycopy(decoded.getPlaneData(1), i * 8, cb, (mbY * 8 + i) * strideChroma + mbX * 8, 8); } for (int i = 0; i < 8; i++) { arraycopy(decoded.getPlaneData(2), i * 8, cr, (mbY * 8 + i) * strideChroma + mbX * 8, 8); } } }
public void predictMB(Picture ref, int refX, int vectX, int refY, int vectY, int blkW, int blkH, int refVertStep, int refVertOff, int[][] tgt, int tgtY, int tgtVertStep) { int ch = chromaFormat == Chroma420 ? 1 : 0; int cw = chromaFormat == Chroma444 ? 0 : 1; int sh = chromaFormat == Chroma420 ? 2 : 1; int sw = chromaFormat == Chroma444 ? 1 : 2; predictPlane(ref.getPlaneData(0), refX + vectX, refY + vectY, ref.getPlaneWidth(0), ref.getPlaneHeight(0), refVertStep, refVertOff, tgt[0], tgtY, blkW, blkH, tgtVertStep); predictPlane(ref.getPlaneData(1), (refX >> cw) + vectX / sw, (refY >> ch) + vectY / sh, ref.getPlaneWidth(1), ref.getPlaneHeight(1), refVertStep, refVertOff, tgt[1], tgtY, blkW >> cw, blkH >> ch, tgtVertStep); predictPlane(ref.getPlaneData(2), (refX >> cw) + vectX / sw, (refY >> ch) + vectY / sh, ref.getPlaneWidth(2), ref.getPlaneHeight(2), refVertStep, refVertOff, tgt[2], tgtY, blkW >> cw, blkH >> ch, tgtVertStep); }
void decodeBlock(BitReader bits, int[] dcPredictor, int[][] quant, VLC[] huff, Picture result, int[] buf, int blkX, int blkY, int plane, int chroma, int field, int step) { Arrays.fill(buf, 0); dcPredictor[plane] = buf[0] = readDCValue(bits, huff[chroma]) * quant[chroma][0] + dcPredictor[plane]; readACValues(bits, buf, huff[chroma + 2], quant[chroma]); SimpleIDCT10Bit.idct10(buf, 0); putBlock(result.getPlaneData(plane), result.getPlaneWidth(plane), buf, blkX, blkY, field, step); }
public static final void putBlkPic(Picture dest, Picture src, int x, int y) { if (dest.getColor() != src.getColor()) throw new RuntimeException("Incompatible color"); for (int c = 0; c < dest.getColor().nComp; c++) { pubBlkOnePlane(dest.getPlaneData(c), dest.getPlaneWidth(c), src.getPlaneData(c), src.getPlaneWidth(c), src.getPlaneHeight(c), x >> dest.getColor().compWidth[c], y >> dest.getColor().compHeight[c]); } }
private int[][] transformChroma(Picture pic, int comp, int qp, int x, int y, Picture outMB, int chromaPred) { int[][] ac = new int[4][16]; for (int blk = 0; blk < ac.length; blk++) { int blkOffX = (blk & 1) << 2; int blkOffY = (blk >> 1) << 2; takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x + blkOffX, y + blkOffY, ac[blk], chromaPred); VPXDCT.fdct4x4(ac[blk]); } return ac; }
private int[] mvEstimate(Picture pic, int mbX, int mbY, int mvpx, int mvpy) { byte[] patch = new byte[256]; MBEncoderHelper.take(pic.getPlaneData(0), pic.getPlaneWidth(0), pic.getPlaneHeight(0), mbX << 4, mbY << 4, patch, 16, 16); return me.estimate(ref, patch, mbX, mbY, mvpx, mvpy); }
private void predictChroma(Picture pic, int[][] ac, byte[][] pred, int comp, int x, int y) { chromaPredBlk0(comp, x, y, pred[0]); chromaPredBlk1(comp, x, y, pred[1]); chromaPredBlk2(comp, x, y, pred[2]); chromaPredBlk3(comp, x, y, pred[3]); MBEncoderHelper.takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x, y, ac[0], pred[0], 4, 4); MBEncoderHelper.takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x + 4, y, ac[1], pred[1], 4, 4); MBEncoderHelper.takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x, y + 4, ac[2], pred[2], 4, 4); MBEncoderHelper.takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x + 4, y + 4, ac[3], pred[3], 4, 4); }
private void transform(Picture pic, int comp, int[][] ac, byte[][] pred, int x, int y) { for (int i = 0; i < ac.length; i++) { int[] coeff = ac[i]; MBEncoderHelper.takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x + BLK_X[i], y + BLK_Y[i], coeff, pred[i], 4, 4); // shift back up // System.out.print("Luma: "); // for (int j = 0; j < coeff.length; j++) { // coeff[j] += 128; // System.out.print(coeff[j] + ","); // } // System.out.println(); CoeffTransformer.fdct4x4(coeff); } }
@Override public void transform(Picture src, Picture dst) { int lumaSize = src.getWidth() * src.getHeight(); arraycopy(src.getPlaneData(0), 0, dst.getPlaneData(0), 0, lumaSize); copyAvg(src.getPlaneData(1), dst.getPlaneData(1), src.getPlaneWidth(1), src.getPlaneHeight(1)); copyAvg(src.getPlaneData(2), dst.getPlaneData(2), src.getPlaneWidth(2), src.getPlaneHeight(2)); }
@Override void decodeBlock(BitReader bits, int[] dcPredictor, int[][] quant, VLC[] huff, Picture result, int[] buf, int blkX, int blkY, int plane, int chroma, int field, int step) { buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = buf[7] = buf[8] = buf[9] = buf[10] = buf[11] = buf[12] = buf[13] = buf[14] = buf[15] = 0; dcPredictor[plane] = buf[0] = readDCValue(bits, huff[chroma]) * quant[chroma][0] + dcPredictor[plane]; readACValues(bits, buf, huff[chroma + 2], quant[chroma]); IDCT4x4.idct(buf, 0); putBlock4x4(result.getPlaneData(plane), result.getPlaneWidth(plane), buf, blkX, blkY, field, step); }
@Override void decodeBlock(BitReader bits, int[] dcPredictor, int[][] quant, VLC[] huff, Picture result, int[] buf, int blkX, int blkY, int plane, int chroma, int field, int step) { buf[1] = buf[2] = buf[3] = 0; dcPredictor[plane] = buf[0] = readDCValue(bits, huff[chroma]) * quant[chroma][0] + dcPredictor[plane]; readACValues(bits, buf, huff[chroma + 2], quant[chroma]); IDCT2x2.idct(buf, 0); putBlock2x2(result.getPlaneData(plane), result.getPlaneWidth(plane), buf, blkX, blkY, field, step); }
private int[][] transform(Picture pic, int comp, int qp, int x, int y) { int dcc = lumaDCPred(x, y); int[][] ac = new int[16][16]; for (int i = 0; i < ac.length; i++) { int[] coeff = ac[i]; int blkOffX = (i & 3) << 2; int blkOffY = i & ~3; takeSubtract(pic.getPlaneData(comp), pic.getPlaneWidth(comp), pic.getPlaneHeight(comp), x + blkOffX, y + blkOffY, coeff, dcc); VPXDCT.fdct4x4(coeff); } return ac; }
/** * Get block of ( possibly interpolated ) luma pixels */ public void getBlockLuma(Picture pic, Picture out, int off, int x, int y, int w, int h) { int xInd = x & 0x3; int yInd = y & 0x3; int xFp = x >> 2; int yFp = y >> 2; if (xFp < 2 || yFp < 2 || xFp > pic.getWidth() - w - 5 || yFp > pic.getHeight() - h - 5) { unsafe[(yInd << 2) + xInd].getLuma(pic.getData()[0], pic.getWidth(), pic.getHeight(), out.getPlaneData(0), off, out.getPlaneWidth(0), xFp, yFp, w, h); } else { safe[(yInd << 2) + xInd].getLuma(pic.getData()[0], pic.getWidth(), pic.getHeight(), out.getPlaneData(0), off, out.getPlaneWidth(0), xFp, yFp, w, h); } }
@Override public void transform(Picture src, Picture dst) { int size = src.getWidth() * src.getHeight(); System.arraycopy(src.getPlaneData(0), 0, dst.getPlaneData(0), 0, size); for (int plane = 1; plane < 3; plane++) { byte[] srcPl = src.getPlaneData(plane); byte[] dstPl = dst.getPlaneData(plane); int srcStride = src.getPlaneWidth(plane); for (int y = 0, srcOff = 0, dstOff = 0; y < src.getHeight(); y += 2, srcOff += srcStride) { for (int x = 0; x < src.getWidth(); x += 2, srcOff += 2, dstOff++) { dstPl[dstOff] = (byte) ((srcPl[srcOff] + srcPl[srcOff + 1] + srcPl[srcOff + srcStride] + srcPl[srcOff + srcStride + 1] + 2) >> 2); } } } } }
private void filterBlockEdgeVert(Picture pic, int comp, int x, int y, int indexAlpha, int indexBeta, int bs, int blkH) { int stride = pic.getPlaneWidth(comp); for (int i = 0; i < blkH; i++) { int offsetQ = (y + i) * stride + x; int p2Idx = offsetQ - 3; int p1Idx = offsetQ - 2; int p0Idx = offsetQ - 1; int q0Idx = offsetQ; int q1Idx = offsetQ + 1; int q2Idx = offsetQ + 2; if (bs == 4) { int p3Idx = offsetQ - 4; int q3Idx = offsetQ + 3; filterBs4(indexAlpha, indexBeta, pic.getPlaneData(comp), pic.getPlaneData(comp), p3Idx, p2Idx, p1Idx, p0Idx, q0Idx, q1Idx, q2Idx, q3Idx, comp != 0); } else if (bs > 0) { filterBs(bs, indexAlpha, indexBeta, pic.getPlaneData(comp), pic.getPlaneData(comp), p2Idx, p1Idx, p0Idx, q0Idx, q1Idx, q2Idx, comp != 0); } } }
private void filterBlockEdgeHoris(Picture pic, int comp, int x, int y, int indexAlpha, int indexBeta, int bs, int blkW) { int stride = pic.getPlaneWidth(comp); int offset = y * stride + x; for (int pixOff = 0; pixOff < blkW; pixOff++) { int p2Idx = offset - 3 * stride + pixOff; int p1Idx = offset - 2 * stride + pixOff; int p0Idx = offset - stride + pixOff; int q0Idx = offset + pixOff; int q1Idx = offset + stride + pixOff; int q2Idx = offset + 2 * stride + pixOff; if (bs == 4) { int p3Idx = offset - 4 * stride + pixOff; int q3Idx = offset + 3 * stride + pixOff; filterBs4(indexAlpha, indexBeta, pic.getPlaneData(comp), pic.getPlaneData(comp), p3Idx, p2Idx, p1Idx, p0Idx, q0Idx, q1Idx, q2Idx, q3Idx, comp != 0); } else if (bs > 0) { filterBs(bs, indexAlpha, indexBeta, pic.getPlaneData(comp), pic.getPlaneData(comp), p2Idx, p1Idx, p0Idx, q0Idx, q1Idx, q2Idx, comp != 0); } } }