//Compute the difference tile dwt
public static void SubBandDiffing_DT(RfxProgressiveCodecContext encodingContext, TileState enTileInfo)
{
if (encodingContext.UseDifferenceTile)
{
DwtTile oldDwt = enTileInfo.GetOldDwt();
if (oldDwt != null)
{
short[] yDiffDwt, cbDiffDwt, crDiffDwt;
int lenOfNonLL3Band = (RdpegfxTileUtils.ComponentElementCount - RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, encodingContext.UseReduceExtrapolate));// ? 81 : 64;
int yNewZeroCount, cbNewZeroCount, crNewZeroCount;
int yDiffZeroCount, cbDiffZeroCount, crDiffZeroCount;
yDiffDwt = RdpegfxTileUtils.SubDiffingDwt(encodingContext.YComponent, oldDwt.Y_DwtQ, lenOfNonLL3Band, out yNewZeroCount, out yDiffZeroCount);
cbDiffDwt = RdpegfxTileUtils.SubDiffingDwt(encodingContext.CbComponent, oldDwt.Cb_DwtQ, lenOfNonLL3Band, out cbNewZeroCount, out cbDiffZeroCount);
crDiffDwt = RdpegfxTileUtils.SubDiffingDwt(encodingContext.CrComponent, oldDwt.Cr_DwtQ, lenOfNonLL3Band, out crNewZeroCount, out crDiffZeroCount);
if ((yDiffDwt != null && cbDiffDwt != null && crDiffDwt != null) &&
(yNewZeroCount + cbNewZeroCount + crNewZeroCount < yDiffZeroCount + cbDiffZeroCount + crDiffZeroCount))
{//use difference tile
encodingContext.YComponent = yDiffDwt;
encodingContext.CbComponent = cbDiffDwt;
encodingContext.CrComponent = crDiffDwt;
return;
}
}
}
encodingContext.UseDifferenceTile = false;//use orginal tile
}
/// <summary>
/// Create an instance from the given DWT data
/// </summary>
/// <param name="data">The linearization DWT data</param>
/// <param name="useReduceExtrapolate">Indicates if Reduce-Extrapolate method used in DWT</param>
/// <returns>A DWTBands instance</returns>
public static DwtBands GetFromLinearizationResult(short[] data, bool useReduceExtrapolate)
{
int curIdx = 0;
DwtBands bDwt = new DwtBands();
bDwt.HL1 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.HL1, useReduceExtrapolate)];
bDwt.LH1 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.LH1, useReduceExtrapolate)];
bDwt.HH1 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.HH1, useReduceExtrapolate)];
bDwt.HL2 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.HL2, useReduceExtrapolate)];
bDwt.LH2 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.LH2, useReduceExtrapolate)];
bDwt.HH2 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.HH2, useReduceExtrapolate)];
bDwt.HL3 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.HL3, useReduceExtrapolate)];
bDwt.LH3 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.LH3, useReduceExtrapolate)];
bDwt.HH3 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.HH3, useReduceExtrapolate)];
bDwt.LL3 = new short[RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, useReduceExtrapolate)];
Array.Copy(data, curIdx, bDwt.HL1, 0, bDwt.HL1.Length); curIdx += bDwt.HL1.Length;
Array.Copy(data, curIdx, bDwt.LH1, 0, bDwt.LH1.Length); curIdx += bDwt.LH1.Length;
Array.Copy(data, curIdx, bDwt.HH1, 0, bDwt.HH1.Length); curIdx += bDwt.HH1.Length;
Array.Copy(data, curIdx, bDwt.HL2, 0, bDwt.HL2.Length); curIdx += bDwt.HL2.Length;
Array.Copy(data, curIdx, bDwt.LH2, 0, bDwt.LH2.Length); curIdx += bDwt.LH2.Length;
Array.Copy(data, curIdx, bDwt.HH2, 0, bDwt.HH2.Length); curIdx += bDwt.HH2.Length;
Array.Copy(data, curIdx, bDwt.HL3, 0, bDwt.HL3.Length); curIdx += bDwt.HL3.Length;
Array.Copy(data, curIdx, bDwt.LH3, 0, bDwt.LH3.Length); curIdx += bDwt.LH3.Length;
Array.Copy(data, curIdx, bDwt.HH3, 0, bDwt.HH3.Length); curIdx += bDwt.HH3.Length;
Array.Copy(data, curIdx, bDwt.LL3, 0, bDwt.LL3.Length); curIdx += bDwt.LL3.Length;
return(bDwt);
}
static DwtTile SetTriState(DwtTile inputTile, bool useReduceExtrapolate)
{
int ll3Len = RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, useReduceExtrapolate);
int ll3Idx = RdpegfxTileUtils.ComponentElementCount - ll3Len;
DwtTile stateTile = new DwtTile(
new short[RdpegfxTileUtils.ComponentElementCount], //y state
new short[RdpegfxTileUtils.ComponentElementCount], //cb state
new short[RdpegfxTileUtils.ComponentElementCount]); //cr state
for (int i = 0; i < RdpegfxTileUtils.ComponentElementCount; i++)
{
if (i < ll3Idx)
{
stateTile.Y_DwtQ[i] = (short)Math.Sign(inputTile.Y_DwtQ[i]);
stateTile.Cb_DwtQ[i] = (short)Math.Sign(inputTile.Cb_DwtQ[i]);
stateTile.Cr_DwtQ[i] = (short)Math.Sign(inputTile.Cr_DwtQ[i]);
}
else
{
stateTile.Y_DwtQ[i] = 1;
stateTile.Cb_DwtQ[i] = 1;
stateTile.Cr_DwtQ[i] = 1;
}
}
return(stateTile);
}
protected static void dequantization_Component(short[,] compontent, TS_RFX_CODEC_QUANT tsRfxCodecQuant, bool useReduceExtrapolate)
{
// Quantization factor: HL1, LH1, HH1, HL2, LH2, HH2, HL3, LH3, HH3, LL3
Hashtable scaleValueTable = new Hashtable();
int HL1_Factor = tsRfxCodecQuant.HL1_HH1 & 0x0f;
int LH1_Factor = (tsRfxCodecQuant.HH2_LH1 & 0xf0) >> 4;
int HH1_Factor = (tsRfxCodecQuant.HL1_HH1 & 0xf0) >> 4;
int HL2_Factor = (tsRfxCodecQuant.LH2_HL2 & 0xf0) >> 4;
int LH2_Factor = tsRfxCodecQuant.LH2_HL2 & 0x0f;
int HH2_Factor = tsRfxCodecQuant.HH2_LH1 & 0x0f;
int HL3_Factor = tsRfxCodecQuant.HL3_HH3 & 0x0f;
int LH3_Factor = (tsRfxCodecQuant.LL3_LH3 & 0xf0) >> 4;
int HH3_Factor = (tsRfxCodecQuant.HL3_HH3 & 0xf0) >> 4;
int LL3_Factor = tsRfxCodecQuant.LL3_LH3 & 0x0f;
int[] HL_Factor = { HL1_Factor, HL2_Factor, HL3_Factor };
int[] LH_Factor = { LH1_Factor, LH2_Factor, LH3_Factor };
int[] HH_Factor = { HH1_Factor, HH2_Factor, HH3_Factor };
BandType_Values[] bandArr = new BandType_Values[] { BandType_Values.HL1, BandType_Values.LH1, BandType_Values.HH1, BandType_Values.HL2, BandType_Values.LH2, BandType_Values.HH2, BandType_Values.HL3, BandType_Values.LH3, BandType_Values.HH3, BandType_Values.LL3 };
int[] bandFactor = new int[] { HL1_Factor, LH1_Factor, HH1_Factor, HL2_Factor, LH2_Factor, HH2_Factor, HL3_Factor, LH3_Factor, HH3_Factor, LL3_Factor };
for (int i = 0; i < bandArr.Length; i++)
{
BandRect br = RdpegfxTileUtils.GetBandRect(bandArr[i], useReduceExtrapolate);
doDequantization_Subband(compontent, br.left, br.top, br.right, br.bottom, bandFactor[i]);
}
}
/// <summary>
/// Encode the surface with Progressive Codec
/// </summary>
/// <param name="quality">The target encoded quality.</param>
/// <param name="bProg">Indicates if encode progressively</param>
/// <param name="bSubDiff">Indicates if sub-diffing with last frame of this surface</param>
/// <param name="bReduceExtrapolate">Indicates if use Reduce Extrapolate method in DWT step.</param>
/// <returns>The dictionary of tile index and encoded tile datas.</returns>
public Dictionary <TileIndex, EncodedTile[]> ProgressiveEncode(ImageQuality_Values quality, bool bProg, bool bSubDiff, bool bReduceExtrapolate, bool ignoreUnchangedTile = true)
{
Dictionary <TileIndex, EncodedTile[]> encodedTileDic = new Dictionary <TileIndex, EncodedTile[]>();
TS_RFX_CODEC_QUANT quant = RdpegfxTileUtils.GetCodecQuant(quality);
TileIndex[] tileIndexArr;
if (!ignoreUnchangedTile)
{
tileIndexArr = GetAllIndexes();
}
else
{
tileIndexArr = GetDiffIndexes(true);
}
foreach (TileIndex index in tileIndexArr)
{
RfxProgressiveCodecContext codecContext = new RfxProgressiveCodecContext(
new TS_RFX_CODEC_QUANT[] { quant },
0, // quantization index of Y, set this paramter to 0 since only one quantization value in the array
0, // quantization index of Cb
0, // quantization index of Cr
bProg, //progressive
bSubDiff, //sub-diffing
bReduceExtrapolate); //reduce extrapolate
TileState tState = new TileState(this, index);
encodedTileDic.Add(index, RfxProgressiveEncoder.EncodeTile(codecContext, tState));
}
return(encodedTileDic);
}
static void DTS_Band(short[] bandData, BandType_Values band, TileComponents component, RFX_PROGRESSIVE_CODEC_QUANT quants)
{
int bitPos = RdpegfxTileUtils.GetBitPosForQuant(quants, component, band);
for (int i = 0; i < bandData.Length; i++)
{
bandData[i] = FunDTS(bandData[i], bitPos, band);
}
}
static void DTS_Band(short[] bandData, BandType_Values band, TileComponents component, ProgressiveChunk_Values chunk)
{
int bitPos = RdpegfxTileUtils.GetBitPosForChunk(chunk, component, band);
for (int i = 0; i < bandData.Length; i++)
{
bandData[i] = FunDTS(bandData[i], bitPos, band);
}
}
protected static void ProgressiveDeQuantization_Component(short[] data, RFX_COMPONMENT_CODEC_QUANT quant, bool useReduceExtrapolate)
{
int bitPos = 0;
for (int i = 0; i < RdpegfxTileUtils.ComponentElementCount; i++)
{
BandType_Values band = RdpegfxTileUtils.GetBandByIndex(i, useReduceExtrapolate);
bitPos = RdpegfxTileUtils.GetBitPosFromQuant(quant, band);
data[i] = FunProgDeQ(data[i], bitPos, band);
}
}
public static void ComputeOriginalLL3FromDeltas(RfxProgressiveCodecContext codecContext)
{
int ll3Len = RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, codecContext.UseReduceExtrapolate);
int ll3Idx = RdpegfxTileUtils.ComponentElementCount - ll3Len;
for (int i = ll3Idx + 1; i < RdpegfxTileUtils.ComponentElementCount; i++)
{
codecContext.YComponent[i] = (short)(codecContext.YComponent[i] + codecContext.YComponent[i - 1]);
codecContext.CbComponent[i] = (short)(codecContext.CbComponent[i] + codecContext.CbComponent[i - 1]);
codecContext.CrComponent[i] = (short)(codecContext.CrComponent[i] + codecContext.CrComponent[i - 1]);
}
}
public static void ComputeLL3Deltas(RfxProgressiveCodecContext encodingContext)
{
int ll3Len = RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, encodingContext.UseReduceExtrapolate);
int ll3Idx = RdpegfxTileUtils.ComponentElementCount - ll3Len;
//for (int i = ll3Idx + 1; i < TileUtils.ComponentElementCount; i++)
for (int i = RdpegfxTileUtils.ComponentElementCount - 1; i >= ll3Idx + 1; i--)
{
encodingContext.YComponent[i] = (short)(encodingContext.YComponent[i] - encodingContext.YComponent[i - 1]);
encodingContext.CbComponent[i] = (short)(encodingContext.CbComponent[i] - encodingContext.CbComponent[i - 1]);
encodingContext.CrComponent[i] = (short)(encodingContext.CrComponent[i] - encodingContext.CrComponent[i - 1]);
}
}
/// <summary>
/// Consturctor
/// </summary>
/// <param name="tsRfxCodecQuantVals">Codec quantity values array</param>
/// <param name="quantIdxY">Index of Y component in quantity array</param>
/// <param name="quantIdxCb">Index of Cb component in quantity array</param>
/// <param name="quantIdxCr">Index of Cr component in quantity array</param>
/// <param name="bProgressive">indicates if use progressive codec</param>
/// <param name="bTileDiff">indicates if sub-diffing</param>
/// <param name="bReduceExtrapolate">Indicates if use Reduce-Extrapolate method in DWT</param>
public RfxProgressiveCodecContext(
TS_RFX_CODEC_QUANT[] tsRfxCodecQuantVals,
byte quantIdxY,
byte quantIdxCb,
byte quantIdxCr,
bool bProgressive = false,
bool bTileDiff = true,
bool bReduceExtrapolate = true)
: base(tsRfxCodecQuantVals, quantIdxY, quantIdxCb, quantIdxCr, EntropyAlgorithm.CLW_ENTROPY_RLGR1)
{
UseProgressive = bProgressive;
UseDifferenceTile = bTileDiff;
UseReduceExtrapolate = bReduceExtrapolate;
prevProgQuant = RdpegfxTileUtils.GetProgCodecQuant(ProgressiveChunk_Values.kChunk_None);
}
public static void reconstruction_Component(short[] component1D, out short[,] compontent2D, bool useReduceExtrapolate)
{
//sequence: HL1, LH1, HH1, HL2, LH2, HH2, HL3, LH3, HH3, and LL3
//lineOutput = new short[TileSize * TileSize];
compontent2D = new short[RdpegfxTileUtils.TileSize, RdpegfxTileUtils.TileSize];
BandType_Values[] bandArr = new BandType_Values[] { BandType_Values.HL1, BandType_Values.LH1, BandType_Values.HH1, BandType_Values.HL2, BandType_Values.LH2, BandType_Values.HH2, BandType_Values.HL3, BandType_Values.LH3, BandType_Values.HH3, BandType_Values.LL3 };
int offset = 0;
BandRect curBand;
for (int i = 0; i < bandArr.Length; i++)
{
curBand = RdpegfxTileUtils.GetBandRect(bandArr[i], useReduceExtrapolate);
reconstruction_SubBand(compontent2D, curBand.left, curBand.top, curBand.right, curBand.bottom, component1D, ref offset);
}
}
protected static void linearization_Compontent(short[,] compontent, bool useReduceExtrapolate, out short[] lineOutput)
{
//sequence: HL1, LH1, HH1, HL2, LH2, HH2, HL3, LH3, HH3, and LL3
lineOutput = new short[TileSize * TileSize];
int curIdx = 0;
BandType_Values[] bandArr = new BandType_Values[] { BandType_Values.HL1, BandType_Values.LH1, BandType_Values.HH1, BandType_Values.HL2, BandType_Values.LH2, BandType_Values.HH2, BandType_Values.HL3, BandType_Values.LH3, BandType_Values.HH3, BandType_Values.LL3 };
short[] bandOutput;
BandRect curBand;
for (int i = 0; i < bandArr.Length; i++)
{
curBand = RdpegfxTileUtils.GetBandRect(bandArr[i], useReduceExtrapolate);
linearization_SubBand(compontent, curBand.left, curBand.top, curBand.right, curBand.bottom, out bandOutput);
Array.Copy(bandOutput, 0, lineOutput, curIdx, bandOutput.Length);
curIdx += bandOutput.Length;
}
}
//SRLEncode
public static EncodedTile SRLEncode(RfxProgressiveCodecContext encodingContext, Rdpegfx.RFX_PROGRESSIVE_CODEC_QUANT progQuant)
{
SRLEncoder encoder = new SRLEncoder();
List <short> yDataToSrl = new List <short>();
List <short> cbDataToSrl = new List <short>();
List <short> crDataToSrl = new List <short>();
List <int> yDataToSrlBitLen = new List <int>();
List <int> cbDataToSrlBitLen = new List <int>();
List <int> crDataToSrlBitLen = new List <int>();
BitStream yRawBitStream = new BitStream();
BitStream cbRawBitStream = new BitStream();
BitStream crRawBitStream = new BitStream();
int nonLL3Len = RdpegfxTileUtils.ComponentElementCount - RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, encodingContext.UseReduceExtrapolate);
Rdpegfx.RFX_PROGRESSIVE_CODEC_QUANT prevProgQuant = encodingContext.prevProgQuant;
Rdpegfx.RFX_PROGRESSIVE_CODEC_QUANT curProgQuant = progQuant;
for (int i = 0; i < RdpegfxTileUtils.ComponentElementCount; i++)
{
BandType_Values band = RdpegfxTileUtils.GetBandByIndex(i, encodingContext.UseReduceExtrapolate);
int targetBitPos = RdpegfxTileUtils.GetBitPosFromQuant(curProgQuant.yQuantValues, band);
int prevBitPos = RdpegfxTileUtils.GetBitPosFromQuant(prevProgQuant.yQuantValues, band);
int bitCount = prevBitPos - targetBitPos;
if (bitCount > 0)
{
if (encodingContext.DAS.Y_DwtQ[i] == 0 && i < nonLL3Len)
{
yDataToSrl.Add(encodingContext.ProgQ.Y_DwtQ[i]);
yDataToSrlBitLen.Add(bitCount);
}
else
{
//Add raw data
yRawBitStream.WriteBits(bitCount, Math.Abs(encodingContext.ProgQ.Y_DwtQ[i]));
}
}
targetBitPos = RdpegfxTileUtils.GetBitPosFromQuant(curProgQuant.cbQuantValues, band);
prevBitPos = RdpegfxTileUtils.GetBitPosFromQuant(prevProgQuant.cbQuantValues, band);
bitCount = prevBitPos - targetBitPos;
if (bitCount > 0)
{
if (encodingContext.DAS.Cb_DwtQ[i] == 0 && i < nonLL3Len)
{
cbDataToSrl.Add(encodingContext.ProgQ.Cb_DwtQ[i]);
cbDataToSrlBitLen.Add(bitCount);
}
else
{
//Add raw data
cbRawBitStream.WriteBits(bitCount, Math.Abs(encodingContext.ProgQ.Cb_DwtQ[i]));
}
}
targetBitPos = RdpegfxTileUtils.GetBitPosFromQuant(curProgQuant.crQuantValues, band);
prevBitPos = RdpegfxTileUtils.GetBitPosFromQuant(curProgQuant.crQuantValues, band);
bitCount = prevBitPos - targetBitPos;
if (bitCount > 0)
{
if (encodingContext.DAS.Cr_DwtQ[i] == 0 && i < nonLL3Len)
{
crDataToSrl.Add(encodingContext.ProgQ.Cr_DwtQ[i]);
crDataToSrlBitLen.Add(bitCount);
}
else
{
//Add raw data
crRawBitStream.WriteBits(bitCount, Math.Abs(encodingContext.ProgQ.Cr_DwtQ[i]));
}
}
}
encodingContext.YData = encoder.Encode(yDataToSrl.ToArray(), yDataToSrlBitLen.ToArray());
encodingContext.CbData = encoder.Encode(cbDataToSrl.ToArray(), cbDataToSrlBitLen.ToArray());
encodingContext.CrData = encoder.Encode(crDataToSrl.ToArray(), crDataToSrlBitLen.ToArray());
EncodedTile ugTile = new EncodedTile();
ugTile.YEncodedData = (byte[])encodingContext.YData.Clone();
ugTile.CbEncodedData = (byte[])encodingContext.CbData.Clone();
ugTile.CrEncodedData = (byte[])encodingContext.CrData.Clone();
ugTile.YRawData = yRawBitStream.ToBytes();
ugTile.CbRawData = cbRawBitStream.ToBytes();
ugTile.CrRawData = crRawBitStream.ToBytes();
ugTile.DataType = EncodedTileType.UpgradePass;
ugTile.IsDifferenceTile = encodingContext.UseDifferenceTile;
ugTile.UseReduceExtrapolate = encodingContext.UseReduceExtrapolate;
ugTile.CodecQuantVals = encodingContext.CodecQuantVals;
ugTile.QuantIdxY = encodingContext.QuantIdxY;
ugTile.QuantIdxCb = encodingContext.QuantIdxCb;
ugTile.QuantIdxCr = encodingContext.QuantIdxCr;
ugTile.ProgCodecQuant = curProgQuant;
return(ugTile);
}
/// <summary>
/// Encode a Tile
/// </summary>
/// <param name="encodingContext">The tile encoding context</param>
/// <param name="enTileInfo">The tile to be encoded</param>
/// <returns>A array of CompressedTile which contains the encoded tiles</returns>
public static EncodedTile[] EncodeTile(RfxProgressiveCodecContext encodingContext, TileState enTileInfo)
{
EncodedTileType targetType = encodingContext.UseProgressive ? EncodedTileType.FirstPass : EncodedTileType.Simple;
//File RGB
FillRgbData(encodingContext, enTileInfo.GetRgb());
//Do color conversion
RemoteFXEncoder.RGBToYCbCr(encodingContext);
//Do DWT
if (encodingContext.UseReduceExtrapolate)
{
//Do DWT using UseReduce Extrapolate method
DWT(encodingContext);
}
else
{
RemoteFXEncoder.DWT(encodingContext);
}
//Do quantiztion
Quantization(encodingContext);
//Do linearization (LL3 delta not computed)
Linearization_NoLL3Delta(encodingContext);
//Update new DWT to tile
DwtTile dwt = new DwtTile(
(short[])encodingContext.YComponent.Clone(),
(short[])encodingContext.CbComponent.Clone(),
(short[])encodingContext.CrComponent.Clone(),
encodingContext.CodecQuantVals,
encodingContext.QuantIdxY,
encodingContext.QuantIdxCb,
encodingContext.QuantIdxCr,
encodingContext.UseReduceExtrapolate
);
enTileInfo.UpdateDwt(dwt);
//Sub-Band Diffing
if (encodingContext.UseDifferenceTile)
{
SubBandDiffing_DT(encodingContext, enTileInfo);
}
if (targetType == EncodedTileType.Simple)
{
ComputeLL3Deltas(encodingContext);
RemoteFXEncoder.RLGREncode(encodingContext);
EncodedTile cpTile = new EncodedTile();
cpTile.YEncodedData = (byte[])encodingContext.YData.Clone();
cpTile.CbEncodedData = (byte[])encodingContext.CbData.Clone();
cpTile.CrEncodedData = (byte[])encodingContext.CrData.Clone();
cpTile.DataType = EncodedTileType.Simple;
cpTile.IsDifferenceTile = encodingContext.UseDifferenceTile;
cpTile.UseReduceExtrapolate = encodingContext.UseReduceExtrapolate;
cpTile.CodecQuantVals = encodingContext.CodecQuantVals;
cpTile.QuantIdxY = encodingContext.QuantIdxY;
cpTile.QuantIdxCb = encodingContext.QuantIdxCb;
cpTile.QuantIdxCr = encodingContext.QuantIdxCr;
cpTile.ProgCodecQuant = null;
return(new EncodedTile[] { cpTile });
}
else
{
List <EncodedTile> progCTileList = new List <EncodedTile>();
//Init DRS, DAS
encodingContext.DRS = new DwtTile(encodingContext.YComponent, encodingContext.CbComponent, encodingContext.CrComponent);
encodingContext.DAS = new DwtTile(new short[RdpegfxTileUtils.ComponentElementCount], new short[RdpegfxTileUtils.ComponentElementCount], new short[RdpegfxTileUtils.ComponentElementCount]);
#region Chunk 25, first pass
ProgressiveQuantization(encodingContext, ProgressiveChunk_Values.kChunk_25);
//Compute ProgQ LL3 deltas
encodingContext.YComponent = encodingContext.ProgQ.Y_DwtQ;
encodingContext.CbComponent = encodingContext.ProgQ.Cb_DwtQ;
encodingContext.CrComponent = encodingContext.ProgQ.Cr_DwtQ;
ComputeLL3Deltas(encodingContext);
RemoteFXEncoder.RLGREncode(encodingContext);
EncodedTile firstPassTile = new EncodedTile();
firstPassTile.YEncodedData = (byte[])encodingContext.YData.Clone();
firstPassTile.CbEncodedData = (byte[])encodingContext.CbData.Clone();
firstPassTile.CrEncodedData = (byte[])encodingContext.CrData.Clone();
firstPassTile.DataType = EncodedTileType.FirstPass;
firstPassTile.IsDifferenceTile = encodingContext.UseDifferenceTile;
firstPassTile.UseReduceExtrapolate = encodingContext.UseReduceExtrapolate;
firstPassTile.CodecQuantVals = encodingContext.CodecQuantVals;
firstPassTile.QuantIdxY = encodingContext.QuantIdxY;
firstPassTile.QuantIdxCb = encodingContext.QuantIdxCb;
firstPassTile.QuantIdxCr = encodingContext.QuantIdxCr;
firstPassTile.ProgCodecQuant = RdpegfxTileUtils.GetProgCodecQuant(ProgressiveChunk_Values.kChunk_25);
progCTileList.Add(firstPassTile);
encodingContext.prevProgQuant = RdpegfxTileUtils.GetProgCodecQuant(ProgressiveChunk_Values.kChunk_25);
//Update DRS
encodingContext.DRS.Sub(encodingContext.DTS);
//Update DAS
encodingContext.DAS.Add(encodingContext.DTS);
#endregion
#region Chunk 50,75,100, upgrade pass
ProgressiveChunk_Values[] upgradeChunks = { ProgressiveChunk_Values.kChunk_50, ProgressiveChunk_Values.kChunk_75, ProgressiveChunk_Values.kChunk_100 };
foreach (ProgressiveChunk_Values tChunk in upgradeChunks)
{
ProgressiveQuantization(encodingContext, tChunk);
RFX_PROGRESSIVE_CODEC_QUANT progquant = RdpegfxTileUtils.GetProgCodecQuant(tChunk);
progCTileList.Add(SRLEncode(encodingContext, progquant));
//Update DRS
encodingContext.DRS.Sub(encodingContext.DTS);
//Update DAS
encodingContext.DAS.Add(encodingContext.DTS);
encodingContext.prevProgQuant = progquant;
}
return(progCTileList.ToArray());
#endregion
}
}
public static void SRLDecode(RfxProgressiveCodecContext codecContext, EncodedTile enTile, TileState tState)
{
SRLDecoder yDecoder = null;
SRLDecoder cbDecoder = null;
SRLDecoder crDecoder = null;
List <short> yData = new List <short>();
List <short> cbData = new List <short>();
List <short> crData = new List <short>();
DwtTile triState = tState.GetTriState();
RFX_PROGRESSIVE_CODEC_QUANT prvProgQuant = tState.GetDwt().ProgCodecQuant;
int nonLL3Len = RdpegfxTileUtils.ComponentElementCount - RdpegfxTileUtils.GetBandSize(BandType_Values.LL3, enTile.UseReduceExtrapolate);
if (enTile.YEncodedData != null)
{
yDecoder = new SRLDecoder(enTile.YEncodedData);
}
if (enTile.CbEncodedData != null)
{
cbDecoder = new SRLDecoder(enTile.CbEncodedData);
}
if (enTile.CrEncodedData != null)
{
crDecoder = new SRLDecoder(enTile.CrEncodedData);
}
BitStream yRaw = BitStream.GetFromBytes(enTile.YRawData);
BitStream cbRaw = BitStream.GetFromBytes(enTile.CbRawData);
BitStream crRaw = BitStream.GetFromBytes(enTile.CrRawData);
for (int i = 0; i < RdpegfxTileUtils.ComponentElementCount; i++)
{
BandType_Values band = RdpegfxTileUtils.GetBandByIndex(i, enTile.UseReduceExtrapolate);
//Y
int curBitPos = RdpegfxTileUtils.GetBitPosFromQuant(enTile.ProgCodecQuant.yQuantValues, band);
int prvBitPos = RdpegfxTileUtils.GetBitPosFromQuant(prvProgQuant.yQuantValues, band);
int bitCount = prvBitPos - curBitPos;
int sign = triState.Y_DwtQ[i];
if (bitCount > 0)
{
if (sign == 0 && i < nonLL3Len)
{
if (yDecoder != null)
{
short?decodedValue = yDecoder.DecodeOne(bitCount);
if (decodedValue.HasValue)
{
yData.Add(decodedValue.Value);
}
else
{
yData.Add(0);
}
}
else
{
yData.Add(0);
}
}
else
{
int output;
if (yRaw.ReadInt32(bitCount, out output))
{
if (sign < 0 && i < nonLL3Len)
{
output = -output;
}
yData.Add((short)output);
}
else
{
yData.Add(0);
}
}
}
else
{
yData.Add(0);
}
//Cb
curBitPos = RdpegfxTileUtils.GetBitPosFromQuant(enTile.ProgCodecQuant.cbQuantValues, band);
prvBitPos = RdpegfxTileUtils.GetBitPosFromQuant(prvProgQuant.cbQuantValues, band);
bitCount = prvBitPos - curBitPos;
sign = triState.Cb_DwtQ[i];
if (bitCount > 0)
{
if (sign == 0 && i < nonLL3Len)
{
if (cbDecoder != null)
{
short?decodedValue = cbDecoder.DecodeOne(bitCount);
if (decodedValue.HasValue)
{
cbData.Add(decodedValue.Value);
}
else
{
cbData.Add(0);
}
}
else
{
cbData.Add(0);
}
}
else
{
int output;
if (cbRaw.ReadInt32(bitCount, out output))
{
if (sign < 0 && i < nonLL3Len)
{
output = -output;
}
cbData.Add((short)output);
}
else
{
cbData.Add(0);
}
}
}
else
{
cbData.Add(0);
}
//cr
curBitPos = RdpegfxTileUtils.GetBitPosFromQuant(enTile.ProgCodecQuant.crQuantValues, band);
prvBitPos = RdpegfxTileUtils.GetBitPosFromQuant(prvProgQuant.crQuantValues, band);
bitCount = prvBitPos - curBitPos;
sign = triState.Cr_DwtQ[i];
if (bitCount > 0)
{
if (sign == 0 && i < nonLL3Len)
{
if (crDecoder != null)
{
short?decodedValue = crDecoder.DecodeOne(bitCount);
if (decodedValue.HasValue)
{
crData.Add(decodedValue.Value);
}
else
{
crData.Add(0);
}
}
else
{
crData.Add(0);
}
}
else
{
int output;
if (crRaw.ReadInt32(bitCount, out output))
{
if (sign < 0 && i < nonLL3Len)
{
output = -output;
}
crData.Add((short)output);
}
else
{
crData.Add(0);
}
}
}
else
{
crData.Add(0);
}
}
codecContext.YComponent = yData.ToArray();
codecContext.CbComponent = cbData.ToArray();
codecContext.CrComponent = crData.ToArray();
}