xref: /frameworks/base/media/libstagefright/codecs/m4v_h263/dec/src/packet_util.cpp

/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * 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.
 * -------------------------------------------------------------------
 */
#include "mp4dec_lib.h"
#include "vlc_decode.h"
#include "bitstream.h"


/***********************************************************CommentBegin******
*       04/13/2000 : initial modification to the new PV-Decoder
*                            Lib format.
*       04/16/2001 : Removed PV_END_OF_BUFFER case, error resilience
***********************************************************CommentEnd********/
PV_STATUS PV_ReadVideoPacketHeader(VideoDecData *video, int *next_MB)
{
    PV_STATUS status;
    Vol *currVol = video->vol[video->currLayer];
    Vop *currVop = video->currVop;
    BitstreamDecVideo *stream = video->bitstream;
    int fcode_forward;
    int resync_marker_length;
    int nbits = video->nBitsForMBID;
    uint32 tmpvar32;
    uint tmpvar16;
    int16 quantizer;
    int nTotalMB = video->nTotalMB;

    fcode_forward = currVop->fcodeForward;
    resync_marker_length = 17;

    if (currVop->predictionType != I_VOP) resync_marker_length = 16 + fcode_forward;

    status = PV_BitstreamShowBitsByteAlign(stream, resync_marker_length, &tmpvar32);
    /*  if (status != PV_SUCCESS && status != PV_END_OF_BUFFER) return status; */
    if (tmpvar32 == RESYNC_MARKER)
    {
//      DecNextStartCode(stream);
        PV_BitstreamByteAlign(stream);
        BitstreamReadBits32(stream, resync_marker_length);

        *next_MB = (int) BitstreamReadBits16(stream, nbits);
//      if (*next_MB <= video->mbnum)   /*  needs more investigation */
//          *next_MB = video->mbnum+1;

        if (*next_MB >= nTotalMB)  /* fix  04/05/01 */
        {
            *next_MB = video->mbnum + 1;
            if (*next_MB >= nTotalMB)    /* this check is needed  */
                *next_MB = nTotalMB - 1;
        }
        quantizer = (int16) BitstreamReadBits16(stream, currVol->quantPrecision);
        if (quantizer == 0) return PV_FAIL;        /*  04/03/01 */

        currVop->quantizer = quantizer;

        /* if we have HEC, read some redundant VOP header information */
        /* this part needs improvement  04/05/01 */
        if (BitstreamRead1Bits(stream))
        {
            int time_base = -1;

            /* modulo_time_base (? bits) */
            do
            {
                time_base++;
                tmpvar16 = BitstreamRead1Bits(stream);
            }
            while (tmpvar16 == 1);

            /* marker bit */
            BitstreamRead1Bits(stream);

            /* vop_time_increment (1-15 bits) */
            BitstreamReadBits16(stream, currVol->nbitsTimeIncRes);

            /* marker bit */
            BitstreamRead1Bits(stream);

            /* vop_prediction_type (2 bits) */
            BitstreamReadBits16(stream, 2);

            /* Added intra_dc_vlc_thr reading  */
            BitstreamReadBits16(stream, 3);

            /* fcodes */
            if (currVop->predictionType != I_VOP)
            {
                fcode_forward = (int) BitstreamReadBits16(stream, 3);

                if (currVop->predictionType == B_VOP)
                {
                    BitstreamReadBits16(stream, 3);
                }
            }

        }
    }
    else
    {
        PV_BitstreamByteAlign(stream);  /*  */
        status = BitstreamCheckEndBuffer(stream);   /* return end_of_VOP  03/30/01 */
        if (status != PV_SUCCESS)
        {
            return status;
        }
        status = BitstreamShowBits32HC(stream, &tmpvar32);   /*  07/07/01 */
        /* -16 = 0xFFFFFFF0*/
        if ((tmpvar32 & 0xFFFFFFF0) == VISUAL_OBJECT_SEQUENCE_START_CODE) /* start code mask 00 00 01 */

        {
            /* we don't have to check for legl stuffing here.   05/08/2000 */
            return PV_END_OF_VOP;
        }
        else
        {
            return PV_FAIL;
        }
    }

    return PV_SUCCESS;
}



