/**
* Retrives precincts and code-blocks coordinates in the given resolution, component and tile. It
* terminates TagTreeEncoder initialization as well.
*
* @param t Tile index.
* @param c Component index.
* @param r Resolution level index.
*/
private void fillPrecInfo(int t, int c, int r) {
if (ppinfo[t][c][r].length == 0) return; // No precinct in this
// resolution level
Point tileI = infoSrc.getTile(null);
Point nTiles = infoSrc.getNumTiles(null);
int x0siz = infoSrc.getImgULX();
int y0siz = infoSrc.getImgULY();
int xsiz = x0siz + infoSrc.getImgWidth();
int ysiz = y0siz + infoSrc.getImgHeight();
int xt0siz = infoSrc.getTilePartULX();
int yt0siz = infoSrc.getTilePartULY();
int xtsiz = infoSrc.getNomTileWidth();
int ytsiz = infoSrc.getNomTileHeight();
int tx0 = (tileI.x == 0) ? x0siz : xt0siz + tileI.x * xtsiz;
int ty0 = (tileI.y == 0) ? y0siz : yt0siz + tileI.y * ytsiz;
int tx1 = (tileI.x != nTiles.x - 1) ? xt0siz + (tileI.x + 1) * xtsiz : xsiz;
int ty1 = (tileI.y != nTiles.y - 1) ? yt0siz + (tileI.y + 1) * ytsiz : ysiz;
int xrsiz = infoSrc.getCompSubsX(c);
int yrsiz = infoSrc.getCompSubsY(c);
int tcx0 = (int) Math.ceil(tx0 / (double) (xrsiz));
int tcy0 = (int) Math.ceil(ty0 / (double) (yrsiz));
int tcx1 = (int) Math.ceil(tx1 / (double) (xrsiz));
int tcy1 = (int) Math.ceil(ty1 / (double) (yrsiz));
int ndl = infoSrc.getAnSubbandTree(t, c).resLvl - r;
int trx0 = (int) Math.ceil(tcx0 / (double) (1 << ndl));
int try0 = (int) Math.ceil(tcy0 / (double) (1 << ndl));
int trx1 = (int) Math.ceil(tcx1 / (double) (1 << ndl));
int try1 = (int) Math.ceil(tcy1 / (double) (1 << ndl));
int cb0x = infoSrc.getCbULX();
int cb0y = infoSrc.getCbULY();
double twoppx = (double) wp.getPrecinctPartition().getPPX(t, c, r);
double twoppy = (double) wp.getPrecinctPartition().getPPY(t, c, r);
int twoppx2 = (int) (twoppx / 2);
int twoppy2 = (int) (twoppy / 2);
// Precincts are located at (cb0x+i*twoppx,cb0y+j*twoppy)
// Valid precincts are those which intersect with the current
// resolution level
int maxPrec = ppinfo[t][c][r].length;
int nPrec = 0;
int istart = (int) Math.floor((try0 - cb0y) / twoppy);
int iend = (int) Math.floor((try1 - 1 - cb0y) / twoppy);
int jstart = (int) Math.floor((trx0 - cb0x) / twoppx);
int jend = (int) Math.floor((trx1 - 1 - cb0x) / twoppx);
int acb0x, acb0y;
SubbandAn root = infoSrc.getAnSubbandTree(t, c);
SubbandAn sb = null;
int p0x, p0y, p1x, p1y; // Precinct projection in subband
int s0x, s0y, s1x, s1y; // Active subband portion
int cw, ch;
int kstart, kend, lstart, lend, k0, l0;
int prg_ulx, prg_uly;
int prg_w = (int) twoppx << ndl;
int prg_h = (int) twoppy << ndl;
CBlkCoordInfo cb;
for (int i = istart; i <= iend; i++) { // Vertical precincts
for (int j = jstart; j <= jend; j++, nPrec++) { // Horizontal precincts
if (j == jstart && (trx0 - cb0x) % (xrsiz * ((int) twoppx)) != 0) {
prg_ulx = tx0;
} else {
prg_ulx = cb0x + j * xrsiz * ((int) twoppx << ndl);
}
if (i == istart && (try0 - cb0y) % (yrsiz * ((int) twoppy)) != 0) {
prg_uly = ty0;
} else {
prg_uly = cb0y + i * yrsiz * ((int) twoppy << ndl);
}
ppinfo[t][c][r][nPrec] =
new PrecInfo(
r,
(int) (cb0x + j * twoppx),
(int) (cb0y + i * twoppy),
(int) twoppx,
(int) twoppy,
prg_ulx,
prg_uly,
prg_w,
prg_h);
if (r == 0) { // LL subband
acb0x = cb0x;
acb0y = cb0y;
p0x = acb0x + j * (int) twoppx;
p1x = p0x + (int) twoppx;
p0y = acb0y + i * (int) twoppy;
p1y = p0y + (int) twoppy;
sb = (SubbandAn) root.getSubbandByIdx(0, 0);
s0x = (p0x < sb.ulcx) ? sb.ulcx : p0x;
s1x = (p1x > sb.ulcx + sb.w) ? sb.ulcx + sb.w : p1x;
s0y = (p0y < sb.ulcy) ? sb.ulcy : p0y;
s1y = (p1y > sb.ulcy + sb.h) ? sb.ulcy + sb.h : p1y;
// Code-blocks are located at (acb0x+k*cw,acb0y+l*ch)
cw = sb.nomCBlkW;
ch = sb.nomCBlkH;
k0 = (int) Math.floor((sb.ulcy - acb0y) / (double) ch);
kstart = (int) Math.floor((s0y - acb0y) / (double) ch);
kend = (int) Math.floor((s1y - 1 - acb0y) / (double) ch);
l0 = (int) Math.floor((sb.ulcx - acb0x) / (double) cw);
lstart = (int) Math.floor((s0x - acb0x) / (double) cw);
lend = (int) Math.floor((s1x - 1 - acb0x) / (double) cw);
if (s1x - s0x <= 0 || s1y - s0y <= 0) {
ppinfo[t][c][r][nPrec].nblk[0] = 0;
ttIncl[t][c][r][nPrec][0] = new TagTreeEncoder(0, 0);
ttMaxBP[t][c][r][nPrec][0] = new TagTreeEncoder(0, 0);
} else {
ttIncl[t][c][r][nPrec][0] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ttMaxBP[t][c][r][nPrec][0] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ppinfo[t][c][r][nPrec].cblk[0] =
new CBlkCoordInfo[kend - kstart + 1][lend - lstart + 1];
ppinfo[t][c][r][nPrec].nblk[0] = (kend - kstart + 1) * (lend - lstart + 1);
for (int k = kstart; k <= kend; k++) { // Vertical cblks
for (int l = lstart; l <= lend; l++) { // Horiz. cblks
cb = new CBlkCoordInfo(k - k0, l - l0);
ppinfo[t][c][r][nPrec].cblk[0][k - kstart][l - lstart] = cb;
} // Horizontal code-blocks
} // Vertical code-blocks
}
} else { // HL, LH and HH subbands
// HL subband
acb0x = 0;
acb0y = cb0y;
p0x = acb0x + j * twoppx2;
p1x = p0x + twoppx2;
p0y = acb0y + i * twoppy2;
p1y = p0y + twoppy2;
sb = (SubbandAn) root.getSubbandByIdx(r, 1);
s0x = (p0x < sb.ulcx) ? sb.ulcx : p0x;
s1x = (p1x > sb.ulcx + sb.w) ? sb.ulcx + sb.w : p1x;
s0y = (p0y < sb.ulcy) ? sb.ulcy : p0y;
s1y = (p1y > sb.ulcy + sb.h) ? sb.ulcy + sb.h : p1y;
// Code-blocks are located at (acb0x+k*cw,acb0y+l*ch)
cw = sb.nomCBlkW;
ch = sb.nomCBlkH;
k0 = (int) Math.floor((sb.ulcy - acb0y) / (double) ch);
kstart = (int) Math.floor((s0y - acb0y) / (double) ch);
kend = (int) Math.floor((s1y - 1 - acb0y) / (double) ch);
l0 = (int) Math.floor((sb.ulcx - acb0x) / (double) cw);
lstart = (int) Math.floor((s0x - acb0x) / (double) cw);
lend = (int) Math.floor((s1x - 1 - acb0x) / (double) cw);
if (s1x - s0x <= 0 || s1y - s0y <= 0) {
ppinfo[t][c][r][nPrec].nblk[1] = 0;
ttIncl[t][c][r][nPrec][1] = new TagTreeEncoder(0, 0);
ttMaxBP[t][c][r][nPrec][1] = new TagTreeEncoder(0, 0);
} else {
ttIncl[t][c][r][nPrec][1] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ttMaxBP[t][c][r][nPrec][1] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ppinfo[t][c][r][nPrec].cblk[1] =
new CBlkCoordInfo[kend - kstart + 1][lend - lstart + 1];
ppinfo[t][c][r][nPrec].nblk[1] = (kend - kstart + 1) * (lend - lstart + 1);
for (int k = kstart; k <= kend; k++) { // Vertical cblks
for (int l = lstart; l <= lend; l++) { // Horiz. cblks
cb = new CBlkCoordInfo(k - k0, l - l0);
ppinfo[t][c][r][nPrec].cblk[1][k - kstart][l - lstart] = cb;
} // Horizontal code-blocks
} // Vertical code-blocks
}
// LH subband
acb0x = cb0x;
acb0y = 0;
p0x = acb0x + j * twoppx2;
p1x = p0x + twoppx2;
p0y = acb0y + i * twoppy2;
p1y = p0y + twoppy2;
sb = (SubbandAn) root.getSubbandByIdx(r, 2);
s0x = (p0x < sb.ulcx) ? sb.ulcx : p0x;
s1x = (p1x > sb.ulcx + sb.w) ? sb.ulcx + sb.w : p1x;
s0y = (p0y < sb.ulcy) ? sb.ulcy : p0y;
s1y = (p1y > sb.ulcy + sb.h) ? sb.ulcy + sb.h : p1y;
// Code-blocks are located at (acb0x+k*cw,acb0y+l*ch)
cw = sb.nomCBlkW;
ch = sb.nomCBlkH;
k0 = (int) Math.floor((sb.ulcy - acb0y) / (double) ch);
kstart = (int) Math.floor((s0y - acb0y) / (double) ch);
kend = (int) Math.floor((s1y - 1 - acb0y) / (double) ch);
l0 = (int) Math.floor((sb.ulcx - acb0x) / (double) cw);
lstart = (int) Math.floor((s0x - acb0x) / (double) cw);
lend = (int) Math.floor((s1x - 1 - acb0x) / (double) cw);
if (s1x - s0x <= 0 || s1y - s0y <= 0) {
ppinfo[t][c][r][nPrec].nblk[2] = 0;
ttIncl[t][c][r][nPrec][2] = new TagTreeEncoder(0, 0);
ttMaxBP[t][c][r][nPrec][2] = new TagTreeEncoder(0, 0);
} else {
ttIncl[t][c][r][nPrec][2] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ttMaxBP[t][c][r][nPrec][2] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ppinfo[t][c][r][nPrec].cblk[2] =
new CBlkCoordInfo[kend - kstart + 1][lend - lstart + 1];
ppinfo[t][c][r][nPrec].nblk[2] = (kend - kstart + 1) * (lend - lstart + 1);
for (int k = kstart; k <= kend; k++) { // Vertical cblks
for (int l = lstart; l <= lend; l++) { // Horiz cblks
cb = new CBlkCoordInfo(k - k0, l - l0);
ppinfo[t][c][r][nPrec].cblk[2][k - kstart][l - lstart] = cb;
} // Horizontal code-blocks
} // Vertical code-blocks
}
// HH subband
acb0x = 0;
acb0y = 0;
p0x = acb0x + j * twoppx2;
p1x = p0x + twoppx2;
p0y = acb0y + i * twoppy2;
p1y = p0y + twoppy2;
sb = (SubbandAn) root.getSubbandByIdx(r, 3);
s0x = (p0x < sb.ulcx) ? sb.ulcx : p0x;
s1x = (p1x > sb.ulcx + sb.w) ? sb.ulcx + sb.w : p1x;
s0y = (p0y < sb.ulcy) ? sb.ulcy : p0y;
s1y = (p1y > sb.ulcy + sb.h) ? sb.ulcy + sb.h : p1y;
// Code-blocks are located at (acb0x+k*cw,acb0y+l*ch)
cw = sb.nomCBlkW;
ch = sb.nomCBlkH;
k0 = (int) Math.floor((sb.ulcy - acb0y) / (double) ch);
kstart = (int) Math.floor((s0y - acb0y) / (double) ch);
kend = (int) Math.floor((s1y - 1 - acb0y) / (double) ch);
l0 = (int) Math.floor((sb.ulcx - acb0x) / (double) cw);
lstart = (int) Math.floor((s0x - acb0x) / (double) cw);
lend = (int) Math.floor((s1x - 1 - acb0x) / (double) cw);
if (s1x - s0x <= 0 || s1y - s0y <= 0) {
ppinfo[t][c][r][nPrec].nblk[3] = 0;
ttIncl[t][c][r][nPrec][3] = new TagTreeEncoder(0, 0);
ttMaxBP[t][c][r][nPrec][3] = new TagTreeEncoder(0, 0);
} else {
ttIncl[t][c][r][nPrec][3] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ttMaxBP[t][c][r][nPrec][3] = new TagTreeEncoder(kend - kstart + 1, lend - lstart + 1);
ppinfo[t][c][r][nPrec].cblk[3] =
new CBlkCoordInfo[kend - kstart + 1][lend - lstart + 1];
ppinfo[t][c][r][nPrec].nblk[3] = (kend - kstart + 1) * (lend - lstart + 1);
for (int k = kstart; k <= kend; k++) { // Vertical cblks
for (int l = lstart; l <= lend; l++) { // Horiz cblks
cb = new CBlkCoordInfo(k - k0, l - l0);
ppinfo[t][c][r][nPrec].cblk[3][k - kstart][l - lstart] = cb;
} // Horizontal code-blocks
} // Vertical code-blocks
}
}
} // Horizontal precincts
} // Vertical precincts
}
/**
* Encodes a packet and returns the buffer containing the encoded packet header. The code-blocks
* appear in a 3D array of CBlkRateDistStats, 'cbs'. The first index is the tile index in
* lexicographical order, the second index is the subband index (as defined in the Subband class),
* and the third index is the code-block index (whithin the subband tile) in lexicographical order
* as well. The indexes of the new truncation points for each code-block are specified by the 3D
* array of int 'tIndx'. The indices of this array are the same as for cbs. The truncation point
* indices in 'tIndx' are the indices of the elements of the 'truncIdxs' array, of the
* CBlkRateDistStats class, that give the real truncation points. If a truncation point index is
* negative it means that the code-block has not been included in any layer yet. If the truncation
* point is less than or equal to the highest truncation point used in previous layers then the
* code-block is not included in the packet. Otherwise, if larger, the code-block is included in
* the packet. The body of the packet can be obtained with the getLastBodyBuf() and
* getLastBodyLen() methods.
*
* <p>Layers must be coded in increasing order, in consecutive manner, for each tile, component
* and resolution level (e.g., layer 1, then layer 2, etc.). For different tile, component and/or
* resolution level no particular order must be followed.
*
* @param ly The layer index (starts at 1).
* @param c The component index.
* @param r The resolution level
* @param t Index of the current tile
* @param cbs The 3D array of coded code-blocks.
* @param tIndx The truncation point indices for each code-block.
* @param hbuf The header buffer. If null a new BitOutputBuffer is created and returned. This
* buffer is reset before anything is written to it.
* @param bbuf The body buffer. If null a new one is created. If not large enough a new one is
* created.
* @param pIdx The precinct index.
* @return The buffer containing the packet header.
*/
public BitOutputBuffer encodePacket(
int ly,
int c,
int r,
int t,
CBlkRateDistStats cbs[][],
int tIndx[][],
BitOutputBuffer hbuf,
byte bbuf[],
int pIdx) {
int b, i, maxi;
int ncb;
int thmax;
int newtp;
int cblen;
int prednbits, nbits, deltabits;
TagTreeEncoder cur_ttIncl, cur_ttMaxBP; // inclusion and bit-depth tag
// trees
int cur_prevtIdxs[]; // last encoded truncation points
CBlkRateDistStats cur_cbs[];
int cur_tIndx[]; // truncation points to encode
int minsb = (r == 0) ? 0 : 1;
int maxsb = (r == 0) ? 1 : 4;
Point cbCoord = null;
SubbandAn root = infoSrc.getAnSubbandTree(t, c);
SubbandAn sb;
roiInPkt = false;
roiLen = 0;
int mend, nend;
// Checks if a precinct with such an index exists in this resolution
// level
if (pIdx >= ppinfo[t][c][r].length) {
packetWritable = false;
return hbuf;
}
PrecInfo prec = ppinfo[t][c][r][pIdx];
// First, we check if packet is empty (i.e precinct 'pIdx' has no
// code-block in any of the subbands)
boolean isPrecVoid = true;
for (int s = minsb; s < maxsb; s++) {
if (prec.nblk[s] == 0) {
// The precinct has no code-block in this subband.
continue;
} else {
// The precinct is not empty in at least one subband ->
// stop
isPrecVoid = false;
break;
}
}
if (isPrecVoid) {
packetWritable = true;
if (hbuf == null) {
hbuf = new BitOutputBuffer();
} else {
hbuf.reset();
}
if (bbuf == null) {
lbbuf = bbuf = new byte[1];
}
hbuf.writeBit(0);
lblen = 0;
return hbuf;
}
if (hbuf == null) {
hbuf = new BitOutputBuffer();
} else {
hbuf.reset();
}
// Invalidate last body buffer
lbbuf = null;
lblen = 0;
// Signal that packet is present
hbuf.writeBit(1);
for (int s = minsb; s < maxsb; s++) { // Loop on subbands
sb = (SubbandAn) root.getSubbandByIdx(r, s);
// Go directly to next subband if the precinct has no code-block
// in the current one.
if (prec.nblk[s] == 0) {
continue;
}
cur_ttIncl = ttIncl[t][c][r][pIdx][s];
cur_ttMaxBP = ttMaxBP[t][c][r][pIdx][s];
cur_prevtIdxs = prevtIdxs[t][c][r][s];
cur_cbs = cbs[s];
cur_tIndx = tIndx[s];
// Set tag tree values for code-blocks in this precinct
mend = (prec.cblk[s] == null) ? 0 : prec.cblk[s].length;
for (int m = 0; m < mend; m++) {
nend = (prec.cblk[s][m] == null) ? 0 : prec.cblk[s][m].length;
for (int n = 0; n < nend; n++) {
cbCoord = prec.cblk[s][m][n].idx;
b = cbCoord.x + cbCoord.y * sb.numCb.x;
if (cur_tIndx[b] > cur_prevtIdxs[b] && cur_prevtIdxs[b] < 0) {
// First inclusion
cur_ttIncl.setValue(m, n, ly - 1);
}
if (ly == 1) { // First layer, need to set the skip of MSBP
cur_ttMaxBP.setValue(m, n, cur_cbs[b].skipMSBP);
}
}
}
// Now encode the information
for (int m = 0; m < prec.cblk[s].length; m++) { // Vertical code-blocks
for (int n = 0; n < prec.cblk[s][m].length; n++) { // Horiz. cblks
cbCoord = prec.cblk[s][m][n].idx;
b = cbCoord.x + cbCoord.y * sb.numCb.x;
// 1) Inclusion information
if (cur_tIndx[b] > cur_prevtIdxs[b]) {
// Code-block included in this layer
if (cur_prevtIdxs[b] < 0) { // First inclusion
// Encode layer info
cur_ttIncl.encode(m, n, ly, hbuf);
// 2) Max bitdepth info. Encode value
thmax = cur_cbs[b].skipMSBP + 1;
for (i = 1; i <= thmax; i++) {
cur_ttMaxBP.encode(m, n, i, hbuf);
}
// Count body size for packet
lblen += cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_tIndx[b]]];
} else { // Already in previous layer
// Send "1" bit
hbuf.writeBit(1);
// Count body size for packet
lblen +=
cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_tIndx[b]]]
- cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_prevtIdxs[b]]];
}
// 3) Truncation point information
if (cur_prevtIdxs[b] < 0) {
newtp = cur_cbs[b].truncIdxs[cur_tIndx[b]];
} else {
newtp =
cur_cbs[b].truncIdxs[cur_tIndx[b]] - cur_cbs[b].truncIdxs[cur_prevtIdxs[b]] - 1;
}
// Mix of switch and if is faster
switch (newtp) {
case 0:
hbuf.writeBit(0); // Send one "0" bit
break;
case 1:
hbuf.writeBits(2, 2); // Send one "1" and one "0"
break;
case 2:
case 3:
case 4:
// Send two "1" bits followed by 2 bits
// representation of newtp-2
hbuf.writeBits((3 << 2) | (newtp - 2), 4);
break;
default:
if (newtp <= 35) {
// Send four "1" bits followed by a five bits
// representation of newtp-5
hbuf.writeBits((15 << 5) | (newtp - 5), 9);
} else if (newtp <= 163) {
// Send nine "1" bits followed by a seven bits
// representation of newtp-36
hbuf.writeBits((511 << 7) | (newtp - 36), 16);
} else {
throw new ArithmeticException(
"Maximum number " + "of truncation " + "points exceeded");
}
}
} else { // Block not included in this layer
if (cur_prevtIdxs[b] >= 0) {
// Already in previous layer. Send "0" bit
hbuf.writeBit(0);
} else { // Not in any previous layers
cur_ttIncl.encode(m, n, ly, hbuf);
}
// Go to the next one.
continue;
}
// Code-block length
// We need to compute the maximum number of bits needed to
// signal the length of each terminated segment and the
// final truncation point.
newtp = 1;
maxi = cur_cbs[b].truncIdxs[cur_tIndx[b]];
cblen =
(cur_prevtIdxs[b] < 0)
? 0
: cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_prevtIdxs[b]]];
// Loop on truncation points
i = (cur_prevtIdxs[b] < 0) ? 0 : cur_cbs[b].truncIdxs[cur_prevtIdxs[b]] + 1;
int minbits = 0;
for (; i < maxi; i++, newtp++) {
// If terminated truncation point calculate length
if (cur_cbs[b].isTermPass != null && cur_cbs[b].isTermPass[i]) {
// Calculate length
cblen = cur_cbs[b].truncRates[i] - cblen;
// Calculate number of needed bits
prednbits = lblock[t][c][r][s][b] + MathUtil.log2(newtp);
minbits = ((cblen > 0) ? MathUtil.log2(cblen) : 0) + 1;
// Update Lblock increment if needed
for (int j = prednbits; j < minbits; j++) {
lblock[t][c][r][s][b]++;
hbuf.writeBit(1);
}
// Initialize for next length
newtp = 0;
cblen = cur_cbs[b].truncRates[i];
}
}
// Last truncation point length always sent
// Calculate length
cblen = cur_cbs[b].truncRates[i] - cblen;
// Calculate number of bits
prednbits = lblock[t][c][r][s][b] + MathUtil.log2(newtp);
minbits = ((cblen > 0) ? MathUtil.log2(cblen) : 0) + 1;
// Update Lblock increment if needed
for (int j = prednbits; j < minbits; j++) {
lblock[t][c][r][s][b]++;
hbuf.writeBit(1);
}
// End of comma-code increment
hbuf.writeBit(0);
// There can be terminated several segments, send length
// info for all terminated truncation points in addition
// to final one
newtp = 1;
maxi = cur_cbs[b].truncIdxs[cur_tIndx[b]];
cblen =
(cur_prevtIdxs[b] < 0)
? 0
: cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_prevtIdxs[b]]];
// Loop on truncation points and count the groups
i = (cur_prevtIdxs[b] < 0) ? 0 : cur_cbs[b].truncIdxs[cur_prevtIdxs[b]] + 1;
for (; i < maxi; i++, newtp++) {
// If terminated truncation point, send length
if (cur_cbs[b].isTermPass != null && cur_cbs[b].isTermPass[i]) {
cblen = cur_cbs[b].truncRates[i] - cblen;
nbits = MathUtil.log2(newtp) + lblock[t][c][r][s][b];
hbuf.writeBits(cblen, nbits);
// Initialize for next length
newtp = 0;
cblen = cur_cbs[b].truncRates[i];
}
}
// Last truncation point length is always signalled
// First calculate number of bits needed to signal
// Calculate length
cblen = cur_cbs[b].truncRates[i] - cblen;
nbits = MathUtil.log2(newtp) + lblock[t][c][r][s][b];
hbuf.writeBits(cblen, nbits);
} // End loop on horizontal code-blocks
} // End loop on vertical code-blocks
} // End loop on subband
// -> Copy the data to the body buffer
// Ensure size for body data
if (bbuf == null || bbuf.length < lblen) {
bbuf = new byte[lblen];
}
lbbuf = bbuf;
lblen = 0;
for (int s = minsb; s < maxsb; s++) { // Loop on subbands
sb = (SubbandAn) root.getSubbandByIdx(r, s);
cur_prevtIdxs = prevtIdxs[t][c][r][s];
cur_cbs = cbs[s];
cur_tIndx = tIndx[s];
ncb = cur_prevtIdxs.length;
mend = (prec.cblk[s] == null) ? 0 : prec.cblk[s].length;
for (int m = 0; m < mend; m++) { // Vertical code-blocks
nend = (prec.cblk[s][m] == null) ? 0 : prec.cblk[s][m].length;
for (int n = 0; n < nend; n++) { // Horiz. cblks
cbCoord = prec.cblk[s][m][n].idx;
b = cbCoord.x + cbCoord.y * sb.numCb.x;
if (cur_tIndx[b] > cur_prevtIdxs[b]) {
// Block included in this precinct -> Copy data to
// body buffer and get code-size
if (cur_prevtIdxs[b] < 0) {
cblen = cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_tIndx[b]]];
System.arraycopy(cur_cbs[b].data, 0, lbbuf, lblen, cblen);
} else {
cblen =
cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_tIndx[b]]]
- cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_prevtIdxs[b]]];
System.arraycopy(
cur_cbs[b].data,
cur_cbs[b].truncRates[cur_cbs[b].truncIdxs[cur_prevtIdxs[b]]],
lbbuf,
lblen,
cblen);
}
lblen += cblen;
// Verifies if this code-block contains new ROI
// information
if (cur_cbs[b].nROIcoeff != 0
&& (cur_prevtIdxs[b] == -1
|| cur_cbs[b].truncIdxs[cur_prevtIdxs[b]] <= cur_cbs[b].nROIcp - 1)) {
roiInPkt = true;
roiLen = lblen;
}
// Update truncation point
cur_prevtIdxs[b] = cur_tIndx[b];
}
} // End loop on horizontal code-blocks
} // End loop on vertical code-blocks
} // End loop on subbands
packetWritable = true;
// Must never happen
if (hbuf.getLength() == 0) {
throw new Error("You have found a bug in PktEncoder, method:" + " encodePacket");
}
return hbuf;
}
/**
* Creates a new packet header encoder, using the information from the 'infoSrc' object. The
* information used is the number of components, number of tiles, subband decomposition, etc.
*
* <p>Note that this constructor visits all the tiles in the 'infoSrc' object. The 'infoSrc'
* object is left at the original tile (i.e. the current tile before calling this constructor),
* but any side effects of visiting the tiles is not reverted.
*
* @param infoSrc The source of information to construct the object.
* @param encSpec The parameters for the encoding
* @param maxNumPrec Maximum number of precinct in each tile, component and resolution level.
* @param pl ParameterList instance that holds command line options
*/
public PktEncoder(CodedCBlkDataSrcEnc infoSrc, J2KImageWriteParamJava wp, Point[][][] numPrec) {
this.infoSrc = infoSrc;
this.wp = wp;
// this.numPrec = numPrec;
// Get number of components and tiles
int nc = infoSrc.getNumComps();
int nt = infoSrc.getNumTiles();
// Do initial allocation
ttIncl = new TagTreeEncoder[nt][nc][][][];
ttMaxBP = new TagTreeEncoder[nt][nc][][][];
lblock = new int[nt][nc][][][];
prevtIdxs = new int[nt][nc][][][];
ppinfo = new PrecInfo[nt][nc][][];
// Finish allocation
SubbandAn root, sb;
int maxs, mins;
int mrl;
Point tmpCoord = null;
int numcb; // Number of code-blocks
Vector cblks = null;
infoSrc.setTile(0, 0);
for (int t = 0; t < nt; t++) { // Loop on tiles
for (int c = 0; c < nc; c++) { // Loop on components
// Get number of resolution levels
root = infoSrc.getAnSubbandTree(t, c);
mrl = root.resLvl;
lblock[t][c] = new int[mrl + 1][][];
ttIncl[t][c] = new TagTreeEncoder[mrl + 1][][];
ttMaxBP[t][c] = new TagTreeEncoder[mrl + 1][][];
prevtIdxs[t][c] = new int[mrl + 1][][];
ppinfo[t][c] = new PrecInfo[mrl + 1][];
for (int r = 0; r <= mrl; r++) { // Loop on resolution levels
mins = (r == 0) ? 0 : 1;
maxs = (r == 0) ? 1 : 4;
int maxPrec = numPrec[t][c][r].x * numPrec[t][c][r].y;
ttIncl[t][c][r] = new TagTreeEncoder[maxPrec][maxs];
ttMaxBP[t][c][r] = new TagTreeEncoder[maxPrec][maxs];
prevtIdxs[t][c][r] = new int[maxs][];
lblock[t][c][r] = new int[maxs][];
// Precincts and code-blocks
ppinfo[t][c][r] = new PrecInfo[maxPrec];
fillPrecInfo(t, c, r);
for (int s = mins; s < maxs; s++) {
// Loop on subbands
sb = (SubbandAn) root.getSubbandByIdx(r, s);
numcb = sb.numCb.x * sb.numCb.y;
lblock[t][c][r][s] = new int[numcb];
ArrayUtil.intArraySet(lblock[t][c][r][s], INIT_LBLOCK);
prevtIdxs[t][c][r][s] = new int[numcb];
ArrayUtil.intArraySet(prevtIdxs[t][c][r][s], -1);
}
}
}
if (t != nt - 1) infoSrc.nextTile();
}
}