mirror of https://github.com/SixLabors/ImageSharp
Ynse Hoornenborg
2 years ago
5 changed files with 912 additions and 797 deletions
@ -0,0 +1,862 @@ |
|||||
|
// Copyright (c) Six Labors.
|
||||
|
// Licensed under the Six Labors Split License.
|
||||
|
|
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Prediction; |
||||
|
using SixLabors.ImageSharp.Formats.Heif.Av1.Quantization; |
||||
|
|
||||
|
namespace SixLabors.ImageSharp.Formats.Heif.Av1.Symbol; |
||||
|
|
||||
|
internal class Av1TileDecoder : IAv1TileDecoder |
||||
|
{ |
||||
|
private static readonly int[] SgrprojXqdMid = [-32, 31]; |
||||
|
private static readonly int[] WienerTapsMid = [3, -7, 15]; |
||||
|
private const int PartitionProbabilitySet = 4; |
||||
|
|
||||
|
private int[] deltaLoopFilter = []; |
||||
|
private bool[][][] blockDecoded = []; |
||||
|
private int[][] referenceSgrXqd = []; |
||||
|
private int[][][] referenceLrWiener = []; |
||||
|
private bool availableUp; |
||||
|
private bool availableLeft; |
||||
|
private bool availableUpForChroma; |
||||
|
private bool availableLeftForChroma; |
||||
|
private Av1ParseAboveContext aboveContext = new(); |
||||
|
private Av1ParseLeftContext leftContext = new(); |
||||
|
private bool skip; |
||||
|
private bool readDeltas; |
||||
|
private int currentQuantizerIndex; |
||||
|
private Av1PredictionMode[][] yModes = []; |
||||
|
private Av1PredictionMode yMode = Av1PredictionMode.DC; |
||||
|
private Av1PredictionMode uvMode = Av1PredictionMode.DC; |
||||
|
private Av1PredictionMode[][] uvModes = []; |
||||
|
private object[] referenceFrame = []; |
||||
|
private object[][][] referenceFrames = []; |
||||
|
private int paletteSizeY; |
||||
|
private int paletteSizeUv; |
||||
|
private object[][] aboveLevelContext = []; |
||||
|
private object[][] aboveDcContext = []; |
||||
|
private object[][] leftLevelContext = []; |
||||
|
private object[][] leftDcContext = []; |
||||
|
private Av1TransformSize transformSize = Av1TransformSize.Size4x4; |
||||
|
private object filterUltraMode = -1; |
||||
|
private int angleDeltaY; |
||||
|
private int angleDeltaUv; |
||||
|
private bool lossless; |
||||
|
private int[][] segmentIds = []; |
||||
|
private int maxLumaWidth; |
||||
|
private int maxLumaHeight; |
||||
|
private int segmentId; |
||||
|
private int[][] cdefIndex = []; |
||||
|
private int deltaLoopFilterResolution = -1; |
||||
|
private int deltaQuantizerResolution = -1; |
||||
|
|
||||
|
public Av1TileDecoder(ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, ObuTileInfo tileInfo) |
||||
|
{ |
||||
|
this.FrameInfo = frameInfo; |
||||
|
this.SequenceHeader = sequenceHeader; |
||||
|
this.TileInfo = tileInfo; |
||||
|
} |
||||
|
|
||||
|
public bool SequenceHeaderDone { get; set; } |
||||
|
|
||||
|
public bool ShowExistingFrame { get; set; } |
||||
|
|
||||
|
public bool SeenFrameHeader { get; set; } |
||||
|
|
||||
|
public ObuFrameHeader FrameInfo { get; } |
||||
|
|
||||
|
public ObuSequenceHeader SequenceHeader { get; } |
||||
|
|
||||
|
public ObuTileInfo TileInfo { get; } |
||||
|
|
||||
|
public void DecodeTile(Span<byte> tileData, int tileNum) |
||||
|
{ |
||||
|
Av1SymbolDecoder reader = new(tileData); |
||||
|
int tileRowIndex = tileNum / this.TileInfo.TileColumnCount; |
||||
|
int tileColumnIndex = tileNum % this.TileInfo.TileColumnCount; |
||||
|
this.aboveContext.Clear(); |
||||
|
this.ClearLoopFilterDelta(); |
||||
|
int planesCount = this.SequenceHeader.ColorConfig.ChannelCount; |
||||
|
this.referenceSgrXqd = new int[planesCount][]; |
||||
|
this.referenceLrWiener = new int[planesCount][][]; |
||||
|
for (int plane = 0; plane < planesCount; plane++) |
||||
|
{ |
||||
|
this.referenceSgrXqd[plane] = new int[2]; |
||||
|
Array.Copy(SgrprojXqdMid, this.referenceSgrXqd[plane], SgrprojXqdMid.Length); |
||||
|
this.referenceLrWiener[plane] = new int[2][]; |
||||
|
for (int pass = 0; pass < 2; pass++) |
||||
|
{ |
||||
|
this.referenceLrWiener[plane][pass] = new int[ObuConstants.WienerCoefficientCount]; |
||||
|
Array.Copy(WienerTapsMid, this.referenceLrWiener[plane][pass], WienerTapsMid.Length); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
Av1BlockSize superBlockSize = this.SequenceHeader.Use128x128SuperBlock ? Av1BlockSize.Block128x128 : Av1BlockSize.Block64x64; |
||||
|
int superBlock4x4Size = superBlockSize.Get4x4WideCount(); |
||||
|
for (int row = this.TileInfo.TileRowStartModeInfo[tileRowIndex]; row < this.TileInfo.TileRowStartModeInfo[tileRowIndex + 1]; row += this.SequenceHeader.ModeInfoSize) |
||||
|
{ |
||||
|
int superBlockRow = row << ObuConstants.ModeInfoSizeLog2 >> this.SequenceHeader.SuperBlockSizeLog2; |
||||
|
this.leftContext.Clear(); |
||||
|
for (int column = this.TileInfo.TileColumnStartModeInfo[tileColumnIndex]; column < this.TileInfo.TileColumnStartModeInfo[tileColumnIndex + 1]; column += this.SequenceHeader.ModeInfoSize) |
||||
|
{ |
||||
|
int superBlockColumn = column << ObuConstants.ModeInfoSizeLog2 >> this.SequenceHeader.SuperBlockSizeLog2; |
||||
|
bool subSamplingX = this.SequenceHeader.ColorConfig.SubSamplingX; |
||||
|
bool subSamplingY = this.SequenceHeader.ColorConfig.SubSamplingY; |
||||
|
|
||||
|
bool readDeltas = this.FrameInfo.DeltaQParameters.IsPresent; |
||||
|
|
||||
|
// Nothing to do for CDEF
|
||||
|
// this.ClearCdef(row, column);
|
||||
|
this.ClearBlockDecodedFlags(row, column, superBlock4x4Size); |
||||
|
this.ReadLoopRestoration(row, column, superBlockSize); |
||||
|
this.DecodePartition(ref reader, row, column, superBlockSize); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ClearLoopFilterDelta() => this.deltaLoopFilter = new int[4]; |
||||
|
|
||||
|
private void ClearBlockDecodedFlags(int row, int column, int superBlock4x4Size) |
||||
|
{ |
||||
|
int planesCount = this.SequenceHeader.ColorConfig.ChannelCount; |
||||
|
for (int plane = 0; plane < planesCount; plane++) |
||||
|
{ |
||||
|
int subX = plane > 0 && this.SequenceHeader.ColorConfig.SubSamplingX ? 1 : 0; |
||||
|
int subY = plane > 0 && this.SequenceHeader.ColorConfig.SubSamplingY ? 1 : 0; |
||||
|
int superBlock4x4Width = (this.FrameInfo.ModeInfoColumnCount - column) >> subX; |
||||
|
int superBlock4x4Height = (this.FrameInfo.ModeInfoRowCount - row) >> subY; |
||||
|
for (int y = -1; y <= superBlock4x4Size >> subY; y++) |
||||
|
{ |
||||
|
for (int x = -1; x <= superBlock4x4Size >> subX; x++) |
||||
|
{ |
||||
|
if (y < 0 && x < superBlock4x4Width) |
||||
|
{ |
||||
|
this.blockDecoded[plane][y][x] = true; |
||||
|
} |
||||
|
else if (x < 0 && y < superBlock4x4Height) |
||||
|
{ |
||||
|
this.blockDecoded[plane][y][x] = true; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
this.blockDecoded[plane][y][x] = false; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
int lastIndex = this.blockDecoded[plane][(superBlock4x4Size >> subY) - 1].Length - 1; |
||||
|
this.blockDecoded[plane][(superBlock4x4Size >> subY) - 1][lastIndex] = false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReadLoopRestoration(int row, int column, Av1BlockSize superBlockSize) |
||||
|
{ |
||||
|
int planesCount = this.SequenceHeader.ColorConfig.ChannelCount; |
||||
|
for (int plane = 0; plane < planesCount; plane++) |
||||
|
{ |
||||
|
if (this.FrameInfo.LoopRestorationParameters[plane].Type != ObuRestorationType.None) |
||||
|
{ |
||||
|
// TODO: Implement.
|
||||
|
throw new NotImplementedException("No loop restoration filter support."); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void FinishDecodeTiles(bool doCdef, bool doLoopRestoration) |
||||
|
{ |
||||
|
// TODO: Implement
|
||||
|
} |
||||
|
|
||||
|
private void DecodePartition(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
if (rowIndex >= this.TileInfo.TileRowStartModeInfo[rowIndex] || |
||||
|
columnIndex >= this.TileInfo.TileColumnStartModeInfo[columnIndex]) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
this.availableUp = this.IsInside(rowIndex - 1, columnIndex); |
||||
|
this.availableLeft = this.IsInside(rowIndex, columnIndex - 1); |
||||
|
int block4x4Size = blockSize.Get4x4WideCount(); |
||||
|
int halfBlock4x4Size = block4x4Size >> 1; |
||||
|
int quarterBlock4x4Size = halfBlock4x4Size >> 2; |
||||
|
bool hasRows = rowIndex + halfBlock4x4Size < this.TileInfo.TileRowCount; |
||||
|
bool hasColumns = columnIndex + halfBlock4x4Size < this.TileInfo.TileColumnCount; |
||||
|
Av1PartitionType partitionType = Av1PartitionType.Split; |
||||
|
if (blockSize < Av1BlockSize.Block8x8) |
||||
|
{ |
||||
|
partitionType = Av1PartitionType.None; |
||||
|
} |
||||
|
else if (hasRows && hasColumns) |
||||
|
{ |
||||
|
int ctx = this.GetPartitionContext(rowIndex, columnIndex, blockSize); |
||||
|
partitionType = reader.ReadPartitionType(ctx); |
||||
|
} |
||||
|
else if (hasColumns) |
||||
|
{ |
||||
|
int ctx = this.GetPartitionContext(rowIndex, columnIndex, blockSize); |
||||
|
bool splitOrHorizontal = reader.ReadSplitOrHorizontal(blockSize, ctx); |
||||
|
partitionType = splitOrHorizontal ? Av1PartitionType.Split : Av1PartitionType.Horizontal; |
||||
|
} |
||||
|
else if (hasRows) |
||||
|
{ |
||||
|
int ctx = this.GetPartitionContext(rowIndex, columnIndex, blockSize); |
||||
|
bool splitOrVertical = reader.ReadSplitOrVertical(blockSize, ctx); |
||||
|
partitionType = splitOrVertical ? Av1PartitionType.Split : Av1PartitionType.Vertical; |
||||
|
} |
||||
|
|
||||
|
Av1BlockSize subSize = partitionType.GetBlockSubSize(blockSize); |
||||
|
Av1BlockSize splitSize = Av1PartitionType.Split.GetBlockSubSize(blockSize); |
||||
|
switch (partitionType) |
||||
|
{ |
||||
|
case Av1PartitionType.Split: |
||||
|
this.DecodePartition(ref reader, rowIndex, columnIndex, subSize); |
||||
|
this.DecodePartition(ref reader, rowIndex, columnIndex + halfBlock4x4Size, subSize); |
||||
|
this.DecodePartition(ref reader, rowIndex + halfBlock4x4Size, columnIndex, subSize); |
||||
|
this.DecodePartition(ref reader, rowIndex + halfBlock4x4Size, columnIndex + halfBlock4x4Size, subSize); |
||||
|
break; |
||||
|
case Av1PartitionType.None: |
||||
|
this.DecodeBlock(ref reader, rowIndex, columnIndex, subSize); |
||||
|
break; |
||||
|
default: |
||||
|
throw new NotImplementedException($"Partition type: {partitionType} is not supported."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void DecodeBlock(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
int block4x4Width = blockSize.Get4x4WideCount(); |
||||
|
int block4x4Height = blockSize.Get4x4HighCount(); |
||||
|
int planesCount = this.SequenceHeader.ColorConfig.ChannelCount; |
||||
|
bool hasChroma = planesCount > 1; |
||||
|
if (block4x4Height == 1 && this.SequenceHeader.ColorConfig.SubSamplingY && (rowIndex & 0x1) == 0) |
||||
|
{ |
||||
|
hasChroma = false; |
||||
|
} |
||||
|
|
||||
|
if (block4x4Width == 1 && this.SequenceHeader.ColorConfig.SubSamplingX && (columnIndex & 0x1) == 0) |
||||
|
{ |
||||
|
hasChroma = false; |
||||
|
} |
||||
|
|
||||
|
this.availableUp = this.IsInside(rowIndex - 1, columnIndex); |
||||
|
this.availableLeft = this.IsInside(rowIndex, columnIndex - 1); |
||||
|
this.availableUpForChroma = this.availableUp; |
||||
|
this.availableLeftForChroma = this.availableLeft; |
||||
|
if (hasChroma) |
||||
|
{ |
||||
|
if (this.SequenceHeader.ColorConfig.SubSamplingY && block4x4Height == 1) |
||||
|
{ |
||||
|
this.availableUpForChroma = this.IsInside(rowIndex - 2, columnIndex); |
||||
|
} |
||||
|
|
||||
|
if (this.SequenceHeader.ColorConfig.SubSamplingX && block4x4Width == 1) |
||||
|
{ |
||||
|
this.availableLeftForChroma = this.IsInside(rowIndex, columnIndex - 2); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
this.ReadModeInfo(ref reader, rowIndex, columnIndex, blockSize); |
||||
|
this.ReadPaletteTokens(ref reader); |
||||
|
ReadBlockTransformSize(ref reader, rowIndex, columnIndex, blockSize); |
||||
|
if (this.skip) |
||||
|
{ |
||||
|
this.ResetBlockContext(rowIndex, columnIndex, blockSize); |
||||
|
} |
||||
|
|
||||
|
// bool isCompound = false;
|
||||
|
for (int y = 0; y < block4x4Height; y++) |
||||
|
{ |
||||
|
for (int x = 0; x < block4x4Width; x++) |
||||
|
{ |
||||
|
this.yModes[rowIndex + y][columnIndex + x] = this.yMode; |
||||
|
if (this.referenceFrame[0] == (object)ObuFrameType.IntraOnlyFrame && hasChroma) |
||||
|
{ |
||||
|
this.uvModes[rowIndex + y][columnIndex + x] = this.uvMode; |
||||
|
} |
||||
|
|
||||
|
for (int refList = 0; refList < 2; refList++) |
||||
|
{ |
||||
|
this.referenceFrames[rowIndex + y][columnIndex + x][refList] = this.referenceFrame[refList]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ComputePrediction(); |
||||
|
this.Residual(rowIndex, columnIndex, blockSize); |
||||
|
} |
||||
|
|
||||
|
private void Residual(int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
bool subsamplingX = this.SequenceHeader.ColorConfig.SubSamplingX; |
||||
|
bool subsamplingY = this.SequenceHeader.ColorConfig.SubSamplingY; |
||||
|
int superBlockMask = this.SequenceHeader.Use128x128SuperBlock ? 31 : 15; |
||||
|
int widthChunks = Math.Max(1, blockSize.Get4x4WideCount() >> 6); |
||||
|
int heightChunks = Math.Max(1, blockSize.Get4x4HighCount() >> 6); |
||||
|
Av1BlockSize sizeChunk = widthChunks > 1 || heightChunks > 1 ? Av1BlockSize.Block64x64 : blockSize; |
||||
|
|
||||
|
for (int chunkY = 0; chunkY < heightChunks; chunkY++) |
||||
|
{ |
||||
|
for (int chunkX = 0; chunkX < widthChunks; chunkX++) |
||||
|
{ |
||||
|
int rowChunk = rowIndex + (chunkY << 4); |
||||
|
int columnChunk = columnIndex + (chunkX << 4); |
||||
|
int subBlockRow = rowChunk & superBlockMask; |
||||
|
int subBlockColumn = columnChunk & superBlockMask; |
||||
|
for (int plane = 0; plane < 1 + (this.HasChroma(rowIndex, columnIndex, blockSize) ? 2 : 0); plane++) |
||||
|
{ |
||||
|
Av1TransformSize transformSize = this.FrameInfo.CodedLossless ? Av1TransformSize.Size4x4 : this.GetSize(plane, this.transformSize); |
||||
|
int stepX = transformSize.GetWidth() >> 2; |
||||
|
int stepY = transformSize.GetHeight() >> 2; |
||||
|
Av1BlockSize planeSize = this.GetPlaneResidualSize(sizeChunk, plane); |
||||
|
int num4x4Width = planeSize.Get4x4WideCount(); |
||||
|
int num4x4Height = planeSize.Get4x4HighCount(); |
||||
|
int subX = plane > 0 && subsamplingX ? 1 : 0; |
||||
|
int subY = plane > 0 && subsamplingY ? 1 : 0; |
||||
|
int baseX = (columnChunk >> subX) * (1 << ObuConstants.ModeInfoSizeLog2); |
||||
|
int baseY = (rowChunk >> subY) * (1 << ObuConstants.ModeInfoSizeLog2); |
||||
|
int baseXBlock = (columnIndex >> subX) * (1 << ObuConstants.ModeInfoSizeLog2); |
||||
|
int baseYBlock = (rowIndex >> subY) * (1 << ObuConstants.ModeInfoSizeLog2); |
||||
|
for (int y = 0; y < num4x4Height; y += stepY) |
||||
|
{ |
||||
|
for (int x = 0; x < num4x4Width; x += stepX) |
||||
|
{ |
||||
|
this.TransformBlock(plane, baseXBlock, baseYBlock, transformSize, x + (chunkX << 4 >> subX), y + (chunkY << 4 >> subY)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private bool HasChroma(int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
int bw = blockSize.Get4x4WideCount(); |
||||
|
int bh = blockSize.Get4x4HighCount(); |
||||
|
bool subX = this.SequenceHeader.ColorConfig.SubSamplingX; |
||||
|
bool subY = this.SequenceHeader.ColorConfig.SubSamplingY; |
||||
|
bool hasChroma = ((rowIndex & 0x01) != 0 || (bh & 0x01) == 0 || !subY) && |
||||
|
((columnIndex & 0x01) != 0 || (bw & 0x01) == 0 || !subX); |
||||
|
return hasChroma; |
||||
|
} |
||||
|
|
||||
|
private Av1TransformSize GetSize(int plane, object transformSize) => throw new NotImplementedException(); |
||||
|
|
||||
|
private Av1BlockSize GetPlaneResidualSize(Av1BlockSize sizeChunk, int plane) => throw new NotImplementedException(); |
||||
|
|
||||
|
private void TransformBlock(int plane, int baseX, int baseY, Av1TransformSize transformSize, int x, int y) |
||||
|
{ |
||||
|
int startX = (baseX + 4) * x; |
||||
|
int startY = (baseY + 4) * y; |
||||
|
bool subsamplingX = this.SequenceHeader.ColorConfig.SubSamplingX; |
||||
|
bool subsamplingY = this.SequenceHeader.ColorConfig.SubSamplingY; |
||||
|
int subX = plane > 0 && subsamplingX ? 1 : 0; |
||||
|
int subY = plane > 0 && subsamplingY ? 1 : 0; |
||||
|
int columnIndex = startX << subX >> ObuConstants.ModeInfoSizeLog2; |
||||
|
int rowIndex = startY << subY >> ObuConstants.ModeInfoSizeLog2; |
||||
|
int superBlockMask = this.SequenceHeader.Use128x128SuperBlock ? 31 : 15; |
||||
|
int subBlockColumn = columnIndex & superBlockMask; |
||||
|
int subBlockRow = rowIndex & superBlockMask; |
||||
|
int stepX = transformSize.GetWidth() >> ObuConstants.ModeInfoSizeLog2; |
||||
|
int stepY = transformSize.GetHeight() >> ObuConstants.ModeInfoSizeLog2; |
||||
|
int maxX = (this.SequenceHeader.ModeInfoSize * (1 << ObuConstants.ModeInfoSizeLog2)) >> subX; |
||||
|
int maxY = (this.SequenceHeader.ModeInfoSize * (1 << ObuConstants.ModeInfoSizeLog2)) >> subY; |
||||
|
if (startX >= maxX || startY >= maxY) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if ((plane == 0 && this.paletteSizeY > 0) || |
||||
|
(plane != 0 && this.paletteSizeUv > 0)) |
||||
|
{ |
||||
|
this.PredictPalette(plane, startX, startY, x, y, transformSize); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
bool isChromaFromLuma = plane > 0 && this.uvMode == Av1PredictionMode.UvChromaFromLuma; |
||||
|
Av1PredictionMode mode; |
||||
|
if (plane == 0) |
||||
|
{ |
||||
|
mode = this.yMode; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
mode = isChromaFromLuma ? Av1PredictionMode.DC : this.uvMode; |
||||
|
} |
||||
|
|
||||
|
int log2Width = transformSize.GetWidthLog2(); |
||||
|
int log2Height = transformSize.GetHeightLog2(); |
||||
|
bool leftAvailable = x > 0 || plane == 0 ? this.availableLeft : this.availableLeftForChroma; |
||||
|
bool upAvailable = y > 0 || plane == 0 ? this.availableUp : this.availableUpForChroma; |
||||
|
bool haveAboveRight = this.blockDecoded[plane][(subBlockRow >> subY) - 1][(subBlockColumn >> subX) + stepX]; |
||||
|
bool haveBelowLeft = this.blockDecoded[plane][(subBlockRow >> subY) + stepY][(subBlockColumn >> subX) - 1]; |
||||
|
this.PredictIntra(plane, startX, startY, leftAvailable, upAvailable, haveAboveRight, haveBelowLeft, mode, log2Width, log2Height); |
||||
|
if (isChromaFromLuma) |
||||
|
{ |
||||
|
this.PredictChromaFromLuma(plane, startX, startY, transformSize); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (plane == 0) |
||||
|
{ |
||||
|
this.maxLumaWidth = startX + (stepX * 4); |
||||
|
this.maxLumaHeight = startY + (stepY * 4); |
||||
|
} |
||||
|
|
||||
|
if (!this.skip) |
||||
|
{ |
||||
|
int eob = this.Coefficients(plane, startX, startY, transformSize); |
||||
|
if (eob > 0) |
||||
|
{ |
||||
|
this.Reconstruct(plane, startX, startY, transformSize); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < stepY; i++) |
||||
|
{ |
||||
|
for (int j = 0; j < stepX; j++) |
||||
|
{ |
||||
|
// Ignore loop filter.
|
||||
|
this.blockDecoded[plane][(subBlockRow >> subY) + i][(subBlockColumn >> subX) + j] = true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void Reconstruct(int plane, int startX, int startY, Av1TransformSize transformSize) => throw new NotImplementedException(); |
||||
|
|
||||
|
private int Coefficients(int plane, int startX, int startY, Av1TransformSize transformSize) => throw new NotImplementedException(); |
||||
|
|
||||
|
private void PredictChromaFromLuma(int plane, int startX, int startY, Av1TransformSize transformSize) => throw new NotImplementedException(); |
||||
|
|
||||
|
private void PredictIntra(int plane, int startX, int startY, bool leftAvailable, bool upAvailable, bool haveAboveRight, bool haveBelowLeft, Av1PredictionMode mode, int log2Width, int log2Height) => throw new NotImplementedException(); |
||||
|
|
||||
|
private void PredictPalette(int plane, int startX, int startY, int x, int y, Av1TransformSize transformSize) => throw new NotImplementedException(); |
||||
|
|
||||
|
private static void ComputePrediction() |
||||
|
{ |
||||
|
// Not applicable for INTRA frames.
|
||||
|
} |
||||
|
|
||||
|
private void ResetBlockContext(int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
int block4x4Width = blockSize.Get4x4WideCount(); |
||||
|
int block4x4Height = blockSize.Get4x4HighCount(); |
||||
|
bool subsamplingX = this.SequenceHeader.ColorConfig.SubSamplingX; |
||||
|
bool subsamplingY = this.SequenceHeader.ColorConfig.SubSamplingY; |
||||
|
int endPlane = this.HasChroma(rowIndex, columnIndex, blockSize) ? 3 : 1; |
||||
|
for (int plane = 0; plane < endPlane; plane++) |
||||
|
{ |
||||
|
int subX = plane > 0 && subsamplingX ? 1 : 0; |
||||
|
int subY = plane > 0 && subsamplingY ? 1 : 0; |
||||
|
for (int i = columnIndex >> subX; i < (columnIndex + block4x4Width) >> subX; i++) |
||||
|
{ |
||||
|
this.aboveLevelContext[plane][i] = 0; |
||||
|
this.aboveDcContext[plane][i] = 0; |
||||
|
} |
||||
|
|
||||
|
for (int i = rowIndex >> subY; i < (rowIndex + block4x4Height) >> subY; i++) |
||||
|
{ |
||||
|
this.leftLevelContext[plane][i] = 0; |
||||
|
this.leftDcContext[plane][i] = 0; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static void ReadBlockTransformSize(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
int block4x4Width = blockSize.Get4x4WideCount(); |
||||
|
int block4x4Height = blockSize.Get4x4HighCount(); |
||||
|
|
||||
|
// First condition in spec is for INTER frames, implemented only the INTRA condition.
|
||||
|
ReadBlockTransformSize(ref reader, rowIndex, columnIndex, blockSize); |
||||
|
/*for (int row = rowIndex; row < rowIndex + block4x4Height; row++) |
||||
|
{ |
||||
|
for (int column = columnIndex; column < columnIndex + block4x4Width; column++) |
||||
|
{ |
||||
|
this.InterTransformSizes[row][column] = this.TransformSize; |
||||
|
} |
||||
|
}*/ |
||||
|
} |
||||
|
|
||||
|
private void ReadPaletteTokens(ref Av1SymbolDecoder reader) |
||||
|
{ |
||||
|
reader.ReadLiteral(-1); |
||||
|
if (this.paletteSizeY != 0) |
||||
|
{ |
||||
|
// Todo: Implement.
|
||||
|
throw new NotImplementedException(); |
||||
|
} |
||||
|
|
||||
|
if (this.paletteSizeUv != 0) |
||||
|
{ |
||||
|
// Todo: Implement.
|
||||
|
throw new NotImplementedException(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReadModeInfo(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
=> this.ReadIntraFrameModeInfo(ref reader, rowIndex, columnIndex, blockSize); |
||||
|
|
||||
|
private void ReadIntraFrameModeInfo(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
this.skip = false; |
||||
|
if (this.FrameInfo.SegmentationParameters.SegmentIdPrecedesSkip) |
||||
|
{ |
||||
|
this.ReadIntraSegmentId(ref reader); |
||||
|
} |
||||
|
|
||||
|
// this.skipMode = false;
|
||||
|
this.ReadSkip(ref reader); |
||||
|
if (!this.FrameInfo.SegmentationParameters.SegmentIdPrecedesSkip) |
||||
|
{ |
||||
|
this.IntraSegmentId(ref reader, rowIndex, columnIndex); |
||||
|
} |
||||
|
|
||||
|
this.ReadCdef(ref reader, rowIndex, columnIndex, blockSize); |
||||
|
this.ReadDeltaQuantizerIndex(ref reader, blockSize); |
||||
|
this.ReadDeltaLoopFilter(ref reader, blockSize); |
||||
|
this.readDeltas = false; |
||||
|
this.referenceFrame[0] = -1; // IntraFrame;
|
||||
|
this.referenceFrame[1] = -1; // None;
|
||||
|
bool useIntraBlockCopy = false; |
||||
|
if (this.FrameInfo.AllowIntraBlockCopy) |
||||
|
{ |
||||
|
useIntraBlockCopy = reader.ReadUseIntraBlockCopy(); |
||||
|
} |
||||
|
|
||||
|
if (useIntraBlockCopy) |
||||
|
{ |
||||
|
// TODO: Implement
|
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
// this.IsInter = false;
|
||||
|
this.yMode = reader.ReadIntraFrameYMode(blockSize); |
||||
|
this.IntraAngleInfoY(ref reader, blockSize); |
||||
|
if (this.HasChroma(rowIndex, columnIndex, blockSize)) |
||||
|
{ |
||||
|
this.uvMode = reader.ReadUvMode(blockSize, this.IsChromaForLumaAllowed(blockSize)); |
||||
|
if (this.uvMode == Av1PredictionMode.UvChromaFromLuma) |
||||
|
{ |
||||
|
this.ReadChromaFromLumaAlphas(ref reader); |
||||
|
} |
||||
|
|
||||
|
this.IntraAngleInfoUv(ref reader, blockSize); |
||||
|
} |
||||
|
|
||||
|
this.paletteSizeY = 0; |
||||
|
this.paletteSizeUv = 0; |
||||
|
if (this.SequenceHeader.ModeInfoSize >= (int)Av1BlockSize.Block8x8 && |
||||
|
((Av1BlockSize)this.SequenceHeader.ModeInfoSize).Get4x4WideCount() <= 64 && |
||||
|
((Av1BlockSize)this.SequenceHeader.ModeInfoSize).Get4x4HighCount() <= 64 && |
||||
|
this.FrameInfo.AllowScreenContentTools) |
||||
|
{ |
||||
|
this.PaletteModeInfo(ref reader); |
||||
|
} |
||||
|
|
||||
|
this.FilterIntraModeInfo(ref reader, blockSize); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private bool IsChromaForLumaAllowed(Av1BlockSize blockSize) |
||||
|
{ |
||||
|
if (this.lossless) |
||||
|
{ |
||||
|
// In lossless, CfL is available when the partition size is equal to the
|
||||
|
// transform size.
|
||||
|
bool subX = this.SequenceHeader.ColorConfig.SubSamplingX; |
||||
|
bool subY = this.SequenceHeader.ColorConfig.SubSamplingY; |
||||
|
Av1BlockSize planeBlockSize = blockSize.GetSubsampled(subX, subY); |
||||
|
return planeBlockSize == Av1BlockSize.Block4x4; |
||||
|
} |
||||
|
|
||||
|
// Spec: CfL is available to luma partitions lesser than or equal to 32x32
|
||||
|
return blockSize.Get4x4WideCount() <= 32 && blockSize.Get4x4HighCount() <= 32; |
||||
|
} |
||||
|
|
||||
|
private void ReadIntraSegmentId(ref Av1SymbolDecoder reader) => throw new NotImplementedException(); |
||||
|
|
||||
|
private void FilterIntraModeInfo(ref Av1SymbolDecoder reader, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
bool useFilterIntra = false; |
||||
|
if (this.SequenceHeader.EnableFilterIntra && |
||||
|
this.yMode == Av1PredictionMode.DC && this.paletteSizeY == 0 && |
||||
|
Math.Max(blockSize.GetWidth(), blockSize.GetHeight()) <= 32) |
||||
|
{ |
||||
|
useFilterIntra = reader.ReadUseFilterUltra(); |
||||
|
if (useFilterIntra) |
||||
|
{ |
||||
|
this.filterUltraMode = reader.ReadFilterUltraMode(); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void PaletteModeInfo(ref Av1SymbolDecoder reader) => |
||||
|
|
||||
|
// TODO: Implement.
|
||||
|
throw new NotImplementedException(); |
||||
|
|
||||
|
private void ReadChromaFromLumaAlphas(ref Av1SymbolDecoder reader) => |
||||
|
|
||||
|
// TODO: Implement.
|
||||
|
throw new NotImplementedException(); |
||||
|
|
||||
|
private void IntraAngleInfoY(ref Av1SymbolDecoder reader, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
this.angleDeltaY = 0; |
||||
|
if (blockSize >= Av1BlockSize.Block8x8 && IsDirectionalMode(this.yMode)) |
||||
|
{ |
||||
|
int angleDeltaY = reader.ReadAngleDelta(this.yMode); |
||||
|
this.angleDeltaY = angleDeltaY - ObuConstants.MaxAngleDelta; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void IntraAngleInfoUv(ref Av1SymbolDecoder reader, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
this.angleDeltaUv = 0; |
||||
|
if (blockSize >= Av1BlockSize.Block8x8 && IsDirectionalMode(this.uvMode)) |
||||
|
{ |
||||
|
int angleDeltaUv = reader.ReadAngleDelta(this.uvMode); |
||||
|
this.angleDeltaUv = angleDeltaUv - ObuConstants.MaxAngleDelta; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static bool IsDirectionalMode(Av1PredictionMode mode) |
||||
|
=> mode is >= Av1PredictionMode.Vertical and <= Av1PredictionMode.Directional67Degrees; |
||||
|
|
||||
|
private void IntraSegmentId(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex) |
||||
|
{ |
||||
|
if (this.FrameInfo.SegmentationParameters.Enabled) |
||||
|
{ |
||||
|
this.ReadSegmentId(ref reader, rowIndex, columnIndex); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
this.segmentId = 0; |
||||
|
} |
||||
|
|
||||
|
this.lossless = this.FrameInfo.LosslessArray[this.segmentId]; |
||||
|
} |
||||
|
|
||||
|
private void ReadSegmentId(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex) |
||||
|
{ |
||||
|
int pred; |
||||
|
int prevUL = -1; |
||||
|
int prevU = -1; |
||||
|
int prevL = -1; |
||||
|
if (this.availableUp && this.availableLeft) |
||||
|
{ |
||||
|
prevUL = this.segmentIds[rowIndex - 1][columnIndex - 1]; |
||||
|
} |
||||
|
|
||||
|
if (this.availableUp) |
||||
|
{ |
||||
|
prevU = this.segmentIds[rowIndex - 1][columnIndex]; |
||||
|
} |
||||
|
|
||||
|
if (this.availableLeft) |
||||
|
{ |
||||
|
prevU = this.segmentIds[rowIndex][columnIndex - 1]; |
||||
|
} |
||||
|
|
||||
|
if (prevU == -1) |
||||
|
{ |
||||
|
pred = prevL == -1 ? 0 : prevL; |
||||
|
} |
||||
|
else if (prevL == -1) |
||||
|
{ |
||||
|
pred = prevU; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
pred = prevU == prevUL ? prevU : prevL; |
||||
|
} |
||||
|
|
||||
|
if (this.skip) |
||||
|
{ |
||||
|
this.segmentId = 0; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
int lastActiveSegmentId = this.FrameInfo.SegmentationParameters.LastActiveSegmentId; |
||||
|
this.segmentId = NegativeDeinterleave(reader.ReadSegmentId(-1), pred, lastActiveSegmentId + 1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private static int NegativeDeinterleave(int diff, int reference, int max) |
||||
|
{ |
||||
|
if (reference == 0) |
||||
|
{ |
||||
|
return diff; |
||||
|
} |
||||
|
|
||||
|
if (reference >= max - 1) |
||||
|
{ |
||||
|
return max - diff - 1; |
||||
|
} |
||||
|
|
||||
|
if (2 * reference < max) |
||||
|
{ |
||||
|
if (diff <= 2 * reference) |
||||
|
{ |
||||
|
if ((diff & 1) > 0) |
||||
|
{ |
||||
|
return reference + ((diff + 1) >> 1); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return reference - (diff >> 1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return diff; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (diff <= 2 * (max - reference - 1)) |
||||
|
{ |
||||
|
if ((diff & 1) > 0) |
||||
|
{ |
||||
|
return reference + ((diff + 1) >> 1); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return reference - (diff >> 1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return max - (diff + 1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReadCdef(ref Av1SymbolDecoder reader, int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
if (this.skip || this.FrameInfo.CodedLossless || !this.SequenceHeader.EnableCdef || this.FrameInfo.AllowIntraBlockCopy) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
int cdefSize4 = Av1BlockSize.Block64x64.Get4x4WideCount(); |
||||
|
int cdefMask4 = ~(cdefSize4 - 1); |
||||
|
int r = rowIndex & cdefMask4; |
||||
|
int c = columnIndex & cdefMask4; |
||||
|
if (this.cdefIndex[r][c] == -1) |
||||
|
{ |
||||
|
this.cdefIndex[r][c] = reader.ReadLiteral(this.FrameInfo.CdefParameters.BitCount); |
||||
|
int w4 = blockSize.Get4x4WideCount(); |
||||
|
int h4 = blockSize.Get4x4HighCount(); |
||||
|
for (int i = r; i < r + h4; i += cdefSize4) |
||||
|
{ |
||||
|
for (int j = c; j < c + w4; j += cdefSize4) |
||||
|
{ |
||||
|
this.cdefIndex[i][j] = this.cdefIndex[r][c]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReadDeltaLoopFilter(ref Av1SymbolDecoder reader, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
Av1BlockSize superBlockSize = this.SequenceHeader.Use128x128SuperBlock ? Av1BlockSize.Block128x128 : Av1BlockSize.Block64x64; |
||||
|
if (blockSize == superBlockSize && this.skip) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (this.readDeltas && this.FrameInfo.DeltaLoopFilterParameters.IsPresent) |
||||
|
{ |
||||
|
int frameLoopFilterCount = 1; |
||||
|
if (this.FrameInfo.DeltaLoopFilterParameters.Multi) |
||||
|
{ |
||||
|
frameLoopFilterCount = this.SequenceHeader.ColorConfig.ChannelCount > 1 ? ObuConstants.FrameLoopFilterCount : ObuConstants.FrameLoopFilterCount - 2; |
||||
|
} |
||||
|
|
||||
|
for (int i = 0; i < frameLoopFilterCount; i++) |
||||
|
{ |
||||
|
int deltaLoopFilterAbsolute = reader.ReadDeltaLoopFilterAbsolute(); |
||||
|
if (deltaLoopFilterAbsolute == ObuConstants.DeltaLoopFilterSmall) |
||||
|
{ |
||||
|
int deltaLoopFilterRemainingBits = reader.ReadLiteral(3) + 1; |
||||
|
int deltaLoopFilterAbsoluteBitCount = reader.ReadLiteral(deltaLoopFilterRemainingBits); |
||||
|
deltaLoopFilterAbsolute = deltaLoopFilterAbsoluteBitCount + (1 << deltaLoopFilterRemainingBits) + 1; |
||||
|
} |
||||
|
|
||||
|
if (deltaLoopFilterAbsolute != 0) |
||||
|
{ |
||||
|
bool deltaLoopFilterSign = reader.ReadLiteral(1) > 0; |
||||
|
int reducedDeltaLoopFilterLevel = deltaLoopFilterSign ? -deltaLoopFilterAbsolute : deltaLoopFilterAbsolute; |
||||
|
this.deltaLoopFilter[i] = Av1Math.Clip3(-ObuConstants.MaxLoopFilter, ObuConstants.MaxLoopFilter, this.deltaLoopFilter[i] + (reducedDeltaLoopFilterLevel << this.deltaLoopFilterResolution)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReadSkip(ref Av1SymbolDecoder reader) |
||||
|
{ |
||||
|
if (this.FrameInfo.SegmentationParameters.SegmentIdPrecedesSkip && |
||||
|
this.FrameInfo.SegmentationParameters.IsFeatureActive(-1, ObuSegmentationFeature.LevelSkip)) |
||||
|
{ |
||||
|
this.skip = true; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
this.skip = reader.ReadSkip(-1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private void ReadDeltaQuantizerIndex(ref Av1SymbolDecoder reader, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
Av1BlockSize superBlockSize = this.SequenceHeader.Use128x128SuperBlock ? Av1BlockSize.Block128x128 : Av1BlockSize.Block64x64; |
||||
|
if (blockSize == superBlockSize && this.skip) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
if (this.readDeltas) |
||||
|
{ |
||||
|
int deltaQuantizerAbsolute = reader.ReadDeltaQuantizerAbsolute(); |
||||
|
if (deltaQuantizerAbsolute == ObuConstants.DeltaQuantizerSmall) |
||||
|
{ |
||||
|
int deltaQuantizerRemainingBits = reader.ReadLiteral(3) + 1; |
||||
|
int deltaQuantizerAbsoluteBitCount = reader.ReadLiteral(deltaQuantizerRemainingBits); |
||||
|
deltaQuantizerAbsolute = deltaQuantizerRemainingBits + (1 << deltaQuantizerRemainingBits) + 1; |
||||
|
} |
||||
|
|
||||
|
if (deltaQuantizerAbsolute != 0) |
||||
|
{ |
||||
|
bool deltaQuantizerSignBit = reader.ReadLiteral(1) > 0; |
||||
|
int reducedDeltaQuantizerIndex = deltaQuantizerSignBit ? -deltaQuantizerAbsolute : deltaQuantizerAbsolute; |
||||
|
this.currentQuantizerIndex = Av1Math.Clip3(1, 255, this.currentQuantizerIndex + (reducedDeltaQuantizerIndex << this.deltaQuantizerResolution)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private bool IsInside(int rowIndex, int columnIndex) => |
||||
|
columnIndex >= this.TileInfo.TileColumnCount && |
||||
|
columnIndex < this.TileInfo.TileColumnCount && |
||||
|
rowIndex >= this.TileInfo.TileRowCount && |
||||
|
rowIndex < this.TileInfo.TileRowCount; |
||||
|
|
||||
|
/* |
||||
|
private static bool IsChroma(int rowIndex, int columnIndex, Av1BlockModeInfo blockMode, bool subSamplingX, bool subSamplingY) |
||||
|
{ |
||||
|
int block4x4Width = blockMode.BlockSize.Get4x4WideCount(); |
||||
|
int block4x4Height = blockMode.BlockSize.Get4x4HighCount(); |
||||
|
bool xPos = (columnIndex & 0x1) > 0 || (block4x4Width & 0x1) > 0 || !subSamplingX; |
||||
|
bool yPos = (rowIndex & 0x1) > 0 || (block4x4Height & 0x1) > 0 || !subSamplingY; |
||||
|
return xPos && yPos; |
||||
|
}*/ |
||||
|
|
||||
|
private int GetPartitionContext(int rowIndex, int columnIndex, Av1BlockSize blockSize) |
||||
|
{ |
||||
|
// Maximum partition point is 8x8. Offset the log value occordingly.
|
||||
|
int blockSizeLog = blockSize.Get4x4WidthLog2() - Av1BlockSize.Block8x8.Get4x4WidthLog2(); |
||||
|
int aboveCtx = this.aboveContext.PartitionWidth + columnIndex - this.TileInfo.TileColumnStartModeInfo[columnIndex]; |
||||
|
int leftCtx = this.leftContext.PartitionHeight + rowIndex - this.TileInfo.TileRowStartModeInfo[rowIndex]; |
||||
|
int above = (aboveCtx >> blockSizeLog) & 0x1; |
||||
|
int left = (leftCtx >> blockSizeLog) & 0x1; |
||||
|
return (left * 2) + above + (blockSizeLog * PartitionProbabilitySet); |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue