/// <summary>
/// Expands each packet interval in the source tile
/// to a list of tilepart packet intervals.
/// Performs the supplied function over the tile-part
/// packet interval, with an optional computational
/// result.
/// </summary>
/// <typeparam name="T">
/// The optional aggregate result of perform
/// </typeparam>
/// <param name="intervals">The packet intervals</param>
/// <param name="srcTile">The source tile</param>
/// <param name="perform">
/// The function to perform on each tile-part packet interval
/// </param>
private void EnumerateIntervals <T>(
IEnumerable <PacketInterval> intervals,
JP2Tile srcTile,
Func <JP2TilePart, int, int, T, T> perform)
{
var scanner = new SegmentScanner(srcTile.GetPacketCounts());
T aggregate = default(T);
foreach (var ival in intervals)
{
// use inclusive end packet index
SegmentLocation segStart = scanner.Find(ival.PacketStart);
SegmentLocation segEnd = scanner.Find(ival.PacketEnd - 1);
int tpStart = segStart.SegmentIdx;
int tpEnd = segEnd.SegmentIdx;
// an interval of packets in the tile may span across multiple tile-parts.
for (int tpIdx = tpStart; tpIdx <= tpEnd; tpIdx++)
{
JP2TilePart tp = srcTile.OpenTilePart(tpIdx);
int pckStart = tpIdx == tpStart
? segStart.InSegmentIdx : 0;
int pckEnd = tpIdx == tpEnd
? (segEnd.InSegmentIdx + 1) : tp.Packets;
int pckCount = pckEnd - pckStart;
aggregate = perform(tp, pckStart, pckCount, aggregate);
}
}
}
public void Add(JP2TilePart tp)
{
if (_tileparts.Count >= MaxEntries)
{
throw new InvalidOperationException(String.Concat(
"Exceeded limit for this TLM marker, ",
"must create a new TLM"));
}
_tileparts.Add(tp);
_isDirty = true;
}
private void CopyTileResLevel(JP2Codestream dst, JP2Codestream src, ushort tIdx, int r)
{
int decomps = src.DecompositionLevels;
var dstTilePart = dst.CreateTilePart(tIdx, r == decomps);
// get all packets for this resolution level and source tile
// currently support only a single tile in source image for every
// destination tile.
QueryContext queryContext = new QueryContext(src, 0);
PreciseQuery preciseQuery = PreciseQuery.Create(queryContext);
var intervals = preciseQuery
.Resolution(r)
.Execute();
JP2Tile srcTile = src.Tiles[0];
// add packet lengths
Func <JP2TilePart, int, int, int, int> addPacketLengths =
(tpSrc, pckStart, pckCount, voidParam) =>
{
var lengths = tpSrc.GetPacketLengths(pckStart, pckCount);
dstTilePart.AddPacketLengths(lengths);
return(voidParam);
};
EnumerateIntervals <int>(intervals, srcTile, addPacketLengths);
// bulk transfer packet data
dstTilePart.Flush();
byte[] buffer = new byte[1 << 16];
Func <JP2TilePart, int, int, uint, uint> bulkTransfer =
(tpSrc, pckStart, pckCount, dstOffset) =>
{
uint dataCount = JP2TilePart.BulkTransferData(
dstTilePart,
dstOffset,
tpSrc,
pckStart,
pckCount,
buffer);
return(dstOffset + dataCount);
};
EnumerateIntervals <uint>(
intervals,
srcTile,
bulkTransfer);
dstTilePart.Close();
srcTile.Close();
}
private void CopyImage()
{
var cs = _jp2.OpenCodestream();
int tileparts = cs.OpenChildren().Count();
var markers = cs.Markers.Values
.Where(ms => ms.Type != MarkerType.TLM);
var csout = new JP2Codestream(markers, tileparts);
csout.Bind(_mem, 0);
JP2TilePart tpin = cs.OpenTilePart(0, 0);
JP2TilePart tpout = csout.CreateTilePart(0, true);
tpout.AddPacketLengths(
tpin.GetPacketLengths(0, tpin.Packets));
tpout.Flush();
uint dataCount =
JP2TilePart.BulkTransferData(tpout, 0, tpin, 0, tpin.Packets);
csout.Flush();
}
