/// <summary> /// Check if a given index in the scope of this surface /// </summary> /// <param name="index">Specified</param> /// <param name="bRgb">If true, check if Rgb data exist for specified frame; otherwise, check if Dwt data exist.</param> /// <returns></returns> public bool IsIndexInScope(TileIndex index, bool bRgb) { if (bRgb) return rgbTileDic.ContainsKey(index); else return dwtQDic.ContainsKey(index); }
/// <summary> /// Update the coefficients after DWT and Quantization of specified tile. /// </summary> /// <param name="index">The index of the tile.</param> /// <param name="dwtQ">The DwtQ coefficients.</param> public void UpdateTileDwtQ(TileIndex index, DwtTile dwtQ) { if (index.X * RdpegfxTileUtils.TileSize >= this.Width || index.Y * RdpegfxTileUtils.TileSize >= this.Height) return; lock (dwtQDic) { if (dwtQDic.ContainsKey(index)) { dwtQDic[index] = dwtQ; } else { dwtQDic.Add(index, dwtQ); } } }
public RgbTile GetRgbTile(TileIndex index) { if (rgbTileDic.ContainsKey(index)) { return rgbTileDic[index]; } else { return null; } }
public DwtTile GetTriState(TileIndex index) { if (this.triStateDic.ContainsKey(index)) { return triStateDic[index]; } else { return null; } }
/// <summary> /// Constructor, create RFX_PROGRESSIVE_TILE_UPGRADE block /// </summary> /// <param name="quantIdx">This is used to indicate index in TS_RFX_CODEC_AUANT array of region block</param> /// <param name="tileIdx">This is used to indicate tile position([x, y]).</param> /// <param name="tileData">This is used to indicate encoded tile data which is related to quantIdx</param> public RFX_PROGRESSIVE_TILE_UPGRADE(byte quantIdx, TileIndex tileIdx, EncodedTile tileData) { this.blockType = RFXProgCodecBlockType.WBT_TILE_PROGRESSIVE_UPGRADE; this.blockLen = 6; // Common part 6 bytes. this.quantIdxY = quantIdx; this.quantIdxCb = quantIdx; this.quantIdxCr = quantIdx; this.xIdx = tileIdx.X; this.yIdx = tileIdx.Y; this.progressiveQuality = tileData.ProgCodecQuant.quality; this.blockLen += 8; // Srl data. this.ySrlLen = (tileData.YEncodedData == null) ? (ushort)0 : (ushort)tileData.YEncodedData.Count(); this.ySrlData = tileData.YEncodedData; this.cbSrlLen = (tileData.CbEncodedData == null) ? (ushort)0 : (ushort)tileData.CbEncodedData.Count(); this.cbSrlData = tileData.CbEncodedData; this.crSrlLen = (tileData.CrEncodedData == null) ? (ushort)0 : (ushort)tileData.CrEncodedData.Count(); this.crSrlData = tileData.CrEncodedData; this.blockLen += (uint)(6 + this.ySrlLen + this.cbSrlLen + this.crSrlLen); // Raw data. this.yRawLen = (tileData.YRawData == null) ? (ushort)0 : (ushort)tileData.YRawData.Count(); this.yRawData = tileData.YRawData; this.cbRawLen = (tileData.CbRawData == null) ? (ushort)0 : (ushort)tileData.CbRawData.Count(); this.cbRawData = tileData.CbRawData; this.crRawLen = (tileData.CrRawData == null) ? (ushort)0 : (ushort)tileData.CrRawData.Count(); this.crRawData = tileData.CrRawData; this.blockLen += (uint)(6 + this.yRawLen + this.cbRawLen + this.crRawLen); }
/// <summary> /// Constructor /// </summary> /// <param name="newFrame">The current frame contains this tile</param> /// <param name="index">The index of this tile in surface</param> public TileState(SurfaceFrame newFrame, TileIndex index) { NewFrame = newFrame; Index = index; }
/// <summary> /// Generate a surface from a bitmap /// </summary> /// <param name="sId">The surface Id</param> /// <param name="bm">The original bitmap</param> /// <returns>A surface instance</returns> public static SurfaceFrame GetFromImage(ushort sId, Bitmap bitmap) { SurfaceFrame surf = new SurfaceFrame(sId, (ushort)bitmap.Width, (ushort)bitmap.Height); for (int xIndex = 0; xIndex * RdpegfxTileUtils.TileSize < bitmap.Width; xIndex++) { for (int yIndex = 0; yIndex * RdpegfxTileUtils.TileSize < bitmap.Height; yIndex++) { TileIndex tIndex = new TileIndex((ushort)xIndex, (ushort)yIndex, bitmap.Width, bitmap.Height); RgbTile rgbTl = RgbTile.GetFromImage(bitmap, xIndex * RdpegfxTileUtils.TileSize, yIndex * RdpegfxTileUtils.TileSize); surf.rgbTileDic.Add(tIndex, rgbTl); } } return surf; }
/// <summary> /// Get all the tile indexes in this surface /// </summary> /// <returns>TileIndex array.</returns> public TileIndex[] GetAllIndexes() { List<TileIndex> indexList = new List<TileIndex>(); for (int xIndex = 0; xIndex * RdpegfxTileUtils.TileSize < this.Width; xIndex++) { for (int yIndex = 0; yIndex * RdpegfxTileUtils.TileSize < this.Height; yIndex++) { TileIndex tIndex = new TileIndex((ushort)xIndex, (ushort)yIndex, this.Width, this.Height); indexList.Add(tIndex); } } return indexList.ToArray(); }
/// <summary> /// Get the bitmap of a tile /// </summary> /// <param name="ti">Tile index</param> /// <returns>Tile bitmap</returns> public Bitmap GetTileBitmap(TileIndex ti) { RgbTile tl = CurrentFrame.GetRgbTile(ti); if (tl != null) { return tl.ToImage(); } return null; }
/// <summary> /// Check if a given index in the scope of this surface /// </summary> /// <param name="index">Specified</param> /// <returns></returns> public bool IsIndexInScope(TileIndex index) { return (index.X * RdpegfxTileUtils.TileSize < this.Width) && (index.Y * RdpegfxTileUtils.TileSize < this.Height); }
/// <summary> /// Get the specified RgbTile /// </summary> /// <param name="index">The index of tile in this surface</param> /// <returns>A RgbTile</returns> public RgbTile GetRgbTile(TileIndex index) { return CurrentFrame.GetRgbTile(index); }
/// <summary> /// Get the tile indexes which covers the specified area /// </summary> /// <param name="rect">The rect area</param> /// <returns>The tile indexes cover the specified area</returns> public TileIndex[] GetIndexesInRect(Rectangle[] rects) { List<TileIndex> indexList = new List<TileIndex>(); foreach (Rectangle rect in rects) { int leftXIndex = rect.X / RdpegfxTileUtils.TileSize; int topYIndex = rect.Y / RdpegfxTileUtils.TileSize; int rightXIndex = (rect.X + rect.Width) / RdpegfxTileUtils.TileSize; int bottomYIndex = (rect.Y + rect.Height) / RdpegfxTileUtils.TileSize; for (int x = leftXIndex; x <= rightXIndex; x++) { for (int y = topYIndex; y <= bottomYIndex; y++) { TileIndex index = new TileIndex((ushort)x, (ushort)y, (rect.X + rect.Width), (rect.Y + rect.Height)); if (!indexList.Contains(index) && IsIndexInScope(index)) { indexList.Add(index); } } } } return indexList.ToArray(); }
/// <summary> /// Get the different tiles of this surface /// </summary> /// <param name="bRgb">If true, check if Rgb data exist for specified frame; otherwise, check if Dwt data exist.</param> /// <returns>The array of different tiles.</returns> public TileIndex[] GetDiffIndexes(bool bRgb) { if (this.pendingUpdateIndexs != null && this.pendingUpdateIndexs.Length <= RdpegfxTileUtils.TileDiffMinCount) { return this.pendingUpdateIndexs; } if (CurrentFrame == null) return null; if (LastFrame == null) return this.pendingUpdateIndexs; List<TileIndex> diffIndexList = new List<TileIndex>(); for (int xIndex = 0; xIndex * RdpegfxTileUtils.TileSize < this.Width; xIndex++) { for (int yIndex = 0; yIndex * RdpegfxTileUtils.TileSize < this.Height; yIndex++) { TileIndex tIndex = new TileIndex((ushort)xIndex, (ushort)yIndex, this.Width, this.Height); if(CurrentFrame.IsIndexInScope(tIndex, bRgb)) { //diffIndexList.Add(tIndex); if (LastFrame != null && LastFrame.IsIndexInScope(tIndex, bRgb)) { if (bRgb) { RgbTile prvRgb = LastFrame.GetRgbTile(tIndex); RgbTile curRgb = CurrentFrame.GetRgbTile(tIndex); if (!curRgb.EqualsWith(prvRgb)) diffIndexList.Add(tIndex); } else { DwtTile prvDwt = LastFrame.GetDwt(tIndex); DwtTile curDwt = CurrentFrame.GetDwt(tIndex); if (!curDwt.EqualsWith(prvDwt)) diffIndexList.Add(tIndex); } } else { diffIndexList.Add(tIndex); } } } } return diffIndexList.ToArray(); }
/// <summary> /// Update the RGB data of the specified tile. /// </summary> /// <param name="index">The index of the tile.</param> /// <param name="dwtQ">The RGB data.</param> public void UpdateTileRgb(TileIndex index, RgbTile rgbT) { if (index.X * RdpegfxTileUtils.TileSize >= this.Width || index.Y * RdpegfxTileUtils.TileSize >= this.Height) return; lock (rgbTileDic) { if (rgbTileDic.ContainsKey(index)) { rgbTileDic[index] = rgbT; } else { rgbTileDic.Add(index, rgbT); } } }
/// <summary> /// Generate a surface from a bitmap, only update the specified tiles /// </summary> /// <param name="sId">The surface Id</param> /// <param name="bm">The original bitmap</param> /// <param name="changedTileIndexs">The indexes of the changed tiles</param> /// <returns>A surface instance</returns> public static SurfaceFrame GetFromImage(ushort sId, Bitmap bitmap, TileIndex[] changedTileIndexs) { SurfaceFrame surf = new SurfaceFrame(sId, (ushort)bitmap.Width, (ushort)bitmap.Height); foreach (TileIndex tIndex in changedTileIndexs) { RgbTile rgbTl = RgbTile.GetFromImage(bitmap, tIndex.X * RdpegfxTileUtils.TileSize, tIndex.Y * RdpegfxTileUtils.TileSize); surf.rgbTileDic.Add(tIndex, rgbTl); } return surf; }
/// <summary> /// Update the tri-state of a tile /// </summary> /// <param name="index">The tile index</param> /// <param name="stat">The tri-state of the specified tile</param> public void UpdateTriState(TileIndex index, DwtTile stat) { if (index.X * RdpegfxTileUtils.TileSize >= this.Width || index.Y * RdpegfxTileUtils.TileSize >= this.Height) return; lock (triStateDic) { if (triStateDic.ContainsKey(index)) { triStateDic[index] = stat; } else { triStateDic.Add(index, stat); } } }
/// <summary> /// Get all the tile indexes in this surface /// </summary> /// <returns>TileIndex array.</returns> public TileIndex[] GetAllIndexes() { List<TileIndex> indexList = new List<TileIndex>(); for (int xIndex = 0; xIndex * RdpegfxTileUtils.TileSize < this.Width; xIndex++) { for (int yIndex = 0; yIndex * RdpegfxTileUtils.TileSize < this.Height; yIndex++) { TileIndex tIndex = new TileIndex((ushort)xIndex, (ushort)yIndex, this.Width, this.Height); // set tile width and height if ((xIndex + 1) * RdpegfxTileUtils.TileSize > this.Width) tIndex.WidthInSurface = (byte)(this.Width - xIndex * RdpegfxTileUtils.TileSize); else tIndex.WidthInSurface = RdpegfxTileUtils.TileSize; if ((yIndex + 1) * RdpegfxTileUtils.TileSize > this.Height) tIndex.HeightInSurface = (byte)(this.Height - yIndex * RdpegfxTileUtils.TileSize); else tIndex.HeightInSurface = RdpegfxTileUtils.TileSize; indexList.Add(tIndex); } } return indexList.ToArray(); }
/// <summary> /// constructor, create RFX_Progressive_TILE_SIMPLE block /// </summary> /// <param name="quantIdx">This is used to indicate index in TS_RFX_CODEC_AUANT array of region block</param> /// <param name="tileIdx">This is used to indicate tile position([x, y]).</param> /// <param name="tileData">This is used to indicate encoded tile data</param> public RFX_Progressive_TILE_SIMPLE(byte quantIdx, TileIndex tileIdx, EncodedTile tileData) { this.blockType = RFXProgCodecBlockType.WBT_TILE_SIMPLE; this.blockLen = 6; // common part 6 bytes this.quantIdxY = quantIdx; this.quantIdxCb = quantIdx; this.quantIdxCr = quantIdx; this.xIdx = tileIdx.X; this.yIdx = tileIdx.Y; this.flags = tileData.IsDifferenceTile; this.blockLen += 8; this.yLen = (tileData.YEncodedData == null) ? (ushort)0 : (ushort)tileData.YEncodedData.Count(); this.yData = tileData.YEncodedData; this.blockLen += (uint)(2 + this.yLen); this.cbLen = (tileData.CbEncodedData == null) ? (ushort)0 : (ushort)tileData.CbEncodedData.Count(); this.cbData = tileData.CbEncodedData; this.blockLen += (uint)(2 + this.cbLen); this.crLen = (tileData.CrEncodedData == null) ? (ushort)0 : (ushort)tileData.CrEncodedData.Count(); this.crData = tileData.CrEncodedData; this.blockLen += (uint)(2 + this.crLen); //this.tailLen = 8; //this.tailData = new byte[8]{0x4C, 0x41, 0x01, 0x00, 0xFF, 0xFF, 0x00, 0x10}; this.tailLen = 0; this.tailData = null; this.blockLen += (uint)(2 + this.tailLen); }
/// <summary> /// Get the coefficients for the same tile of last frame after DWT and Quantization. /// </summary> /// <param name="index">The index of the tile.</param> public DwtTile GetDwt(TileIndex index) { if (dwtQDic.ContainsKey(index)) { return dwtQDic[index]; } else { return null; } }
/// <summary> /// Build tile data blocks(tile simple or tile first or tile upgrade). /// </summary> /// <param name="quantIdx">This is used to indicate index in TS_RFX_CODEC_QUANT array of region block</param> /// <param name="tileIdx">This is used to indicate the tile index.</param> /// <param name="tileData">This is used to indicate the encoded tile data.</param> /// <param name="tileBlockType">This is used to indicate the tile data block type(simple, first, or upgrade).</param> public RFX_Progressive_DataBlock BuildTileDataBlock(byte quantIdx, TileIndex tileIdx, EncodedTile tileData, RFXProgCodecBlockType tileBlockType) { RFX_Progressive_DataBlock tile_block; if (tileBlockType == RFXProgCodecBlockType.WBT_TILE_PROGRESSIVE_FIRST) { tile_block = new RFX_Progressive_TILE_FIRST(quantIdx, tileIdx, tileData); } else if (tileBlockType == RFXProgCodecBlockType.WBT_TILE_PROGRESSIVE_UPGRADE) { tile_block = new RFX_PROGRESSIVE_TILE_UPGRADE(quantIdx, tileIdx, tileData); } else { tile_block = new RFX_Progressive_TILE_SIMPLE(quantIdx, tileIdx, tileData); } return tile_block; }
/// <summary> /// Constructor /// </summary> /// <param name="surface">The surface contains this tile</param> /// <param name="index">The index of this tile in surface</param> public TileState(Surface surface, TileIndex index) { NewFrame = surface.CurrentFrame; LastFrame = surface.LastFrame; Index = index; }