/*
* Copyright (c) 2017, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file     codechal_decode_vp8.cpp
//! \brief    Implements the decode interface extension for VP8.
//! \details  Implements all functions required by CodecHal for VP8 decoding.
//!

#include "codechal_decoder.h"
#include "codechal_decode_vp8.h"
#include "codec_def_vp8_probs.h"
#include "codechal_mmc_decode_vp8.h"
#if USE_CODECHAL_DEBUG_TOOL
#include <sstream>
#include <fstream>
#include "codechal_debug.h"
#endif

void Vp8EntropyState::DecodeFill()
{
    int32_t        shift       = m_bdValueSize - 8 - (m_count + 8);
    uint32_t       bytesLeft   = (uint32_t)(m_bufferEnd - m_buffer);
    uint32_t       bitsLeft   = bytesLeft * CHAR_BIT;
    int32_t        num         = (int32_t)(shift + CHAR_BIT - bitsLeft);
    int32_t        loopEnd     = 0;

    if (num >= 0)
    {
        m_count += m_lotsOfBits;
        loopEnd = num;
    }

    if (num < 0 || bitsLeft)
    {
        while (shift >= loopEnd)
        {
            m_count += CHAR_BIT;
            m_value |= (uint32_t)*m_buffer << shift;
            ++m_buffer;
            shift -= CHAR_BIT;
        }
    }
}

uint32_t Vp8EntropyState::DecodeBool(int32_t probability)
{
    uint32_t split     = 1 + (((m_range - 1) * probability) >> 8);
    uint32_t bigSplit  = (uint32_t)split << (m_bdValueSize - 8);
    uint32_t origRange = m_range;
    m_range            = split;

    uint32_t bit = 0;
    if (m_value >= bigSplit)
    {
        m_range = origRange - split;
        m_value = m_value - bigSplit;
        bit = 1;
    }

    int32_t shift = Norm[m_range];
    m_range <<= shift;
    m_value <<= shift;
    m_count -= shift;

    if (m_count < 0)
    {
        DecodeFill();
    }

    return bit;
}

int32_t Vp8EntropyState::DecodeValue(int32_t bits)
{
    int32_t retValue = 0;

    for (int32_t iBit = bits - 1; iBit >= 0; iBit--)
    {
        retValue |= (DecodeBool(0x80) << iBit);
    }

    return retValue;
}

void Vp8EntropyState::ParseFrameHeadInit()
{
    if (m_frameHead->iFrameType == m_keyFrame)
    {
        MOS_SecureMemcpy(m_frameHead->FrameContext.MvContext, sizeof(DefaultMvContext), DefaultMvContext, sizeof(DefaultMvContext));
        MOS_SecureMemcpy(m_frameHead->FrameContext.YModeProb, sizeof(KfYModeProb), KfYModeProb, sizeof(KfYModeProb));
        MOS_SecureMemcpy(m_frameHead->FrameContext.UVModeProb, sizeof(KfUVModeProb), KfUVModeProb, sizeof(KfUVModeProb));
        MOS_SecureMemcpy(m_frameHead->FrameContext.CoefProbs, sizeof(DefaultCoefProbs), DefaultCoefProbs, sizeof(DefaultCoefProbs));

        MOS_SecureMemcpy(m_frameHead->YModeProbs, sizeof(KfYModeProb), KfYModeProb, sizeof(KfYModeProb));
        MOS_SecureMemcpy(m_frameHead->UVModeProbs, sizeof(KfUVModeProb), KfUVModeProb, sizeof(KfUVModeProb));
        MOS_SecureMemcpy(m_frameHead->YModeProbs, sizeof(YModeProb), YModeProb, sizeof(YModeProb));
        MOS_SecureMemcpy(m_frameHead->UVModeProbs, sizeof(UVModeProb), UVModeProb, sizeof(UVModeProb));

        memset(m_frameHead->SegmentFeatureData, 0, sizeof(m_frameHead->SegmentFeatureData));
        m_frameHead->u8MbSegementAbsDelta = 0;

        memset(m_frameHead->RefLFDeltas, 0, sizeof(m_frameHead->RefLFDeltas));
        memset(m_frameHead->ModeLFDeltas, 0, sizeof(m_frameHead->ModeLFDeltas));

        m_frameHead->iRefreshGoldenFrame = 1;
        m_frameHead->iRefreshAltFrame    = 1;
        m_frameHead->iCopyBufferToGolden = 0;
        m_frameHead->iCopyBufferToAlt    = 0;

        m_frameHead->iLastFrameBufferCurrIdx   = m_frameHead->iNewFrameBufferIdx;
        m_frameHead->iGoldenFrameBufferCurrIdx = m_frameHead->iNewFrameBufferIdx;
        m_frameHead->iAltFrameBufferCurrIdx    = m_frameHead->iNewFrameBufferIdx;

        m_frameHead->RefFrameSignBias[VP8_GOLDEN_FRAME] = 0;
        m_frameHead->RefFrameSignBias[VP8_ALTREF_FRAME] = 0;
    }
}

int32_t Vp8EntropyState::StartEntropyDecode()
{
    m_bufferEnd = m_dataBufferEnd;
    m_buffer    = m_dataBuffer;
    m_value     = 0;
    m_count     = -8;
    m_range     = 255;

    if ((m_bufferEnd - m_buffer) > 0 && m_buffer == nullptr)
    {
        return 1;
    }

    DecodeFill();

    return 0;
}

void Vp8EntropyState::SegmentationEnabled()
{
    m_frameHead->u8SegmentationEnabled = (uint8_t)DecodeBool(m_probHalf);

    if (m_frameHead->u8SegmentationEnabled)
    {
        m_frameHead->u8UpdateMbSegmentationMap  = (uint8_t)DecodeBool(m_probHalf);
        m_frameHead->u8UpdateMbSegmentationData = (uint8_t)DecodeBool(m_probHalf);

        if (m_frameHead->u8UpdateMbSegmentationData)
        {
            m_frameHead->u8MbSegementAbsDelta = (uint8_t)DecodeBool(m_probHalf);

            memset(m_frameHead->SegmentFeatureData, 0, sizeof(m_frameHead->SegmentFeatureData));

            for (int32_t i = 0; i < VP8_MB_LVL_MAX; i++)
            {
                for (int32_t j = 0; j < VP8_MAX_MB_SEGMENTS; j++)
                {
                    if (DecodeBool(m_probHalf))
                    {
                        m_frameHead->SegmentFeatureData[i][j] = (int8_t)DecodeValue(MbFeatureDataBits[i]);

                        if (DecodeBool(m_probHalf))
                        {
                            m_frameHead->SegmentFeatureData[i][j] = -m_frameHead->SegmentFeatureData[i][j];
                        }
                    }
                    else
                    {
                        m_frameHead->SegmentFeatureData[i][j] = 0;
                    }
                }
            }
        }

        if (m_frameHead->u8UpdateMbSegmentationMap)
        {
            memset(m_frameHead->MbSegmentTreeProbs, 255, sizeof(m_frameHead->MbSegmentTreeProbs));

            for (int32_t i = 0; i < VP8_MB_SEGMENT_TREE_PROBS; i++)
            {
                if (DecodeBool(m_probHalf))
                {
                    m_frameHead->MbSegmentTreeProbs[i] = (uint8_t)DecodeValue(8);
                }
            }
        }
    }
    else
    {
        m_frameHead->u8UpdateMbSegmentationMap  = 0;
        m_frameHead->u8UpdateMbSegmentationData = 0;
    }
}

void Vp8EntropyState::LoopFilterInit(int32_t defaultFilterLvl)
{
    for (int32_t segmentNum = 0; segmentNum < VP8_MAX_MB_SEGMENTS; segmentNum++)
    {
        int32_t segmentLvl = defaultFilterLvl;

        if (m_frameHead->u8SegmentationEnabled)
        {
            if (m_frameHead->u8MbSegementAbsDelta == 1)
            {
                m_frameHead->LoopFilterLevel[segmentNum] = segmentLvl = m_frameHead->SegmentFeatureData[VP8_MB_LVL_ALT_LF][segmentNum];
            }
            else
            {
                segmentLvl += m_frameHead->SegmentFeatureData[VP8_MB_LVL_ALT_LF][segmentNum];
                m_frameHead->LoopFilterLevel[segmentNum] = segmentLvl = (segmentLvl > 0) ? ((segmentLvl > 63) ? 63 : segmentLvl) : 0;
            }
        }
    }
}

void Vp8EntropyState::LoopFilterEnabled()
{
    m_frameHead->FilterType      = (VP8_LF_TYPE)DecodeBool(m_probHalf);
    m_frameHead->iFilterLevel    = DecodeValue(6);
    m_frameHead->iSharpnessLevel = DecodeValue(3);

    m_frameHead->u8ModeRefLfDeltaUpdate  = 0;
    m_frameHead->u8ModeRefLfDeltaEnabled = (uint8_t)DecodeBool(m_probHalf);

    if (m_frameHead->u8ModeRefLfDeltaEnabled)
    {
        m_frameHead->u8ModeRefLfDeltaUpdate = (uint8_t)DecodeBool(m_probHalf);

        if (m_frameHead->u8ModeRefLfDeltaUpdate)
        {
            for (int32_t i = 0; i < VP8_MAX_REF_LF_DELTAS; i++)
            {
                if (DecodeBool(m_probHalf))
                {
                    m_frameHead->RefLFDeltas[i] = (int8_t)DecodeValue(6);

                    if (DecodeBool(m_probHalf))
                    {
                        m_frameHead->RefLFDeltas[i] = m_frameHead->RefLFDeltas[i] * (-1);
                    }
                }
            }

            for (int32_t i = 0; i < VP8_MAX_MODE_LF_DELTAS; i++)
            {
                if (DecodeBool(m_probHalf))
                {
                    m_frameHead->ModeLFDeltas[i] = (int8_t)DecodeValue(6);

                    if (DecodeBool(m_probHalf))
                    {
                        m_frameHead->ModeLFDeltas[i] = m_frameHead->ModeLFDeltas[i] * (-1);
                    }
                }
            }
        }
    }

    if (m_frameHead->iFilterLevel)
    {
        LoopFilterInit(m_frameHead->iFilterLevel);
    }
}

int32_t Vp8EntropyState::GetDeltaQ(int32_t prevVal, int32_t *qupdate)
{
    int32_t retVal = 0;

    if (DecodeBool(m_probHalf))
    {
        retVal = DecodeValue(4);

        if (DecodeBool(m_probHalf))
        {
            retVal = -retVal;
        }
    }

    if (retVal != prevVal)
    {
        *qupdate = 1;
    }

    return retVal;
}

int32_t Vp8EntropyState::DcQuant(int32_t qindex, int32_t delta)
{
    int32_t retVal;

    qindex = qindex + delta;

    if (qindex > 127)
    {
        qindex = 127;
    }
    else if (qindex < 0)
    {
        qindex = 0;
    }

    retVal = DcQLookup[qindex];
    return retVal;
}

int32_t Vp8EntropyState::Dc2Quant(int32_t qindex, int32_t delta)
{
    int32_t retVal;

    qindex = qindex + delta;

    if (qindex > 127)
    {
        qindex = 127;
    }
    else if (qindex < 0)
    {
        qindex = 0;
    }

    retVal = DcQLookup[qindex] * 2;
    return retVal;
}

int32_t Vp8EntropyState::DcUVQuant(int32_t qindex, int32_t delta)
{
    int32_t retVal;

    qindex = qindex + delta;

    if (qindex > 127)
    {
        qindex = 127;
    }
    else if (qindex < 0)
    {
        qindex = 0;
    }

    retVal = DcQLookup[qindex];

    if (retVal > 132)
    {
        retVal = 132;
    }

    return retVal;
}

int32_t Vp8EntropyState::AcYQuant(int32_t qindex)
{
    int32_t retVal;

    if (qindex > 127)
    {
        qindex = 127;
    }
    else if (qindex < 0)
    {
        qindex = 0;
    }

    retVal = AcQLookup[qindex];
    return retVal;
}

int32_t Vp8EntropyState::Ac2Quant(int32_t qindex, int32_t delta)
{
    int32_t retVal;

    qindex = qindex + delta;

    if (qindex > 127)
    {
        qindex = 127;
    }
    else if (qindex < 0)
    {
        qindex = 0;
    }

    retVal = (AcQLookup[qindex] * 101581) >> 16;

    if (retVal < 8)
    {
        retVal = 8;
    }

    return retVal;
}
int32_t Vp8EntropyState::AcUVQuant(int32_t qindex, int32_t delta)
{
    int32_t retVal;

    qindex = qindex + delta;

    if (qindex > 127)
    {
        qindex = 127;
    }
    else if (qindex < 0)
    {
        qindex = 0;
    }

    retVal = AcQLookup[qindex];
    return retVal;
}

void Vp8EntropyState::QuantInit()
{
    for (int32_t i = 0; i < VP8_Q_INDEX_RANGE; i++)
    {
        m_frameHead->Y1DeQuant[i][0] = (int16_t)DcQuant(i, m_frameHead->iY1DcDeltaQ);
        m_frameHead->Y2DeQuant[i][0] = (int16_t)Dc2Quant(i, m_frameHead->iY2DcDeltaQ);
        m_frameHead->UVDeQuant[i][0] = (int16_t)DcUVQuant(i, m_frameHead->iUVDcDeltaQ);

        m_frameHead->Y1DeQuant[i][1] = (int16_t)AcYQuant(i);
        m_frameHead->Y2DeQuant[i][1] = (int16_t)Ac2Quant(i, m_frameHead->iY2AcDeltaQ);
        m_frameHead->UVDeQuant[i][1] = (int16_t)AcUVQuant(i, m_frameHead->iUVAcDeltaQ);
    }
}

void Vp8EntropyState::QuantSetup()
{
    int32_t qupdate = 0;

    m_frameHead->iBaseQIndex = DecodeValue(7);
    m_frameHead->iY1DcDeltaQ = GetDeltaQ(m_frameHead->iY1DcDeltaQ, &qupdate);
    m_frameHead->iY2DcDeltaQ = GetDeltaQ(m_frameHead->iY2DcDeltaQ, &qupdate);
    m_frameHead->iY2AcDeltaQ = GetDeltaQ(m_frameHead->iY2AcDeltaQ, &qupdate);
    m_frameHead->iUVDcDeltaQ = GetDeltaQ(m_frameHead->iUVDcDeltaQ, &qupdate);
    m_frameHead->iUVAcDeltaQ = GetDeltaQ(m_frameHead->iUVAcDeltaQ, &qupdate);

    if (qupdate)
    {
        QuantInit();
    }
}

void Vp8EntropyState::ReadMvContexts(MV_CONTEXT *mvContext)
{
    int32_t i = 0;

    do
    {
        const uint8_t *upProb = MvUpdateProbs[i].MvProb;
        uint8_t *prob = (uint8_t *)(mvContext + i);
        uint8_t *const stopProb = prob + 19;

        do
        {
            if (DecodeBool(*upProb++))
            {
                const uint8_t x = (uint8_t)DecodeValue(7);

                *prob = x ? x << 1 : 1;
            }
        } while (++prob < stopProb);

    } while (++i < 2);
}

MOS_STATUS Vp8EntropyState::ParseFrameHead(PCODEC_VP8_PIC_PARAMS vp8PicParams)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    ParseFrameHeadInit();

    StartEntropyDecode();

    if (m_frameHead->iFrameType == m_keyFrame)
    {
        DecodeBool(m_probHalf);  // Color Space
        DecodeBool(m_probHalf);  // Clamp Type
    }

    SegmentationEnabled();

    LoopFilterEnabled();

    m_frameHead->MultiTokenPartition = (VP8_TOKEN_PARTITION)DecodeValue(2);

    if (!m_frameHead->bNotFirstCall)
    {
        QuantInit();
    }

    QuantSetup();

    if (m_frameHead->iFrameType != m_keyFrame)
    {
        m_frameHead->iRefreshGoldenFrame = DecodeBool(m_probHalf);

        m_frameHead->iRefreshAltFrame = DecodeBool(m_probHalf);

        m_frameHead->iCopyBufferToGolden = 0;

        if (!m_frameHead->iRefreshGoldenFrame)
        {
            m_frameHead->iCopyBufferToGolden = DecodeValue(2);
        }

        m_frameHead->iCopyBufferToAlt = 0;

        if (!m_frameHead->iRefreshAltFrame)
        {
            m_frameHead->iCopyBufferToAlt = DecodeValue(2);
        }

        m_frameHead->RefFrameSignBias[VP8_GOLDEN_FRAME] = DecodeBool(m_probHalf);
        m_frameHead->RefFrameSignBias[VP8_ALTREF_FRAME] = DecodeBool(m_probHalf);
    }

    if (m_frameHead->bNotFirstCall && m_frameHead->iRefreshEntropyProbs == 0)
    {
        MOS_SecureMemcpy(&m_frameHead->FrameContext, sizeof(m_frameHead->FrameContext), &m_frameHead->LastFrameContext, sizeof(m_frameHead->LastFrameContext));
    }

    m_frameHead->iRefreshEntropyProbs = DecodeBool(m_probHalf);

    if (m_frameHead->iRefreshEntropyProbs == 0)
    {
        MOS_SecureMemcpy(&m_frameHead->LastFrameContext, sizeof(m_frameHead->LastFrameContext), &m_frameHead->FrameContext, sizeof(m_frameHead->FrameContext));
    }

    if (m_frameHead->iFrameType == m_keyFrame || DecodeBool(m_probHalf))
    {
        m_frameHead->iRefreshLastFrame = true;
    }
    else
    {
        m_frameHead->iRefreshLastFrame = false;
    }

    for (int32_t i = 0; i < VP8_BLOCK_TYPES; i++)
        for (int32_t j = 0; j < VP8_COEF_BANDS; j++)
            for (int32_t k = 0; k < VP8_PREV_COEF_CONTEXTS; k++)
                for (int32_t l = 0; l < VP8_ENTROPY_NODES; l++)
                {
                    uint8_t *const p = m_frameHead->FrameContext.CoefProbs[i][j][k] + l;

                    if (DecodeBool(CoefUpdateProbs[i][j][k][l]))
                    {
                        *p = (uint8_t)DecodeValue(8);
                    }
                }

    m_frameHead->iMbNoCoeffSkip = (int32_t)DecodeBool(m_probHalf);
    m_frameHead->iProbSkipFalse = 0;
    if (m_frameHead->iMbNoCoeffSkip)
    {
        m_frameHead->iProbSkipFalse = (uint8_t)DecodeValue(8);
    }

    if (m_frameHead->iFrameType != m_keyFrame)
    {
        m_frameHead->ProbIntra = (uint8_t)DecodeValue(8);
        m_frameHead->ProbLast  = (uint8_t)DecodeValue(8);
        m_frameHead->ProbGf    = (uint8_t)DecodeValue(8);

        if (DecodeBool(m_probHalf))
        {
            int32_t i = 0;

            do
            {
                m_frameHead->YModeProbs[i] = m_frameHead->FrameContext.YModeProb[i] =
                    (uint8_t)DecodeValue(8);
            } while (++i < 4);
        }

        if (DecodeBool(m_probHalf))
        {
            int32_t i = 0;

            do
            {
                m_frameHead->UVModeProbs[i] = m_frameHead->FrameContext.UVModeProb[i] =
                    (uint8_t)DecodeValue(8);
            } while (++i < 3);
        }

        MV_CONTEXT MVContext[2];
        for (int32_t i = 0; i < 2; i++)
        {
            for (int32_t j = 0; j < 19; j++)
            {
                MVContext[i].MvProb[j] = vp8PicParams->ucMvUpdateProb[i][j];
            }
        }

        ReadMvContexts(MVContext);
    }

    vp8PicParams->ucP0EntropyCount = 8 - (m_count & 0x07);
    vp8PicParams->ucP0EntropyValue = (uint8_t)(m_value >> 24);
    vp8PicParams->uiP0EntropyRange = m_range;

    uint32_t firstPartitionAndUncompSize;
    if (m_frameHead->iFrameType == m_keyFrame)
    {
        firstPartitionAndUncompSize = vp8PicParams->uiFirstPartitionSize + 10;
    }
    else
    {
        firstPartitionAndUncompSize = vp8PicParams->uiFirstPartitionSize + 3;
    }

    // Partition Size
    uint32_t partitionNum     = 1 << m_frameHead->MultiTokenPartition;
    uint32_t partitionSizeSum = 0;
    m_dataBuffer              = m_bitstreamBuffer + firstPartitionAndUncompSize;
    if (partitionNum > 1)
    {
        for (int32_t i = 1; i < (int32_t)partitionNum; i++)
        {
            vp8PicParams->uiPartitionSize[i] = m_dataBuffer[0] + (m_dataBuffer[1] << 8) + (m_dataBuffer[2] << 16);
            m_dataBuffer += 3;
            partitionSizeSum += vp8PicParams->uiPartitionSize[i];
        }
    }

    uint32_t offsetCounter                      = ((m_count & 0x18) >> 3) + (((m_count & 0x07) != 0) ? 1 : 0);
    vp8PicParams->uiFirstMbByteOffset           = (uint32_t)(m_buffer - m_bitstreamBuffer) - offsetCounter;
    vp8PicParams->uiPartitionSize[0]            = firstPartitionAndUncompSize - (uint32_t)(m_buffer - m_bitstreamBuffer) + offsetCounter;
    vp8PicParams->uiPartitionSize[partitionNum] = m_bitstreamBufferSize - firstPartitionAndUncompSize - (partitionNum - 1) * 3 - partitionSizeSum;

    return eStatus;
}

void Vp8EntropyState::FrameHeadQuantUpdate(
    PCODEC_VP8_PIC_PARAMS vp8PicParams)
{
    for (int32_t i = 0; i < VP8_Q_INDEX_RANGE; i++)
    {
        m_frameHead->Y1DeQuant[i][0] = (int16_t)DcQuant(i, vp8PicParams->cY1DcDeltaQ);
        m_frameHead->Y2DeQuant[i][0] = (int16_t)Dc2Quant(i, vp8PicParams->cY2DcDeltaQ);
        m_frameHead->UVDeQuant[i][0] = (int16_t)DcUVQuant(i, vp8PicParams->cUVDcDeltaQ);

        m_frameHead->Y1DeQuant[i][1] = (int16_t)AcYQuant(i);
        m_frameHead->Y2DeQuant[i][1] = (int16_t)Ac2Quant(i, vp8PicParams->cY2AcDeltaQ);
        m_frameHead->UVDeQuant[i][1] = (int16_t)AcUVQuant(i, vp8PicParams->cUVAcDeltaQ);
    }
}

void Vp8EntropyState::Initialize(
    PCODECHAL_DECODE_VP8_FRAME_HEAD vp8FrameHeadIn,
    uint8_t*        bitstreamBufferIn,
    uint32_t        bitstreamBufferSizeIn)
{
    m_frameHead           = vp8FrameHeadIn;
    m_dataBuffer          = bitstreamBufferIn;
    m_dataBufferEnd       = bitstreamBufferIn + bitstreamBufferSizeIn;
    m_bitstreamBuffer     = bitstreamBufferIn;
    m_bitstreamBufferSize = bitstreamBufferSizeIn;

    m_frameHead->iFrameType                    = m_dataBuffer[0] & 1;
    m_frameHead->iVersion                      = (m_dataBuffer[0] >> 1) & 7;
    m_frameHead->iShowframe                    = (m_dataBuffer[0] >> 4) & 1;
    m_frameHead->uiFirstPartitionLengthInBytes = (m_dataBuffer[0] | (m_dataBuffer[1] << 8) | (m_dataBuffer[2] << 16)) >> 5;

    m_dataBuffer += 3;

    if (m_frameHead->iFrameType == m_keyFrame)
    {
        m_dataBuffer += 7;
    }
}

MOS_STATUS CodechalDecodeVp8::ParseFrameHead(uint8_t* bitstreamBuffer, uint32_t bitstreamBufferSize)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(bitstreamBuffer);

    m_vp8EntropyState.Initialize(&m_vp8FrameHead, bitstreamBuffer, bitstreamBufferSize);

    eStatus = m_vp8EntropyState.ParseFrameHead(m_vp8PicParams);

    if (eStatus != MOS_STATUS_SUCCESS)
    {
        CODECHAL_DECODE_ASSERTMESSAGE("Fail to parse VP8 Frame Head");
        return eStatus;
    }

    //------------------------------------------------------Temporary Separator

    // Loop Filter
    for (int32_t i = 0; i < VP8_MAX_MB_SEGMENTS; i++)
    {
        int32_t segmentLvl = m_vp8PicParams->ucFilterLevel;

        if (m_vp8PicParams->segmentation_enabled)
        {
            if (m_vp8PicParams->mb_segement_abs_delta == 1)
            {
                m_vp8PicParams->ucLoopFilterLevel[i] = segmentLvl = m_vp8PicParams->cSegmentFeatureData[VP8_MB_LVL_ALT_LF][i];
            }
            else
            {
                segmentLvl += m_vp8PicParams->cSegmentFeatureData[VP8_MB_LVL_ALT_LF][i];
                m_vp8PicParams->ucLoopFilterLevel[i] = segmentLvl = (segmentLvl > 0) ? ((segmentLvl > 63) ? 63 : segmentLvl) : 0;
            }
        }
        else
        {
            m_vp8PicParams->ucLoopFilterLevel[i] = m_vp8PicParams->ucFilterLevel;
        }
    }

    // Quant Matrix
    int32_t vp8QIndex[VP8_MAX_MB_SEGMENTS];
    if (m_vp8PicParams->segmentation_enabled)
    {
        for (int32_t i = 0; i < 4; i++)
        {
            if (m_vp8PicParams->mb_segement_abs_delta == 1)
            {
                vp8QIndex[i] = (int32_t)m_vp8PicParams->cSegmentFeatureData[VP8_MB_LVL_ALT_Q][i];
            }
            else
            {
                vp8QIndex[i] = (int32_t)m_vp8PicParams->ucBaseQIndex + (int32_t)m_vp8PicParams->cSegmentFeatureData[VP8_MB_LVL_ALT_Q][i];
                vp8QIndex[i] = (vp8QIndex[i] >= 0) ? ((vp8QIndex[i] <= VP8_MAX_Q) ? vp8QIndex[i] : VP8_MAX_Q) : 0;    // Clamp to valid range
            }
        }
    }
    else
    {
        vp8QIndex[0] = (int32_t)m_vp8PicParams->ucBaseQIndex;
        vp8QIndex[1] = 0;
        vp8QIndex[2] = 0;
        vp8QIndex[3] = 0;
    }

    m_vp8EntropyState.FrameHeadQuantUpdate(m_vp8PicParams);

    m_vp8IqMatrixParams->quantization_values[0][0] = m_vp8FrameHead.Y1DeQuant[vp8QIndex[0]][0];
    m_vp8IqMatrixParams->quantization_values[0][1] = m_vp8FrameHead.Y1DeQuant[vp8QIndex[0]][1];
    m_vp8IqMatrixParams->quantization_values[0][2] = m_vp8FrameHead.UVDeQuant[vp8QIndex[0]][0];
    m_vp8IqMatrixParams->quantization_values[0][3] = m_vp8FrameHead.UVDeQuant[vp8QIndex[0]][1];
    m_vp8IqMatrixParams->quantization_values[0][4] = m_vp8FrameHead.Y2DeQuant[vp8QIndex[0]][0];
    m_vp8IqMatrixParams->quantization_values[0][5] = m_vp8FrameHead.Y2DeQuant[vp8QIndex[0]][1];

    if (m_vp8FrameHead.u8SegmentationEnabled)
    {
        for (int32_t i = 1; i < 4; i++)
        {
            m_vp8IqMatrixParams->quantization_values[i][0] = m_vp8FrameHead.Y1DeQuant[vp8QIndex[i]][0];
            m_vp8IqMatrixParams->quantization_values[i][1] = m_vp8FrameHead.Y1DeQuant[vp8QIndex[i]][1];
            m_vp8IqMatrixParams->quantization_values[i][2] = m_vp8FrameHead.UVDeQuant[vp8QIndex[i]][0];
            m_vp8IqMatrixParams->quantization_values[i][3] = m_vp8FrameHead.UVDeQuant[vp8QIndex[i]][1];
            m_vp8IqMatrixParams->quantization_values[i][4] = m_vp8FrameHead.Y2DeQuant[vp8QIndex[i]][0];
            m_vp8IqMatrixParams->quantization_values[i][5] = m_vp8FrameHead.Y2DeQuant[vp8QIndex[i]][1];
        }
    }
    else
    {
        for (int32_t i = 1; i < 4; i++)
        {
            for (int32_t j = 0; j < 6; j++)
            {
                m_vp8IqMatrixParams->quantization_values[i][j] = 0;
            }
        }
    }

    // Coef Prob
    if (!Mos_ResourceIsNull(&m_resCoefProbBuffer))
    {
        m_osInterface->pfnFreeResource(
            m_osInterface,
            &m_resCoefProbBuffer);
    }

    CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                  &m_resCoefProbBuffer,
                                                  sizeof(m_vp8FrameHead.FrameContext.CoefProbs),
                                                  "VP8_Coef_Prob"),
        "Failed to allocate VP8 CoefProb Buffer.");

    CodechalResLock ResourceLock(m_osInterface, &m_resCoefProbBuffer);
    auto data = (uint8_t*)ResourceLock.Lock(CodechalResLock::writeOnly);

    CODECHAL_DECODE_CHK_NULL_RETURN(data);

    MOS_SecureMemcpy(
        data,
        sizeof(m_vp8FrameHead.FrameContext.CoefProbs),
        (void *)&(m_vp8FrameHead.FrameContext.CoefProbs),
        sizeof(m_vp8FrameHead.FrameContext.CoefProbs));

    m_vp8FrameHead.bNotFirstCall = true;

    return eStatus;
}

MOS_STATUS CodechalDecodeVp8::CopyBitstreamBuffer(
    MOS_RESOURCE    srcBitstreamBuffer,
    PMOS_RESOURCE   dstBitstreamBuffer,
    uint32_t        size)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
        m_osInterface,
        m_videoContextForWa));
    m_osInterface->pfnResetOsStates(m_osInterface);

    m_osInterface->pfnSetPerfTag(
        m_osInterface,
        (uint16_t)(((m_mode << 4) & 0xF0) | COPY_TYPE));
    m_osInterface->pfnResetPerfBufferID(m_osInterface);

    MOS_COMMAND_BUFFER cmdBuffer;
    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));

    // Send command buffer header at the beginning (OS dependent)
    CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, false));

    CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
        &cmdBuffer,                     // pCmdBuffer
        &srcBitstreamBuffer,            // presSrc
        dstBitstreamBuffer,             // presDst
        MOS_ALIGN_CEIL(size, 16),       // u32CopyLength
        0,                              // u32CopyInputOffset
        0));                            // u32CopyOutputOffset

    MHW_MI_FLUSH_DW_PARAMS flushDwParams;
    MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
    CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
        &cmdBuffer,
        &flushDwParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
        &cmdBuffer,
        nullptr));

    m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);

    m_huCCopyInUse = true;

    MOS_SYNC_PARAMS syncParams;

    syncParams = g_cInitSyncParams;
    syncParams.GpuContext = m_videoContext;
    syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));

    syncParams = g_cInitSyncParams;
    syncParams.GpuContext = m_videoContextForWa;
    syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
        m_osInterface,
        &cmdBuffer,
        m_videoContextUsesNullHw));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(m_osInterface, m_videoContext));

    return eStatus;
}

MOS_STATUS CodechalDecodeVp8::AllocateResourcesFixedSizes()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(m_osInterface, &m_resSyncObject));

    CodecHalAllocateDataList(
        m_vp8RefList,
        CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8);

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
        m_osInterface,
        &m_resSyncObjectWaContextInUse));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
        m_osInterface,
        &m_resSyncObjectVideoContextInUse));

    return eStatus;
}

MOS_STATUS CodechalDecodeVp8::AllocateResourcesVariableSizes()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    if (m_decodeParams.m_bitstreamLockingInUse && (!m_decodeParams.m_bitstreamLockable))
    {
        if (!Mos_ResourceIsNull(&m_resTmpBitstreamBuffer))
        {
            m_osInterface->pfnFreeResource(
                m_osInterface,
                &m_resTmpBitstreamBuffer);
        }

        CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                      &m_resTmpBitstreamBuffer,
                                                      m_dataSize,
                                                      "VP8_BitStream"),
            "Failed to allocate Bitstream Buffer.");
    }

    uint16_t picWidthInMB    = MOS_MAX(m_picWidthInMbLastMaxAlloced, (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1));
    uint16_t picHeightInMB   = MOS_MAX(m_picHeightInMbLastMaxAlloced, (m_vp8PicParams->wFrameHeightInMbsMinus1 + 1));
    uint32_t maxWidth        = picWidthInMB * CODECHAL_MACROBLOCK_WIDTH;
    uint32_t maxHeight       = picHeightInMB * CODECHAL_MACROBLOCK_HEIGHT;
    uint32_t numMacroblocks  = picWidthInMB * picHeightInMB;

    if (m_mfxInterface->IsDeblockingFilterRowstoreCacheEnabled() == false)
    {
        uint16_t maxMfdDFRowStoreScratchBufferPicWidthInMB;
        maxMfdDFRowStoreScratchBufferPicWidthInMB = MOS_MAX(m_mfdDeblockingFilterRowStoreScratchBufferPicWidthInMb,
            (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1));

        if ((maxMfdDFRowStoreScratchBufferPicWidthInMB > m_mfdDeblockingFilterRowStoreScratchBufferPicWidthInMb) ||
            Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
        {
            if (!Mos_ResourceIsNull(&m_resMfdDeblockingFilterRowStoreScratchBuffer))
            {
                m_osInterface->pfnFreeResource(
                    m_osInterface,
                    &m_resMfdDeblockingFilterRowStoreScratchBuffer);
            }
            // Deblocking Filter Row Store Scratch buffer
            //(Num MacroBlock Width) * (Num Cachlines) * (Cachline size)
            CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                          &m_resMfdDeblockingFilterRowStoreScratchBuffer,
                                                          maxMfdDFRowStoreScratchBufferPicWidthInMB * 2 * CODECHAL_CACHELINE_SIZE,
                                                          "DeblockingScratchBuffer"),
                "Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
        }

        //record the width and height used for allocation internal resources.
        m_mfdDeblockingFilterRowStoreScratchBufferPicWidthInMb = maxMfdDFRowStoreScratchBufferPicWidthInMB;
    }

    if (m_mfxInterface->IsIntraRowstoreCacheEnabled() == false)
    {
        uint16_t maxMfdIntraRowStoreScratchBufferPicWidthInMB;
        maxMfdIntraRowStoreScratchBufferPicWidthInMB = MOS_MAX(m_mfdIntraRowStoreScratchBufferPicWidthInMb, (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1));

        if ((maxMfdIntraRowStoreScratchBufferPicWidthInMB > m_mfdIntraRowStoreScratchBufferPicWidthInMb) ||
            Mos_ResourceIsNull(&m_resMfdIntraRowStoreScratchBuffer))
        {
            if (!Mos_ResourceIsNull(&m_resMfdIntraRowStoreScratchBuffer))
            {
                m_osInterface->pfnFreeResource(
                    m_osInterface,
                    &m_resMfdIntraRowStoreScratchBuffer);
            }

            // Intra Row Store Scratch buffer
            // (FrameWidth in MB) * (CacheLine size per MB)
            CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                          &m_resMfdIntraRowStoreScratchBuffer,
                                                          maxMfdIntraRowStoreScratchBufferPicWidthInMB * CODECHAL_CACHELINE_SIZE,
                                                          "IntraScratchBuffer"),
                "Failed to allocate VP8 BSD Intra Row Store Scratch Buffer.");
        }

        //record the width and height used for allocation internal resources.
        m_mfdIntraRowStoreScratchBufferPicWidthInMb = maxMfdIntraRowStoreScratchBufferPicWidthInMB;
    }

    if (m_mfxInterface->IsBsdMpcRowstoreCacheEnabled() == false)
    {
        uint16_t maxBsdMpcRowStoreScratchBufferPicWidthInMB;
        maxBsdMpcRowStoreScratchBufferPicWidthInMB = MOS_MAX(m_bsdMpcRowStoreScratchBufferPicWidthInMb, (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1));

        if ((maxBsdMpcRowStoreScratchBufferPicWidthInMB > m_bsdMpcRowStoreScratchBufferPicWidthInMb) ||
            Mos_ResourceIsNull(&m_resBsdMpcRowStoreScratchBuffer))
        {
            if (!Mos_ResourceIsNull(&m_resBsdMpcRowStoreScratchBuffer))
            {
                m_osInterface->pfnFreeResource(
                    m_osInterface,
                    &m_resBsdMpcRowStoreScratchBuffer);
            }
            // BSD/MPC Row Store Scratch buffer
            // (FrameWidth in MB) * (2) * (CacheLine size per MB)
            CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                          &m_resBsdMpcRowStoreScratchBuffer,
                                                          maxBsdMpcRowStoreScratchBufferPicWidthInMB * CODECHAL_CACHELINE_SIZE * 2,
                                                          "MpcScratchBuffer"),
                "Failed to allocate BSD/MPC Row Store Scratch Buffer.");
        }

        //record the width and height used for allocation internal resources.
        m_bsdMpcRowStoreScratchBufferPicWidthInMb = maxBsdMpcRowStoreScratchBufferPicWidthInMB;
    }

    if ((picWidthInMB > m_picWidthInMbLastMaxAlloced) ||
        Mos_ResourceIsNull(&m_resMprRowStoreScratchBuffer))
    {
        if (!Mos_ResourceIsNull(&m_resMprRowStoreScratchBuffer))
        {
            m_osInterface->pfnFreeResource(
                m_osInterface,
                &m_resMprRowStoreScratchBuffer);
        }
        // MPR Row Store Scratch buffer
        // (FrameWidth in MB) * (2) * (CacheLine size per MB)
        CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                      &m_resMprRowStoreScratchBuffer,
                                                      picWidthInMB * CODECHAL_CACHELINE_SIZE * 22,
                                                      "MprScratchBuffer"),
            "Failed to allocate MPR Row Store Scratch Buffer.");
    }

    if ((numMacroblocks > (uint32_t)m_picWidthInMbLastMaxAlloced * m_picHeightInMbLastMaxAlloced) ||
        Mos_ResourceIsNull(&m_resSegmentationIdStreamBuffer))
    {
        if (!Mos_ResourceIsNull(&m_resSegmentationIdStreamBuffer))
        {
            m_osInterface->pfnFreeResource(
                m_osInterface,
                &m_resSegmentationIdStreamBuffer);
        }
        // Segmentation ID Stream buffer
        //(Num MacroBlocks) * (Cachline size) * (2 bit)
        CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
                                                      &m_resSegmentationIdStreamBuffer,
                                                      MOS_MAX(numMacroblocks * CODECHAL_CACHELINE_SIZE * 2 / 8, 64),
                                                      "SegmentationIdStreamBuffer"),
            "Failed to allocate Segmentation ID Stream Buffer.");
    }

    m_picWidthInMbLastMaxAlloced  = picWidthInMB;
    m_picHeightInMbLastMaxAlloced = picHeightInMB;

    return eStatus;
}

CodechalDecodeVp8::~CodechalDecodeVp8()
{
    CODECHAL_DECODE_FUNCTION_ENTER;

    m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObject);

    CodecHalFreeDataList(m_vp8RefList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_VP8);

    // indicate resCoefProbBuffer is allocated internal, not from m_decodeParams.m_coefProbBuffer
    if (m_vp8FrameHead.bNotFirstCall == true)
    {
        m_osInterface->pfnFreeResource(
            m_osInterface,
            &m_resCoefProbBuffer);
    }

    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_resTmpBitstreamBuffer);

    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_resMfdDeblockingFilterRowStoreScratchBuffer);

    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_resMfdIntraRowStoreScratchBuffer);

    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_resBsdMpcRowStoreScratchBuffer);

    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_resMprRowStoreScratchBuffer);

    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_resSegmentationIdStreamBuffer);

    m_osInterface->pfnDestroySyncResource(
        m_osInterface,
        &m_resSyncObjectWaContextInUse);

    m_osInterface->pfnDestroySyncResource(
        m_osInterface,
        &m_resSyncObjectVideoContextInUse);

    return;
}

MOS_STATUS CodechalDecodeVp8::SetFrameStates()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
    CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);

    m_dataSize          = m_decodeParams.m_dataSize;
    m_dataOffset        = m_decodeParams.m_dataOffset;
    m_destSurface       = *(m_decodeParams.m_destSurface);
    m_resDataBuffer     = *(m_decodeParams.m_dataBuffer);
    m_vp8PicParams      = (PCODEC_VP8_PIC_PARAMS)m_decodeParams.m_picParams;
    m_vp8IqMatrixParams = (PCODEC_VP8_IQ_MATRIX_PARAMS)m_decodeParams.m_iqMatrixBuffer;

    CODECHAL_DECODE_CHK_NULL_RETURN(m_vp8PicParams);

    PCODEC_REF_LIST destEntry = m_vp8RefList[m_vp8PicParams->CurrPic.FrameIdx];
    CODEC_PICTURE   currPic   = m_vp8PicParams->CurrPic;

    MOS_ZeroMemory(destEntry, sizeof(CODEC_REF_LIST));
    destEntry->RefPic = currPic;
    destEntry->resRefPic = m_destSurface.OsResource;

    m_statusReportFeedbackNumber = m_vp8PicParams->uiStatusReportFeedbackNumber;

    m_deblockingEnabled = !m_vp8PicParams->LoopFilterDisable ? true : false;

    if (m_mfxInterface->IsRowStoreCachingSupported())
    {
        MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams;
        MOS_ZeroMemory(&rowstoreParams, sizeof(rowstoreParams));
        rowstoreParams.dwPicWidth = m_width;
        rowstoreParams.bMbaff = false;
        rowstoreParams.Mode = CODECHAL_DECODE_MODE_VP8VLD;
        CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams));
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesVariableSizes());

    if (m_decodeParams.m_bitstreamLockingInUse)
    {
        if (m_decodeParams.m_bitstreamLockable)
        {
            CodechalResLock ResourceLock(m_osInterface, &m_resDataBuffer);
            auto bitstreamBuffer = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly);

            CODECHAL_DECODE_CHK_STATUS_RETURN(ParseFrameHead(bitstreamBuffer + m_dataOffset, m_dataSize));
        }
        else
        {
            CODECHAL_DECODE_CHK_STATUS_RETURN(CopyBitstreamBuffer(m_resDataBuffer, &m_resTmpBitstreamBuffer, m_dataSize));

            CodechalResLock ResourceLock(m_osInterface, &m_resTmpBitstreamBuffer);
            auto bitstreamBuffer = (uint8_t*)ResourceLock.Lock(CodechalResLock::readOnly);

            CODECHAL_DECODE_CHK_STATUS_RETURN(ParseFrameHead(bitstreamBuffer, m_dataSize));
        }

        m_decodeParams.m_coefProbSize = sizeof(m_vp8FrameHead.FrameContext.CoefProbs);
    }
    else
    {
        m_resCoefProbBuffer = *(m_decodeParams.m_coefProbBuffer);
    }

    m_width  = (m_vp8PicParams->wFrameWidthInMbsMinus1 + 1) * CODECHAL_MACROBLOCK_WIDTH;
    m_height = (m_vp8PicParams->wFrameHeightInMbsMinus1 + 1) * CODECHAL_MACROBLOCK_HEIGHT;

    // Overwrite the actual surface height with the coded height and width of the frame
    // for VP8 since it's possible for a VP8 frame to change size during playback
    m_destSurface.dwWidth  = m_width;
    m_destSurface.dwHeight = m_height;

    m_perfType = m_vp8PicParams->key_frame ? I_TYPE : P_TYPE;

    m_crrPic = m_vp8PicParams->CurrPic;

    CODECHAL_DEBUG_TOOL(
        CODECHAL_DECODE_CHK_NULL_RETURN(m_debugInterface);
        m_vp8PicParams->CurrPic.PicFlags = PICTURE_FRAME;
        m_debugInterface->m_currPic      = m_crrPic;
        m_debugInterface->m_frameType    = m_perfType;

        if (m_vp8PicParams) {
            CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(
                m_vp8PicParams));
        }

        if (m_vp8IqMatrixParams) {
            CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(
                m_vp8IqMatrixParams));
        }

        // Dump Vp8CoefProb
        CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
            &(m_resCoefProbBuffer),
            CodechalDbgAttr::attrCoeffProb,
            "_DEC",
            m_decodeParams.m_coefProbSize));)

    return eStatus;
}

MOS_STATUS CodechalDecodeVp8::DecodeStateLevel()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    if (m_vp8PicParams->key_frame)  // reference surface should be nullptr when key_frame == true
    {
        m_presLastRefSurface   = nullptr;
        m_presGoldenRefSurface = nullptr;
        m_presAltRefSurface    = nullptr;
    }
    else
    {
        m_presLastRefSurface   = &(m_vp8RefList[m_vp8PicParams->ucLastRefPicIndex]->resRefPic);
        m_presGoldenRefSurface = &(m_vp8RefList[m_vp8PicParams->ucGoldenRefPicIndex]->resRefPic);
        m_presAltRefSurface    = &(m_vp8RefList[m_vp8PicParams->ucAltRefPicIndex]->resRefPic);
    }

    MOS_COMMAND_BUFFER cmdBuffer;
    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));

    MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
    MOS_ZeroMemory(&pipeModeSelectParams, sizeof(pipeModeSelectParams));
    pipeModeSelectParams.Mode               = m_mode;
    pipeModeSelectParams.bStreamOutEnabled  = m_streamOutEnabled;
    pipeModeSelectParams.bPostDeblockOutEnable = m_deblockingEnabled;
    pipeModeSelectParams.bPreDeblockOutEnable  = !m_deblockingEnabled;
    pipeModeSelectParams.bShortFormatInUse     = m_shortFormatInUse;

    MHW_VDBOX_SURFACE_PARAMS surfaceParams;
    MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
    surfaceParams.Mode = m_mode;
    surfaceParams.psSurface = &m_destSurface;

    MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
    MOS_ZeroMemory(&pipeBufAddrParams, sizeof(pipeBufAddrParams));
    pipeBufAddrParams.Mode = m_mode;

    if (m_deblockingEnabled)
    {
        pipeBufAddrParams.psPostDeblockSurface = &m_destSurface;
    }
    else
    {
        pipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));

    // when there is no last, golden and alternate reference,
    // the index is set to the destination frame index
    pipeBufAddrParams.presReferences[CodechalDecodeLastRef]      = m_presLastRefSurface;
    pipeBufAddrParams.presReferences[CodechalDecodeGoldenRef]    = m_presGoldenRefSurface;
    pipeBufAddrParams.presReferences[CodechalDecodeAlternateRef] = m_presAltRefSurface;

    pipeBufAddrParams.presMfdIntraRowStoreScratchBuffer            = &m_resMfdIntraRowStoreScratchBuffer;
    pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resMfdDeblockingFilterRowStoreScratchBuffer;
    if (m_streamOutEnabled)
    {
        pipeBufAddrParams.presStreamOutBuffer =
            &(m_streamOutBuffer[m_streamOutCurrBufIdx]);
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->CheckReferenceList(&pipeBufAddrParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetRefrenceSync(m_disableDecodeSyncLock, m_disableLockForTranscode));

    MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
    MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
    indObjBaseAddrParams.Mode = m_mode;

    indObjBaseAddrParams.dwDataSize     = m_dataSize;
    indObjBaseAddrParams.dwDataOffset   = m_dataOffset;
    indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;

    MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
    MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
    bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resBsdMpcRowStoreScratchBuffer;
    bspBufBaseAddrParams.presMprRowStoreScratchBuffer    = &m_resMprRowStoreScratchBuffer;

    MHW_VDBOX_VP8_PIC_STATE vp8PicState;
    vp8PicState.pVp8PicParams                  = m_vp8PicParams;
    vp8PicState.pVp8IqMatrixParams             = m_vp8IqMatrixParams;
    vp8PicState.presSegmentationIdStreamBuffer = &m_resSegmentationIdStreamBuffer;
    vp8PicState.dwCoefProbTableOffset = 0;
    vp8PicState.presCoefProbBuffer             = &m_resCoefProbBuffer;

    CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
        &cmdBuffer, true));

    if (m_statusQueryReportingEnabled)
    {
        CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer));
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxVp8PicCmd(&cmdBuffer, &vp8PicState));

    m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);

    return eStatus;
}

MOS_STATUS CodechalDecodeVp8::DecodePrimitiveLevel()
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    MOS_COMMAND_BUFFER cmdBuffer;
    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));

    // Fill BSD Object Commands
    MHW_VDBOX_VP8_BSD_PARAMS vp8BsdParams;
    vp8BsdParams.pVp8PicParams = m_vp8PicParams;

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfdVp8BsdObjectCmd(&cmdBuffer, &vp8BsdParams));

    // Check if destination surface needs to be synchronized
    MOS_SYNC_PARAMS syncParams;
    syncParams = g_cInitSyncParams;
    syncParams.GpuContext = m_videoContext;
    syncParams.presSyncResource         = &m_destSurface.OsResource;
    syncParams.bReadOnly = false;
    syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
    syncParams.bDisableLockForTranscode = m_disableLockForTranscode;

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(m_osInterface, &syncParams));
    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));

    // Update the resource tag (s/w tag) for On-Demand Sync
    m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);

    MHW_MI_FLUSH_DW_PARAMS flushDwParams;
    MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));

    // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
    if (m_osInterface->bTagResourceSync)
    {
        CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(&cmdBuffer, &syncParams));
    }

    if (m_statusQueryReportingEnabled)
    {
        CodechalDecodeStatusReport decodeStatusReport;

        decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
        decodeStatusReport.m_currDecodedPic     = m_vp8PicParams->CurrPic;
        decodeStatusReport.m_currDeblockedPic   = m_vp8PicParams->CurrPic;
        decodeStatusReport.m_codecStatus        = CODECHAL_STATUS_UNAVAILABLE;
        decodeStatusReport.m_currDecodedPicRes  = m_vp8RefList[m_vp8PicParams->CurrPic.FrameIdx]->resRefPic;
        CODECHAL_DEBUG_TOOL(
            decodeStatusReport.m_secondField = CodecHal_PictureIsBottomField(m_vp8PicParams->CurrPic);
            decodeStatusReport.m_frameType   = m_perfType;)
        CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(decodeStatusReport, &cmdBuffer));
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));

    m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);

    CODECHAL_DEBUG_TOOL(
        CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
            &cmdBuffer,
            CODECHAL_NUM_MEDIA_STATES,
            "_DEC"));
    )

    if (m_huCCopyInUse)
    {
        syncParams = g_cInitSyncParams;
        syncParams.GpuContext = m_videoContextForWa;
        syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;

        CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));

        syncParams = g_cInitSyncParams;
        syncParams.GpuContext = m_videoContext;
        syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;

        CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));

        m_huCCopyInUse = false;
    }

    CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_videoContextUsesNullHw));

    CODECHAL_DEBUG_TOOL(
        m_mmc->UpdateUserFeatureKey(&m_destSurface);)

    if (m_statusQueryReportingEnabled)
    {
        CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(m_videoContextUsesNullHw));
        }

    // Needs to be re-set for Linux buffer re-use scenarios
        m_vp8RefList[m_vp8PicParams->ucCurrPicIndex]->resRefPic =
            m_destSurface.OsResource;

        // Send the signal to indicate decode completion, in case On-Demand Sync is not present
        CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(m_osInterface, &syncParams));

        return eStatus;
}

MOS_STATUS CodechalDecodeVp8::InitMmcState()
{
#ifdef _MMC_SUPPORTED
    m_mmc = MOS_New(CodechalMmcDecodeVp8, m_hwInterface, this);
    CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
#endif
    return MOS_STATUS_SUCCESS;
}

MOS_STATUS CodechalDecodeVp8::AllocateStandard(
    CodechalSetting *settings)
{
    MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

    CODECHAL_DECODE_FUNCTION_ENTER;

    CODECHAL_DECODE_CHK_NULL_RETURN(settings);

    CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());

    m_width         = settings->width;
    m_height        = settings->height;
    m_shortFormatInUse = settings->shortFormatInUse ? true : false;
    m_huCCopyInUse     = false;

    // Picture Level Commands
    m_hwInterface->GetMfxStateCommandsDataSize(
        m_mode,
        &m_commandBufferSizeNeeded,
        &m_commandPatchListSizeNeeded,
        m_shortFormatInUse);

    // Primitive Level Commands
    m_hwInterface->GetMfxPrimitiveCommandsDataSize(
        m_mode,
        &m_standardDecodeSizeNeeded,
        &m_standardDecodePatchListSizeNeeded,
        m_shortFormatInUse);

    CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResourcesFixedSizes());

    return eStatus;
}

CodechalDecodeVp8::CodechalDecodeVp8(
    CodechalHwInterface *   hwInterface,
    CodechalDebugInterface *debugInterface,
    PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecode(hwInterface, debugInterface, standardInfo),
                                            m_picWidthInMbLastMaxAlloced(0),
                                            m_picHeightInMbLastMaxAlloced(0),
                                            m_shortFormatInUse(false),
                                            m_dataSize(0),
                                            m_vp8PicParams(nullptr),
                                            m_vp8IqMatrixParams(nullptr),
                                            m_presLastRefSurface(nullptr),
                                            m_presGoldenRefSurface(nullptr),
                                            m_presAltRefSurface(nullptr),
                                            m_mfdDeblockingFilterRowStoreScratchBufferPicWidthInMb(0),
                                            m_mfdIntraRowStoreScratchBufferPicWidthInMb(0),
                                            m_bsdMpcRowStoreScratchBufferPicWidthInMb(0),
                                            m_privateInputBufferSize(0),
                                            m_coeffProbTableOffset(0),
                                            m_deblockingEnabled(false),
                                            m_huCCopyInUse(false)
{
    CODECHAL_DECODE_FUNCTION_ENTER;

    MOS_ZeroMemory(&m_destSurface, sizeof(m_destSurface));
    MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
    MOS_ZeroMemory(&m_resCoefProbBuffer, sizeof(m_resCoefProbBuffer));
    MOS_ZeroMemory(&m_resTmpBitstreamBuffer, sizeof(m_resTmpBitstreamBuffer));
    MOS_ZeroMemory(&m_resMfdIntraRowStoreScratchBuffer, sizeof(m_resMfdIntraRowStoreScratchBuffer));
    MOS_ZeroMemory(&m_resMfdDeblockingFilterRowStoreScratchBuffer, sizeof(m_resMfdDeblockingFilterRowStoreScratchBuffer));
    MOS_ZeroMemory(&m_resBsdMpcRowStoreScratchBuffer, sizeof(m_resBsdMpcRowStoreScratchBuffer));
    MOS_ZeroMemory(&m_resMprRowStoreScratchBuffer, sizeof(m_resMprRowStoreScratchBuffer));
    MOS_ZeroMemory(&m_resSegmentationIdStreamBuffer, sizeof(m_resSegmentationIdStreamBuffer));
    MOS_ZeroMemory(&m_resSyncObject, sizeof(m_resSyncObject));
    MOS_ZeroMemory(&m_resPrivateInputBuffer, sizeof(m_resPrivateInputBuffer));
    MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
    MOS_ZeroMemory(&m_resSyncObjectVideoContextInUse, sizeof(m_resSyncObjectVideoContextInUse));
    MOS_ZeroMemory(&m_vp8FrameHead, sizeof(m_vp8FrameHead));
}

#if USE_CODECHAL_DEBUG_TOOL
MOS_STATUS CodechalDecodeVp8::DumpPicParams(
    PCODEC_VP8_PIC_PARAMS           picParams)
{
    CODECHAL_DEBUG_FUNCTION_ENTER;

    if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
    {
        return MOS_STATUS_SUCCESS;
    }

    CODECHAL_DEBUG_CHK_NULL(picParams);

    std::ostringstream oss;
    oss.setf(std::ios::showbase | std::ios::uppercase);

    oss<< "CurrPic FrameIdx: "<<std::hex<< +picParams->CurrPic.FrameIdx<<std::endl;
    oss<< "CurrPic PicFlags: "<<std::hex<< +picParams->CurrPic.PicFlags<<std::endl;
    oss<< "wFrameWidthInMbsMinus1: "<<std::hex<< +picParams->wFrameWidthInMbsMinus1<<std::endl;
    oss<< "wFrameHeightInMbsMinus1: "<<std::hex<< +picParams->wFrameHeightInMbsMinus1<<std::endl;
    oss<< "ucCurrPicIndex: "<<std::hex<< +picParams->ucCurrPicIndex<<std::endl;
    oss<< "ucLastRefPicIndex: "<<std::hex<< +picParams->ucLastRefPicIndex<<std::endl;
    oss<< "ucGoldenRefPicIndex: "<<std::hex<< +picParams->ucGoldenRefPicIndex<<std::endl;
    oss<< "ucAltRefPicIndex: "<<std::hex<< +picParams->ucAltRefPicIndex<<std::endl;
    oss<< "ucDeblockedPicIndex: "<<std::hex<< +picParams->ucDeblockedPicIndex<<std::endl;
    oss<< "ucReserved8Bits: "<<std::hex<< +picParams->ucReserved8Bits<<std::endl;
    oss<< "wPicFlags: "<<std::hex<< +picParams->wPicFlags<<std::endl;
    oss<< "key_frame: "<<std::hex<< +picParams->key_frame<<std::endl;
    oss<< "version: "<<std::hex<< +picParams->version<<std::endl;
    oss<< "segmentation_enabled: "<<std::hex<< +picParams->segmentation_enabled<<std::endl;
    oss<< "update_mb_segmentation_map: "<<std::hex<< +picParams->update_mb_segmentation_map<<std::endl;
    oss<< "update_segment_feature_data: "<<std::hex<< +picParams->update_segment_feature_data<<std::endl;
    oss<< "filter_type: "<<std::hex<< +picParams->filter_type<<std::endl;
    oss<< "sign_bias_golden: "<<std::hex<< +picParams->sign_bias_golden<<std::endl;
    oss<< "sign_bias_alternate: "<<std::hex<< +picParams->sign_bias_alternate<<std::endl;
    oss<< "mb_no_coeff_skip: "<<std::hex<< +picParams->mb_no_coeff_skip<<std::endl;
    oss<< "mode_ref_lf_delta_update: "<<std::hex<< +picParams->mode_ref_lf_delta_update<<std::endl;
    oss<< "CodedCoeffTokenPartition: "<<std::hex<< +picParams->CodedCoeffTokenPartition<<std::endl;
    oss<< "LoopFilterDisable: "<<std::hex<< +picParams->LoopFilterDisable<<std::endl;
    oss<< "loop_filter_adj_enable: "<<std::hex<< +picParams->loop_filter_adj_enable<<std::endl;

    for(uint8_t i=0;i<4;++i)
    {
        oss<< "ucLoopFilterLevel[" <<std::dec<<+i<<"]: "<<std::hex<< +picParams->ucLoopFilterLevel[i]<<std::endl;
    }

    for(uint8_t i=0;i<4;++i)
    {
        oss<< "cRefLfDelta["<<std::dec<<+i<<"]: "<<std::hex<< +picParams->cRefLfDelta[i]<<std::endl;
    }

    for(uint8_t i=0;i<4;++i)
    {
        oss<< "cModeLfDelta[" <<std::dec<<+i<<"]: "<<std::hex<< +picParams->cModeLfDelta[i]<<std::endl;
    }
    oss<< "ucSharpnessLevel: " <<std::dec<<std::hex<< +picParams->ucSharpnessLevel<<std::endl;

    for(uint8_t i=0;i<3;++i)
    {
        oss<< "cMbSegmentTreeProbs[" <<std::dec<<+i<<"]: "<<std::hex<< +picParams->cMbSegmentTreeProbs[i]<<std::endl;
    }
    oss<< "ucProbSkipFalse: "<<std::hex<< +picParams->ucProbSkipFalse<<std::endl;
    oss<< "ucProbIntra: "<<std::hex<< +picParams->ucProbIntra<<std::endl;
    oss<< "ucProbLast: "<<std::hex<< +picParams->ucProbLast<<std::endl;
    oss<< "ucProbGolden: "<<std::hex<< +picParams->ucProbGolden<<std::endl;

    for(uint8_t i=0;i<4;++i)
    {
        oss<< "ucYModeProbs[" <<std::dec<<+i<<"]: "<<std::hex<< +picParams->ucYModeProbs[i]<<std::endl;
    }

    for(uint8_t i=0;i<3;++i)
    {
        oss<< "ucUvModeProbs[" <<std::dec<<+i<<"]: "<<std::hex<< +picParams->ucUvModeProbs[i]<<std::endl;
    }
    oss<< "ucReserved8Bits1: "<<std::hex<< +picParams->ucReserved8Bits1<<std::endl;
    oss<< "ucP0EntropyCount: "<<std::hex<< +picParams->ucP0EntropyCount<<std::endl;
    oss<< "ucP0EntropyValue: "<<std::hex<< +picParams->ucP0EntropyValue<<std::endl;
    oss<< "uiP0EntropyRange: "<<std::hex<< +picParams->uiP0EntropyRange<<std::endl;
    oss<< "uiFirstMbByteOffset: "<<std::hex<< +picParams->uiFirstMbByteOffset<<std::endl;

    for(uint8_t i=0;i<2;++i)
    {
        for(uint8_t j=0;j<CODEC_VP8_MVP_COUNT;++j)
        {
            oss<< "ucMvUpdateProb["<<std::dec<<+i<<"]["<<std::dec<<+j<<"]: "<<std::hex<< +picParams->ucMvUpdateProb[i][j]<<std::endl;
        }
    }
    for(uint8_t i=0;i<CODEC_VP8_MAX_PARTITION_NUMBER;++i)
    {
        oss<< "uiPartitionSize["<<std::dec<<+i<<"]: "<<std::hex<< +picParams->uiPartitionSize[i]<<std::endl;
    }
    oss<< "uiStatusReportFeedbackNumber: "<<std::hex<< +picParams->uiStatusReportFeedbackNumber<<std::endl;

    const char* fileName = m_debugInterface->CreateFileName(
        "_DEC",
        CodechalDbgBufferType::bufPicParams,
        CodechalDbgExtType::txt);

    std::ofstream ofs(fileName, std::ios::out);
    ofs << oss.str();
    ofs.close();
    return MOS_STATUS_SUCCESS;
}

MOS_STATUS CodechalDecodeVp8::DumpIQParams(
    PCODEC_VP8_IQ_MATRIX_PARAMS          matrixData)
{
    CODECHAL_DEBUG_FUNCTION_ENTER;

    if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
    {
        return MOS_STATUS_SUCCESS;
    }

    CODECHAL_DEBUG_CHK_NULL(matrixData);

    std::ostringstream oss;
    oss.setf(std::ios::showbase | std::ios::uppercase);

    for(uint8_t i=0;i<4;++i)
    {
        for(uint8_t j=0;j<6;++j)
        {
            oss<< "quantization_values["<< std::dec<< +i <<"]["<<+j<<"]: "<<std::hex<< +matrixData->quantization_values[i][j]<<std::endl;
        }
    }

    const char* fileName = m_debugInterface->CreateFileName(
        "_DEC",
        CodechalDbgBufferType::bufIqParams,
        CodechalDbgExtType::txt);

    std::ofstream ofs(fileName, std::ios::out);
    ofs << oss.str();
    ofs.close();
    return MOS_STATUS_SUCCESS;
}

#endif