/***********************************************************CommentBegin******
*       3/10/00  : initial modification to the
*                new PV-Decoder Lib format.
*       04/17/01 : remove PV_END_OF_BUFFER, error checking
***********************************************************CommentEnd********/
PV_STATUS PV_GobHeader(VideoDecData *video)
{
    uint32 tmpvar;
    Vop *currVop = video->currVop;
    BitstreamDecVideo *stream = video->bitstream;
    int quantPrecision = 5;
    int16 quantizer;

    BitstreamShowBits32(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);

    if (tmpvar != GOB_RESYNC_MARKER)
    {
        PV_BitstreamShowBitsByteAlign(stream, GOB_RESYNC_MARKER_LENGTH, &tmpvar);

        if (tmpvar != GOB_RESYNC_MARKER)
        {
            return PV_FAIL;
        }
        else
            PV_BitstreamByteAlign(stream);  /* if bytealigned GOBHEADER search is performed */
        /* then no more noforcestuffing  */
    }

    /* we've got a GOB header info here */
    BitstreamShowBits32(stream, GOB_RESYNC_MARKER_LENGTH + 5, &tmpvar);
    tmpvar &= 0x1F;

    if (tmpvar == 0)
    {
        return PV_END_OF_VOP;
    }

    if (tmpvar == 31)
    {
        PV_BitstreamFlushBits(stream, GOB_RESYNC_MARKER_LENGTH + 5);
        BitstreamByteAlignNoForceStuffing(stream);
        return PV_END_OF_VOP;
    }

    PV_BitstreamFlushBits(stream, GOB_RESYNC_MARKER_LENGTH + 5);
    currVop->gobNumber = (int) tmpvar;
    if (currVop->gobNumber >= video->nGOBinVop) return PV_FAIL;
    currVop->gobFrameID = (int) BitstreamReadBits16(stream, 2);
    quantizer = (int16) BitstreamReadBits16(stream, quantPrecision);
    if (quantizer == 0)   return PV_FAIL;         /*  04/03/01 */

    currVop->quantizer = quantizer;
    return PV_SUCCESS;
}
#ifdef PV_ANNEX_IJKT_SUPPORT
PV_STATUS PV_H263SliceHeader(VideoDecData *video, int *next_MB)
{
    PV_STATUS status;
    uint32 tmpvar;
    Vop *currVop = video->currVop;
    BitstreamDecVideo *stream = video->bitstream;
    int nTotalMB = video->nTotalMB;
    int16 quantizer;

    PV_BitstreamShowBitsByteAlignNoForceStuffing(stream, 17, &tmpvar);
    if (tmpvar == RESYNC_MARKER)
    {
        BitstreamByteAlignNoForceStuffing(stream);
        PV_BitstreamFlushBits(stream, 17);
        if (!BitstreamRead1Bits(stream))
        {
            return PV_FAIL;
        }
        *next_MB = BitstreamReadBits16(stream, video->nBitsForMBID);
        if (*next_MB >= nTotalMB)  /* fix  04/05/01 */
        {
            *next_MB = video->mbnum + 1;
            if (*next_MB >= nTotalMB)    /* this check is needed  */
                *next_MB = nTotalMB - 1;
        }
        /* we will not parse sebp2 for large pictures 3GPP */
        quantizer = (int16) BitstreamReadBits16(stream, 5);
        if (quantizer == 0) return PV_FAIL;

        currVop->quantizer = quantizer;
        if (!BitstreamRead1Bits(stream))
        {
            return PV_FAIL;
        }
        currVop->gobFrameID = (int) BitstreamReadBits16(stream, 2);
    }
    else
    {
        status = BitstreamCheckEndBuffer(stream);   /* return end_of_VOP  03/30/01 */
        if (status != PV_SUCCESS)
        {
            return status;
        }
        PV_BitstreamShowBitsByteAlign(stream, SHORT_VIDEO_START_MARKER_LENGTH, &tmpvar);

        if (tmpvar == SHORT_VIDEO_START_MARKER)
        {
            /* we don't have to check for legal stuffing here.   05/08/2000 */
            return PV_END_OF_VOP;
        }
        else
        {
            return PV_FAIL;
        }
    }
    return PV_SUCCESS;
}
#endif