/* * Copyright (C) 2009 The Android Open Source Project * Modified for use by h264bsd standalone library * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /*------------------------------------------------------------------------------     Table of contents      1. Include headers     2. External compiler flags     3. Module defines     4. Local function prototypes     5. Functions          h264bsdDecodeSliceData          SetMbParams          h264bsdMarkSliceCorrupted ------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------    1. Include headers------------------------------------------------------------------------------*/ #include "h264bsd_slice_data.h"#include "h264bsd_util.h"#include "h264bsd_vlc.h" /*------------------------------------------------------------------------------    2. External compiler flags-------------------------------------------------------------------------------- --------------------------------------------------------------------------------    3. Module defines------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------    4. Local function prototypes------------------------------------------------------------------------------*/ static void SetMbParams(mbStorage_t *pMb, sliceHeader_t *pSlice, u32 sliceId,    i32 chromaQpIndexOffset); /*------------------------------------------------------------------------------    5.1  Function name: h264bsdDecodeSliceData         Functional description:            Decode one slice. Function decodes stream data, i.e. macroblocks            and possible skip_run fields. h264bsdDecodeMacroblock function is            called to handle all other macroblock related processing.            Macroblock to slice group mapping is considered when next            macroblock to process is determined (h264bsdNextMbAddress function)            map         Inputs:            pStrmData       pointer to stream data structure            pStorage        pointer to storage structure            currImage       pointer to current processed picture, needed for                            intra prediction of the macroblocks            pSliceHeader    pointer to slice header of the current slice         Outputs:            currImage       processed macroblocks are written to current image            pStorage        mbStorage structure of each processed macroblock                            is updated here         Returns:            HANTRO_OK       success            HANTRO_NOK      invalid stream data ------------------------------------------------------------------------------*/ u32 h264bsdDecodeSliceData(strmData_t *pStrmData, storage_t *pStorage,    image_t *currImage, sliceHeader_t *pSliceHeader){ /* Variables */     u8 mbData[384 + 15 + 32];    u8 *data;    u32 tmp;    u32 skipRun;    u32 prevSkipped;    u32 currMbAddr;    u32 moreMbs;    u32 mbCount;    i32 qpY;    macroblockLayer_t *mbLayer; /* Code */     ASSERT(pStrmData);    ASSERT(pSliceHeader);    ASSERT(pStorage);    ASSERT(pSliceHeader->firstMbInSlice < pStorage->picSizeInMbs);     /* ensure 16-byte alignment */    data = (u8*)ALIGN(mbData, 16);     mbLayer = pStorage->mbLayer;     currMbAddr = pSliceHeader->firstMbInSlice;    skipRun = 0;    prevSkipped = HANTRO_FALSE;     /* increment slice index, will be one for decoding of the first slice of     * the picture */    pStorage->slice->sliceId++;     /* lastMbAddr stores address of the macroblock that was last successfully     * decoded, needed for error handling */    pStorage->slice->lastMbAddr = 0;     mbCount = 0;    /* initial quantization parameter for the slice is obtained as the sum of     * initial QP for the picture and sliceQpDelta for the current slice */    qpY = (i32)pStorage->activePps->picInitQp + pSliceHeader->sliceQpDelta;    do    {        /* primary picture and already decoded macroblock -> error */        if (!pSliceHeader->redundantPicCnt && pStorage->mb[currMbAddr].decoded)        {            EPRINT("Primary and already decoded");            return(HANTRO_NOK);        }         SetMbParams(pStorage->mb + currMbAddr, pSliceHeader,            pStorage->slice->sliceId, pStorage->activePps->chromaQpIndexOffset);         if (!IS_I_SLICE(pSliceHeader->sliceType))        {            if (!prevSkipped)            {                tmp = h264bsdDecodeExpGolombUnsigned(pStrmData, &skipRun);                if (tmp != HANTRO_OK)                    return(tmp);                /* skip_run shall be less than or equal to number of                 * macroblocks left */                if (skipRun > (pStorage->picSizeInMbs - currMbAddr))                {                    EPRINT("skip_run");                    return(HANTRO_NOK);                }                if (skipRun)                {                    prevSkipped = HANTRO_TRUE;                    memset(&mbLayer->mbPred, 0, sizeof(mbPred_t));                    /* mark current macroblock skipped */                    mbLayer->mbType = P_Skip;                }            }        }         if (skipRun)        {            DEBUG(("Skipping macroblock %d\n", currMbAddr));            skipRun--;        }        else        {            prevSkipped = HANTRO_FALSE;            tmp = h264bsdDecodeMacroblockLayer(pStrmData, mbLayer,                pStorage->mb + currMbAddr, pSliceHeader->sliceType,                pSliceHeader->numRefIdxL0Active);            if (tmp != HANTRO_OK)            {                EPRINT("macroblock_layer");                return(tmp);            }        }         tmp = h264bsdDecodeMacroblock(pStorage->mb + currMbAddr, mbLayer,            currImage, pStorage->dpb, &qpY, currMbAddr,            pStorage->activePps->constrainedIntraPredFlag, data);        if (tmp != HANTRO_OK)        {            EPRINT("MACRO_BLOCK");            return(tmp);        }         /* increment macroblock count only for macroblocks that were decoded         * for the first time (redundant slices) */        if (pStorage->mb[currMbAddr].decoded == 1)            mbCount++;         /* keep on processing as long as there is stream data left or         * processing of macroblocks to be skipped based on the last skipRun is         * not finished */        moreMbs = (h264bsdMoreRbspData(pStrmData) || skipRun) ?                                        HANTRO_TRUE : HANTRO_FALSE;         /* lastMbAddr is only updated for intra slices (all macroblocks of         * inter slices will be lost in case of an error) */        if (IS_I_SLICE(pSliceHeader->sliceType))            pStorage->slice->lastMbAddr = currMbAddr;         currMbAddr = h264bsdNextMbAddress(pStorage->sliceGroupMap,            pStorage->picSizeInMbs, currMbAddr);        /* data left in the buffer but no more macroblocks for current slice         * group -> error */        if (moreMbs && !currMbAddr)        {            EPRINT("Next mb address");            return(HANTRO_NOK);        }     } while (moreMbs);     if ((pStorage->slice->numDecodedMbs + mbCount) > pStorage->picSizeInMbs)    {        EPRINT("Num decoded mbs");        return(HANTRO_NOK);    }     pStorage->slice->numDecodedMbs += mbCount;     return(HANTRO_OK); } /*------------------------------------------------------------------------------    5.2  Function: SetMbParams         Functional description:            Set macroblock parameters that remain constant for this slice         Inputs:            pSlice      pointer to current slice header            sliceId     id of the current slice            chromaQpIndexOffset         Outputs:            pMb         pointer to macroblock structure which is updated         Returns:            none ------------------------------------------------------------------------------*/ static void SetMbParams(mbStorage_t *pMb, sliceHeader_t *pSlice, u32 sliceId,    i32 chromaQpIndexOffset){ /* Variables */    u32 tmp1;    i32 tmp2, tmp3; /* Code */     tmp1 = pSlice->disableDeblockingFilterIdc;    tmp2 = pSlice->sliceAlphaC0Offset;    tmp3 = pSlice->sliceBetaOffset;    pMb->sliceId = sliceId;    pMb->disableDeblockingFilterIdc = tmp1;    pMb->filterOffsetA = tmp2;    pMb->filterOffsetB = tmp3;    pMb->chromaQpIndexOffset = chromaQpIndexOffset; } /*------------------------------------------------------------------------------    5.3  Function name: h264bsdMarkSliceCorrupted         Functional description:            Mark macroblocks of the slice corrupted. If lastMbAddr in the slice            storage is set -> picWidhtInMbs (or at least 10) macroblocks back            from  the lastMbAddr are marked corrupted. However, if lastMbAddr            is not set -> all macroblocks of the slice are marked.         Inputs:            pStorage        pointer to storage structure            firstMbInSlice  address of the first macroblock in the slice, this                            identifies the slice to be marked corrupted         Outputs:            pStorage        mbStorage for the corrupted macroblocks updated         Returns:            none ------------------------------------------------------------------------------*/ void h264bsdMarkSliceCorrupted(storage_t *pStorage, u32 firstMbInSlice){ /* Variables */     u32 tmp, i;    u32 sliceId;    u32 currMbAddr; /* Code */     ASSERT(pStorage);    ASSERT(firstMbInSlice < pStorage->picSizeInMbs);     currMbAddr = firstMbInSlice;     sliceId = pStorage->slice->sliceId;     /* DecodeSliceData sets lastMbAddr for I slices -> if it was set, go back     * MAX(picWidthInMbs, 10) macroblocks and start marking from there */    if (pStorage->slice->lastMbAddr)    {        ASSERT(pStorage->mb[pStorage->slice->lastMbAddr].sliceId == sliceId);        i = pStorage->slice->lastMbAddr - 1;        tmp = 0;        while (i > currMbAddr)        {            if (pStorage->mb[i].sliceId == sliceId)            {                tmp++;                if (tmp >= MAX(pStorage->activeSps->picWidthInMbs, 10))                    break;            }            i--;        }        currMbAddr = i;    }     do    {         if ( (pStorage->mb[currMbAddr].sliceId == sliceId) &&             (pStorage->mb[currMbAddr].decoded) )        {            pStorage->mb[currMbAddr].decoded--;        }        else        {            break;        }         currMbAddr = h264bsdNextMbAddress(pStorage->sliceGroupMap,            pStorage->picSizeInMbs, currMbAddr);     } while (currMbAddr); }