xref: /frameworks/av/media/libstagefright/codecs/m4v_h263/enc/src/mp4enc_api.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 "mp4enc_lib.h"
#include "bitstream_io.h"
#include "rate_control.h"
#include "m4venc_oscl.h"


/* Inverse normal zigzag */
const static Int zigzag_i[NCOEFF_BLOCK] =
{
    0, 1, 8, 16, 9, 2, 3, 10,
    17, 24, 32, 25, 18, 11, 4, 5,
    12, 19, 26, 33, 40, 48, 41, 34,
    27, 20, 13, 6, 7, 14, 21, 28,
    35, 42, 49, 56, 57, 50, 43, 36,
    29, 22, 15, 23, 30, 37, 44, 51,
    58, 59, 52, 45, 38, 31, 39, 46,
    53, 60, 61, 54, 47, 55, 62, 63
};

/* INTRA */
const static Int mpeg_iqmat_def[NCOEFF_BLOCK] =
    {  8, 17, 18, 19, 21, 23, 25, 27,
       17, 18, 19, 21, 23, 25, 27, 28,
       20, 21, 22, 23, 24, 26, 28, 30,
       21, 22, 23, 24, 26, 28, 30, 32,
       22, 23, 24, 26, 28, 30, 32, 35,
       23, 24, 26, 28, 30, 32, 35, 38,
       25, 26, 28, 30, 32, 35, 38, 41,
       27, 28, 30, 32, 35, 38, 41, 45
    };

/* INTER */
const static Int mpeg_nqmat_def[64]  =
    { 16, 17, 18, 19, 20, 21, 22, 23,
      17, 18, 19, 20, 21, 22, 23, 24,
      18, 19, 20, 21, 22, 23, 24, 25,
      19, 20, 21, 22, 23, 24, 26, 27,
      20, 21, 22, 23, 25, 26, 27, 28,
      21, 22, 23, 24, 26, 27, 28, 30,
      22, 23, 24, 26, 27, 28, 30, 31,
      23, 24, 25, 27, 28, 30, 31, 33
    };

/* Profiles and levels */
/* Simple profile(level 0-3) and Core profile (level 1-2) */
/* {SPL0, SPL1, SPL2, SPL3, CPL1, CPL2, CPL2, CPL2} , SPL0: Simple Profile@Level0, CPL1: Core Profile@Level1, the last two are redundant for easy table manipulation */
const static Int profile_level_code[8] =
{
    0x08, 0x01, 0x02, 0x03, 0x21, 0x22, 0x22, 0x22
};

const static Int profile_level_max_bitrate[8] =
{
    64000, 64000, 128000, 384000, 384000, 2000000, 2000000, 2000000
};

const static Int profile_level_max_packet_size[8] =
{
    2048, 2048, 4096, 8192, 4096, 8192, 8192, 8192
};

const static Int profile_level_max_mbsPerSec[8] =
{
    1485, 1485, 5940, 11880, 5940, 23760, 23760, 23760
};

const static Int profile_level_max_VBV_size[8] =
{
    163840, 163840, 655360, 655360, 262144, 1310720, 1310720, 1310720
};


/* Simple scalable profile (level 0-2) and Core scalable profile (level 1-3) */
/* {SSPL0, SSPL1, SSPL2, SSPL2, CSPL1, CSPL2, CSPL3, CSPL3} , SSPL0: Simple Scalable Profile@Level0, CSPL1: Core Scalable Profile@Level1, the fourth is redundant for easy table manipulation */

const static Int scalable_profile_level_code[8] =
{
    0x10, 0x11, 0x12, 0x12, 0xA1, 0xA2, 0xA3, 0xA3
};

const static Int scalable_profile_level_max_bitrate[8] =
{
    128000, 128000, 256000, 256000, 768000, 1500000, 4000000, 4000000
};

/* in bits */
const static Int scalable_profile_level_max_packet_size[8] =
{
    2048, 2048, 4096, 4096, 4096, 4096, 16384, 16384
};

const static Int scalable_profile_level_max_mbsPerSec[8] =
{
    1485, 7425, 23760, 23760, 14850, 29700, 120960, 120960
};

const static Int scalable_profile_level_max_VBV_size[8] =
{
    163840, 655360, 655360, 655360, 1048576, 1310720, 1310720, 1310720
};


/* H263 profile 0 @ level 10-70 */
const static Int   h263Level[8] = {0, 10, 20, 30, 40, 50, 60, 70};
const static float rBR_bound[8] = {0, 1, 2, 6, 32, 64, 128, 256};
const static float max_h263_framerate[2] = {(float)30000 / (float)2002,
        (float)30000 / (float)1001
                                           };
const static Int   max_h263_width[2]  = {176, 352};
const static Int   max_h263_height[2] = {144, 288};

/* 6/2/2001, newly added functions to make PVEncodeVop more readable. */
Int DetermineCodingLayer(VideoEncData *video, Int *nLayer, ULong modTime);
void DetermineVopType(VideoEncData *video, Int currLayer);
Int UpdateSkipNextFrame(VideoEncData *video, ULong *modTime, Int *size, PV_STATUS status);
Bool SetProfile_BufferSize(VideoEncData *video, float delay, Int bInitialized);

#ifdef PRINT_RC_INFO
extern FILE *facct;
extern int tiTotalNumBitsGenerated;
extern int iStuffBits;
#endif

#ifdef PRINT_EC
extern FILE *fec;
#endif


/* ======================================================================== */
/*  Function : PVGetDefaultEncOption()                                      */
/*  Date     : 12/12/2005                                                   */
/*  Purpose  :                                                              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVGetDefaultEncOption(VideoEncOptions *encOption, Int encUseCase)
{
    VideoEncOptions defaultUseCase = {H263_MODE, profile_level_max_packet_size[SIMPLE_PROFILE_LEVEL0] >> 3,
                                      SIMPLE_PROFILE_LEVEL0, PV_OFF, 0, 1, 1000, 33, {144, 144}, {176, 176}, {15, 30}, {64000, 128000},
                                      {10, 10}, {12, 12}, {0, 0}, CBR_1, 0.0, PV_OFF, -1, 0, PV_OFF, 16, PV_OFF, 0, PV_ON
                                     };

    OSCL_UNUSED_ARG(encUseCase); // unused for now. Later we can add more defaults setting and use this
    // argument to select the right one.
    /* in the future we can create more meaningful use-cases */
    if (encOption == NULL)
    {
        return PV_FALSE;
    }

    M4VENC_MEMCPY(encOption, &defaultUseCase, sizeof(VideoEncOptions));

    return PV_TRUE;
}

/* ======================================================================== */
/*  Function : PVInitVideoEncoder()                                         */
/*  Date     : 08/22/2000                                                   */
/*  Purpose  : Initialization of MP4 Encoder and VO bitstream               */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :  5/21/01, allocate only yChan and assign uChan & vChan   */
/*              12/12/05, add encoding option as input argument         */
/* ======================================================================== */
OSCL_EXPORT_REF Bool    PVInitVideoEncoder(VideoEncControls *encoderControl, VideoEncOptions *encOption)
{

    Bool        status = PV_TRUE;
    Int         nLayers, idx, i, j;
    Int         max = 0, max_width = 0, max_height = 0, pitch, offset;
    Int         size = 0, nTotalMB = 0;
    VideoEncData *video;
    Vol         *pVol;
    VideoEncParams  *pEncParams;
    Int         temp_w, temp_h, mbsPerSec;

    /******************************************/
    /*      this part use to be PVSetEncode() */
    Int profile_table_index, *profile_level_table;
    Int profile_level = encOption->profile_level;
    Int PacketSize = encOption->packetSize << 3;
    Int timeInc, timeIncRes;
    float profile_max_framerate;
    VideoEncParams *encParams;

    if (encoderControl->videoEncoderData) /* this has been called */
    {
        if (encoderControl->videoEncoderInit) /* check if PVInitVideoEncoder() has been called  */
        {
            PVCleanUpVideoEncoder(encoderControl);
            encoderControl->videoEncoderInit = 0;
        }

        M4VENC_FREE(encoderControl->videoEncoderData);
        encoderControl->videoEncoderData = NULL;
    }
    encoderControl->videoEncoderInit = 0;   /* reset this value */

    video = (VideoEncData *)M4VENC_MALLOC(sizeof(VideoEncData)); /* allocate memory for encData */

    if (video == NULL)
        return PV_FALSE;

    M4VENC_MEMSET(video, 0, sizeof(VideoEncData));

    encoderControl->videoEncoderData = (void *) video;         /* set up pointer in VideoEncData structure */

    video->encParams = (VideoEncParams *)M4VENC_MALLOC(sizeof(VideoEncParams));
    if (video->encParams == NULL)
        goto CLEAN_UP;

    M4VENC_MEMSET(video->encParams, 0, sizeof(VideoEncParams));

    encParams = video->encParams;
    encParams->nLayers = encOption->numLayers;

    /* Check whether the input packetsize is valid (Note: put code here (before any memory allocation) in order to avoid memory leak */
    if ((Int)profile_level < (Int)(SIMPLE_SCALABLE_PROFILE_LEVEL0))  /* non-scalable profile */
    {
        profile_level_table = (Int *)profile_level_max_packet_size;
        profile_table_index = (Int)profile_level;
        if (encParams->nLayers != 1)
        {
            goto CLEAN_UP;
        }

        encParams->LayerMaxMbsPerSec[0] = profile_level_max_mbsPerSec[profile_table_index];

    }
    else   /* scalable profile */
    {
        profile_level_table = (Int *)scalable_profile_level_max_packet_size;
        profile_table_index = (Int)profile_level - (Int)(SIMPLE_SCALABLE_PROFILE_LEVEL0);
        if (encParams->nLayers < 2)
        {
            goto CLEAN_UP;
        }
        for (i = 0; i < encParams->nLayers; i++)
        {
            encParams->LayerMaxMbsPerSec[i] = scalable_profile_level_max_mbsPerSec[profile_table_index];
        }

    }

    /* cannot have zero size packet with these modes */
    if (PacketSize == 0)
    {
        if (encOption->encMode == DATA_PARTITIONING_MODE)
        {
            goto CLEAN_UP;
        }
        if (encOption->encMode == COMBINE_MODE_WITH_ERR_RES)
        {
            encOption->encMode = COMBINE_MODE_NO_ERR_RES;
        }
    }

    if (encOption->gobHeaderInterval == 0)
    {
        if (encOption->encMode == H263_MODE_WITH_ERR_RES)
        {
            encOption->encMode = H263_MODE;
        }

        if (encOption->encMode == SHORT_HEADER_WITH_ERR_RES)
        {
            encOption->encMode = SHORT_HEADER;
        }
    }

    if (PacketSize > profile_level_table[profile_table_index])
        goto CLEAN_UP;

    /* Initial Defaults for all Modes */

    encParams->SequenceStartCode = 1;
    encParams->GOV_Enabled = 0;
    encParams->RoundingType = 0;
    encParams->IntraDCVlcThr = PV_MAX(PV_MIN(encOption->intraDCVlcTh, 7), 0);
    encParams->ACDCPrediction = ((encOption->useACPred == PV_ON) ? TRUE : FALSE);
    encParams->RC_Type = encOption->rcType;
    encParams->Refresh = encOption->numIntraMB;
    encParams->ResyncMarkerDisable = 0; /* Enable Resync Marker */

    for (i = 0; i < encOption->numLayers; i++)
    {
#ifdef NO_MPEG_QUANT
        encParams->QuantType[i] = 0;
#else
        encParams->QuantType[i] = encOption->quantType[i];      /* H263 */
#endif
        if (encOption->pQuant[i] >= 1 && encOption->pQuant[i] <= 31)
        {
            encParams->InitQuantPvop[i] = encOption->pQuant[i];
        }
        else
        {
            goto CLEAN_UP;
        }
        if (encOption->iQuant[i] >= 1 && encOption->iQuant[i] <= 31)
        {
            encParams->InitQuantIvop[i] = encOption->iQuant[i];
        }
        else
        {
            goto CLEAN_UP;
        }
    }

    encParams->HalfPel_Enabled = 1;
    encParams->SearchRange = encOption->searchRange; /* 4/16/2001 */
    encParams->FullSearch_Enabled = 0;
#ifdef NO_INTER4V
    encParams->MV8x8_Enabled = 0;
#else
    encParams->MV8x8_Enabled = 0;// comment out for now!! encOption->mv8x8Enable;
#endif
    encParams->H263_Enabled = 0;
    encParams->GOB_Header_Interval = 0; // need to be reset to 0
    encParams->IntraPeriod = encOption->intraPeriod;    /* Intra update period update default*/
    encParams->SceneChange_Det = encOption->sceneDetect;
    encParams->FineFrameSkip_Enabled = 0;
    encParams->NoFrameSkip_Enabled = encOption->noFrameSkipped;
    encParams->NoPreSkip_Enabled = encOption->noFrameSkipped;
    encParams->GetVolHeader[0] = 0;
    encParams->GetVolHeader[1] = 0;
    encParams->ResyncPacketsize = encOption->packetSize << 3;
    encParams->LayerMaxBitRate[0] = 0;
    encParams->LayerMaxBitRate[1] = 0;
    encParams->LayerMaxFrameRate[0] = (float)0.0;
    encParams->LayerMaxFrameRate[1] = (float)0.0;
    encParams->VBV_delay = encOption->vbvDelay;  /* 2sec VBV buffer size */

    switch (encOption->encMode)
    {

        case SHORT_HEADER:
        case SHORT_HEADER_WITH_ERR_RES:

            /* From Table 6-26 */
            encParams->nLayers = 1;
            encParams->QuantType[0] = 0;    /*H263 */
            encParams->ResyncMarkerDisable = 1; /* Disable Resync Marker */
            encParams->DataPartitioning = 0; /* Combined Mode */
            encParams->ReversibleVLC = 0;   /* Disable RVLC */
            encParams->RoundingType = 0;
            encParams->IntraDCVlcThr = 7;   /* use_intra_dc_vlc = 0 */
            encParams->MV8x8_Enabled = 0;

            encParams->GOB_Header_Interval = encOption->gobHeaderInterval;
            encParams->H263_Enabled = 2;
            encParams->GOV_Enabled = 0;
            encParams->TimeIncrementRes = 30000;        /* timeIncrementRes for H263 */
            break;

        case H263_MODE:
        case H263_MODE_WITH_ERR_RES:

            /* From Table 6-26 */
            encParams->nLayers = 1;
            encParams->QuantType[0] = 0;    /*H263 */
            encParams->ResyncMarkerDisable = 1; /* Disable Resync Marker */
            encParams->DataPartitioning = 0; /* Combined Mode */
            encParams->ReversibleVLC = 0;   /* Disable RVLC */
            encParams->RoundingType = 0;
            encParams->IntraDCVlcThr = 7;   /* use_intra_dc_vlc = 0 */
            encParams->MV8x8_Enabled = 0;

            encParams->H263_Enabled = 1;
            encParams->GOV_Enabled = 0;
            encParams->TimeIncrementRes = 30000;        /* timeIncrementRes for H263 */

            break;
#ifndef H263_ONLY
        case DATA_PARTITIONING_MODE:

            encParams->DataPartitioning = 1;        /* Base Layer Data Partitioning */
            encParams->ResyncMarkerDisable = 0; /* Resync Marker */
#ifdef NO_RVLC
            encParams->ReversibleVLC = 0;
#else
            encParams->ReversibleVLC = (encOption->rvlcEnable == PV_ON); /* RVLC when Data Partitioning */
#endif
            encParams->ResyncPacketsize = PacketSize;
            break;

        case COMBINE_MODE_WITH_ERR_RES:

            encParams->DataPartitioning = 0;        /* Combined Mode */
            encParams->ResyncMarkerDisable = 0; /* Resync Marker */
            encParams->ReversibleVLC = 0;           /* No RVLC */
            encParams->ResyncPacketsize = PacketSize;
            break;

        case COMBINE_MODE_NO_ERR_RES:

            encParams->DataPartitioning = 0;        /* Combined Mode */
            encParams->ResyncMarkerDisable = 1; /* Disable Resync Marker */
            encParams->ReversibleVLC = 0;           /* No RVLC */
            break;
#endif
        default:
            goto CLEAN_UP;
    }
    /* Set the constraints (maximum values) according to the input profile and level */
    /* Note that profile_table_index is already figured out above */

    /* base layer */
    encParams->profile_table_index    = profile_table_index; /* Used to limit the profile and level in SetProfile_BufferSize() */

    /* check timeIncRes */
    timeIncRes = encOption->timeIncRes;
    timeInc = encOption->tickPerSrc;

    if ((timeIncRes >= 1) && (timeIncRes <= 65536) && (timeInc < timeIncRes) && (timeInc != 0))
    {
        if (!encParams->H263_Enabled)
        {
            encParams->TimeIncrementRes = timeIncRes;
        }
        else
        {
            encParams->TimeIncrementRes = 30000;
//          video->FrameRate = 30000/(float)1001; /* fix it to 29.97 fps */
        }
        video->FrameRate = timeIncRes / ((float)timeInc);
    }
    else
    {
        goto CLEAN_UP;
    }

    /* check frame dimension */
    if (encParams->H263_Enabled)
    {
        switch (encOption->encWidth[0])
        {
            case 128:
                if (encOption->encHeight[0] != 96) /* source_format = 1 */
                    goto CLEAN_UP;
                break;
            case 176:
                if (encOption->encHeight[0] != 144) /* source_format = 2 */
                    goto CLEAN_UP;
                break;
            case 352:
                if (encOption->encHeight[0] != 288) /* source_format = 2 */
                    goto CLEAN_UP;
                break;

            case 704:
                if (encOption->encHeight[0] != 576) /* source_format = 2 */
                    goto CLEAN_UP;
                break;
            case 1408:
                if (encOption->encHeight[0] != 1152) /* source_format = 2 */
                    goto CLEAN_UP;
                break;

            default:
                goto CLEAN_UP;
        }
    }
    for (i = 0; i < encParams->nLayers; i++)
    {
        encParams->LayerHeight[i] = encOption->encHeight[i];
        encParams->LayerWidth[i] = encOption->encWidth[i];
    }

    /* check frame rate */
    for (i = 0; i < encParams->nLayers; i++)
    {
        encParams->LayerFrameRate[i] = encOption->encFrameRate[i];
    }

    if (encParams->nLayers > 1)
    {
        if (encOption->encFrameRate[0] == encOption->encFrameRate[1] ||
                encOption->encFrameRate[0] == 0. || encOption->encFrameRate[1] == 0.) /* 7/31/03 */
            goto CLEAN_UP;
    }
    /* set max frame rate */
    for (i = 0; i < encParams->nLayers; i++)
    {

        /* Make sure the maximum framerate is consistent with the given profile and level */
        nTotalMB = ((encParams->LayerWidth[i] + 15) / 16) * ((encParams->LayerHeight[i] + 15) / 16);

        if (nTotalMB > 0)
            profile_max_framerate = (float)encParams->LayerMaxMbsPerSec[i] / (float)nTotalMB;

        else
            profile_max_framerate = (float)30.0;

        encParams->LayerMaxFrameRate[i] = PV_MIN(profile_max_framerate, encParams->LayerFrameRate[i]);
    }

    /* check bit rate */
    /* set max bit rate */
    for (i = 0; i < encParams->nLayers; i++)
    {
        encParams->LayerBitRate[i] = encOption->bitRate[i];
        encParams->LayerMaxBitRate[i] = encOption->bitRate[i];
    }
    if (encParams->nLayers > 1)
    {
        if (encOption->bitRate[0] == encOption->bitRate[1] ||
                encOption->bitRate[0] == 0 || encOption->bitRate[1] == 0) /* 7/31/03 */
            goto CLEAN_UP;
    }
    /* check rate control and vbv delay*/
    encParams->RC_Type = encOption->rcType;

    if (encOption->vbvDelay == 0.0) /* set to default */
    {
        switch (encOption->rcType)
        {
            case CBR_1:
            case CBR_2:
                encParams->VBV_delay = (float)2.0; /* default 2sec VBV buffer size */
                break;

            case CBR_LOWDELAY:
                encParams->VBV_delay = (float)0.5; /* default 0.5sec VBV buffer size */
                break;

            case VBR_1:
            case VBR_2:
                encParams->VBV_delay = (float)10.0; /* default 10sec VBV buffer size */
                break;
            default:
                break;
        }
    }
    else /* force this value */
    {
        encParams->VBV_delay = encOption->vbvDelay;
    }

    /* check search range */
    if (encParams->H263_Enabled && encOption->searchRange > 16)
    {
        encParams->SearchRange = 16; /* 4/16/2001 */
    }

    /*****************************************/
    /* checking for conflict between options */
    /*****************************************/

    if (video->encParams->RC_Type == CBR_1 || video->encParams->RC_Type == CBR_2 || video->encParams->RC_Type == CBR_LOWDELAY)  /* if CBR */
    {
#ifdef _PRINT_STAT
        if (video->encParams->NoFrameSkip_Enabled == PV_ON ||
                video->encParams->NoPreSkip_Enabled == PV_ON) /* don't allow frame skip*/
            printf("WARNING!!!! CBR with NoFrameSkip\n");
#endif
    }
    else if (video->encParams->RC_Type == CONSTANT_Q)   /* constant_Q */
    {
        video->encParams->NoFrameSkip_Enabled = PV_ON;  /* no frame skip */
        video->encParams->NoPreSkip_Enabled = PV_ON;    /* no frame skip */
#ifdef _PRINT_STAT
        printf("Turn on NoFrameSkip\n");
#endif
    }

    if (video->encParams->NoFrameSkip_Enabled == PV_ON) /* if no frame skip */
    {
        video->encParams->FineFrameSkip_Enabled = PV_OFF;
#ifdef _PRINT_STAT
        printf("NoFrameSkip !!! may violate VBV_BUFFER constraint.\n");
        printf("Turn off FineFrameSkip\n");
#endif
    }

    /******************************************/
    /******************************************/

    nLayers = video->encParams->nLayers; /* Number of Layers to be encoded */

    /* Find the maximum width*height for memory allocation of the VOPs */
    for (idx = 0; idx < nLayers; idx++)
    {
        temp_w = video->encParams->LayerWidth[idx];
        temp_h = video->encParams->LayerHeight[idx];

        if ((temp_w*temp_h) > max)
        {
            max = temp_w * temp_h;
            max_width = ((temp_w + 15) >> 4) << 4;
            max_height = ((temp_h + 15) >> 4) << 4;
            nTotalMB = ((max_width * max_height) >> 8);
        }

        /* Check if the video size and framerate(MBsPerSec) are vald */
        mbsPerSec = (Int)(nTotalMB * video->encParams->LayerFrameRate[idx]);
        if (mbsPerSec > video->encParams->LayerMaxMbsPerSec[idx]) status = PV_FALSE;
    }

    /****************************************************/
    /* Set Profile and Video Buffer Size for each layer */
    /****************************************************/
    if (video->encParams->RC_Type == CBR_LOWDELAY) video->encParams->VBV_delay = 0.5; /* For CBR_LOWDELAY, we set 0.5sec buffer */
    status = SetProfile_BufferSize(video, video->encParams->VBV_delay, 1);
    if (status != PV_TRUE)
        goto CLEAN_UP;

    /****************************************/
    /* memory allocation and initialization */
    /****************************************/

    if (video == NULL) goto CLEAN_UP;

    /* cyclic reference for passing through both structures */
    video->videoEncControls = encoderControl;

    //video->currLayer = 0; /* Set current Layer to 0 */
    //video->currFrameNo = 0; /* Set current frame Number to 0 */
    video->nextModTime = 0;
    video->nextEncIVop = 0; /* Sets up very first frame to be I-VOP! */
    video->numVopsInGOP = 0; /* counter for Vops in Gop, 2/8/01 */

    //video->frameRate = video->encParams->LayerFrameRate[0]; /* Set current layer frame rate */

    video->QPMB = (UChar *) M4VENC_MALLOC(nTotalMB * sizeof(UChar)); /* Memory for MB quantizers */
    if (video->QPMB == NULL) goto CLEAN_UP;


    video->headerInfo.Mode = (UChar *) M4VENC_MALLOC(sizeof(UChar) * nTotalMB); /* Memory for MB Modes */
    if (video->headerInfo.Mode == NULL) goto CLEAN_UP;
    video->headerInfo.CBP = (UChar *) M4VENC_MALLOC(sizeof(UChar) * nTotalMB);   /* Memory for CBP (Y and C) of each MB */
    if (video->headerInfo.CBP == NULL) goto CLEAN_UP;

    /* Allocating motion vector space and interpolation memory*/

    video->mot = (MOT **)M4VENC_MALLOC(sizeof(MOT *) * nTotalMB);
    if (video->mot == NULL) goto CLEAN_UP;

    for (idx = 0; idx < nTotalMB; idx++)
    {
        video->mot[idx] = (MOT *)M4VENC_MALLOC(sizeof(MOT) * 8);
        if (video->mot[idx] == NULL)
        {
            goto CLEAN_UP;
        }
    }

    video->intraArray = (UChar *)M4VENC_MALLOC(sizeof(UChar) * nTotalMB);
    if (video->intraArray == NULL) goto CLEAN_UP;

    video->sliceNo = (UChar *) M4VENC_MALLOC(nTotalMB); /* Memory for Slice Numbers */
    if (video->sliceNo == NULL) goto CLEAN_UP;
    /* Allocating space for predDCAC[][8][16], Not that I intentionally  */
    /*    increase the dimension of predDCAC from [][6][15] to [][8][16] */
    /*    so that compilers can generate faster code to indexing the     */
    /*    data inside (by using << instead of *).         04/14/2000. */
    /* 5/29/01, use  decoder lib ACDC prediction memory scheme.  */
    video->predDC = (typeDCStore *) M4VENC_MALLOC(nTotalMB * sizeof(typeDCStore));
    if (video->predDC == NULL) goto CLEAN_UP;

    if (!video->encParams->H263_Enabled)
    {
        video->predDCAC_col = (typeDCACStore *) M4VENC_MALLOC(((max_width >> 4) + 1) * sizeof(typeDCACStore));
        if (video->predDCAC_col == NULL) goto CLEAN_UP;

        /* element zero will be used for storing vertical (col) AC coefficients */
        /*  the rest will be used for storing horizontal (row) AC coefficients  */
        video->predDCAC_row = video->predDCAC_col + 1;        /*  ACDC */

        video->acPredFlag = (Int *) M4VENC_MALLOC(nTotalMB * sizeof(Int)); /* Memory for acPredFlag */
        if (video->acPredFlag == NULL) goto CLEAN_UP;
    }

    video->outputMB = (MacroBlock *) M4VENC_MALLOC(sizeof(MacroBlock)); /* Allocating macroblock space */
    if (video->outputMB == NULL) goto CLEAN_UP;
    M4VENC_MEMSET(video->outputMB->block[0], 0, (sizeof(Short) << 6)*6);

    M4VENC_MEMSET(video->dataBlock, 0, sizeof(Short) << 7);
    /* Allocate (2*packetsize) working bitstreams */

    video->bitstream1 = BitStreamCreateEnc(2 * 4096); /*allocate working stream 1*/
    if (video->bitstream1 == NULL) goto CLEAN_UP;
    video->bitstream2 = BitStreamCreateEnc(2 * 4096); /*allocate working stream 2*/
    if (video->bitstream2 == NULL) goto CLEAN_UP;
    video->bitstream3 = BitStreamCreateEnc(2 * 4096); /*allocate working stream 3*/
    if (video->bitstream3 == NULL) goto CLEAN_UP;

    /* allocate overrun buffer */
    // this buffer is used when user's buffer is too small to hold one frame.
    // It is not needed for slice-based encoding.
    if (nLayers == 1)
    {
        video->oBSize = encParams->BufferSize[0] >> 3;
    }
    else
    {
        video->oBSize = PV_MAX((encParams->BufferSize[0] >> 3), (encParams->BufferSize[1] >> 3));
    }

    if (video->oBSize > DEFAULT_OVERRUN_BUFFER_SIZE || encParams->RC_Type == CONSTANT_Q) // set limit
    {
        video->oBSize = DEFAULT_OVERRUN_BUFFER_SIZE;
    }
    video->overrunBuffer = (UChar*) M4VENC_MALLOC(sizeof(UChar) * video->oBSize);
    if (video->overrunBuffer == NULL) goto CLEAN_UP;


    video->currVop = (Vop *) M4VENC_MALLOC(sizeof(Vop)); /* Memory for Current VOP */
    if (video->currVop == NULL) goto CLEAN_UP;

    /* add padding, 09/19/05 */
    if (video->encParams->H263_Enabled) /* make it conditional  11/28/05 */
    {
        pitch = max_width;
        offset = 0;
    }
    else
    {
        pitch = max_width + 32;
        offset = (pitch << 4) + 16;
        max_height += 32;
    }
    size = pitch * max_height;

    video->currVop->yChan = (PIXEL *)M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for currVop Y */
    if (video->currVop->yChan == NULL) goto CLEAN_UP;
    video->currVop->uChan = video->currVop->yChan + size;/* Memory for currVop U */
    video->currVop->vChan = video->currVop->uChan + (size >> 2);/* Memory for currVop V */

    /* shift for the offset */
    if (offset)
    {
        video->currVop->yChan += offset; /* offset to the origin.*/
        video->currVop->uChan += (offset >> 2) + 4;
        video->currVop->vChan += (offset >> 2) + 4;
    }

    video->forwardRefVop = video->currVop;      /*  Initialize forwardRefVop */
    video->backwardRefVop = video->currVop;     /*  Initialize backwardRefVop */

    video->prevBaseVop = (Vop *) M4VENC_MALLOC(sizeof(Vop));         /* Memory for Previous Base Vop */
    if (video->prevBaseVop == NULL) goto CLEAN_UP;
    video->prevBaseVop->yChan = (PIXEL *) M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for prevBaseVop Y */
    if (video->prevBaseVop->yChan == NULL) goto CLEAN_UP;
    video->prevBaseVop->uChan = video->prevBaseVop->yChan + size; /* Memory for prevBaseVop U */
    video->prevBaseVop->vChan = video->prevBaseVop->uChan + (size >> 2); /* Memory for prevBaseVop V */

    if (offset)
    {
        video->prevBaseVop->yChan += offset; /* offset to the origin.*/
        video->prevBaseVop->uChan += (offset >> 2) + 4;
        video->prevBaseVop->vChan += (offset >> 2) + 4;
    }


    if (0) /* If B Frames */
    {
        video->nextBaseVop = (Vop *) M4VENC_MALLOC(sizeof(Vop));         /* Memory for Next Base Vop */
        if (video->nextBaseVop == NULL) goto CLEAN_UP;
        video->nextBaseVop->yChan = (PIXEL *) M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for nextBaseVop Y */
        if (video->nextBaseVop->yChan == NULL) goto CLEAN_UP;
        video->nextBaseVop->uChan = video->nextBaseVop->yChan + size; /* Memory for nextBaseVop U */
        video->nextBaseVop->vChan = video->nextBaseVop->uChan + (size >> 2); /* Memory for nextBaseVop V */

        if (offset)
        {
            video->nextBaseVop->yChan += offset; /* offset to the origin.*/
            video->nextBaseVop->uChan += (offset >> 2) + 4;
            video->nextBaseVop->vChan += (offset >> 2) + 4;
        }
    }

    if (nLayers > 1)   /* If enhancement layers */
    {
        video->prevEnhanceVop = (Vop *) M4VENC_MALLOC(sizeof(Vop));      /* Memory for Previous Enhancement Vop */
        if (video->prevEnhanceVop == NULL) goto CLEAN_UP;
        video->prevEnhanceVop->yChan = (PIXEL *) M4VENC_MALLOC(sizeof(PIXEL) * (size + (size >> 1))); /* Memory for Previous Ehancement Y */
        if (video->prevEnhanceVop->yChan == NULL) goto CLEAN_UP;
        video->prevEnhanceVop->uChan = video->prevEnhanceVop->yChan + size; /* Memory for Previous Enhancement U */
        video->prevEnhanceVop->vChan = video->prevEnhanceVop->uChan + (size >> 2); /* Memory for Previous Enhancement V */

        if (offset)
        {
            video->prevEnhanceVop->yChan += offset; /* offset to the origin.*/
            video->prevEnhanceVop->uChan += (offset >> 2) + 4;
            video->prevEnhanceVop->vChan += (offset >> 2) + 4;
        }
    }

    video->numberOfLayers = nLayers; /* Number of Layers */
    video->sumMAD = 0;


    /* 04/09/01, for Vops in the use multipass processing */
    for (idx = 0; idx < nLayers; idx++)
    {
        video->pMP[idx] = (MultiPass *)M4VENC_MALLOC(sizeof(MultiPass));
        if (video->pMP[idx] == NULL)    goto CLEAN_UP;
        M4VENC_MEMSET(video->pMP[idx], 0, sizeof(MultiPass));

        video->pMP[idx]->encoded_frames = -1; /* forget about the very first I frame */


        /* RDInfo **pRDSamples */
        video->pMP[idx]->pRDSamples = (RDInfo **)M4VENC_MALLOC(30 * sizeof(RDInfo *));
        if (video->pMP[idx]->pRDSamples == NULL)    goto CLEAN_UP;
        for (i = 0; i < 30; i++)
        {
            video->pMP[idx]->pRDSamples[i] = (RDInfo *)M4VENC_MALLOC(32 * sizeof(RDInfo));
            if (video->pMP[idx]->pRDSamples[i] == NULL) goto CLEAN_UP;
            for (j = 0; j < 32; j++)    M4VENC_MEMSET(&(video->pMP[idx]->pRDSamples[i][j]), 0, sizeof(RDInfo));
        }
        video->pMP[idx]->frameRange = (Int)(video->encParams->LayerFrameRate[idx] * 1.0); /* 1.0s time frame*/
        video->pMP[idx]->frameRange = PV_MAX(video->pMP[idx]->frameRange, 5);
        video->pMP[idx]->frameRange = PV_MIN(video->pMP[idx]->frameRange, 30);

        video->pMP[idx]->framePos = -1;

    }
    /* /// End /////////////////////////////////////// */


    video->vol = (Vol **)M4VENC_MALLOC(nLayers * sizeof(Vol *)); /* Memory for VOL pointers */

    /* Memory allocation and Initialization of Vols and writing of headers */
    if (video->vol == NULL) goto CLEAN_UP;

    for (idx = 0; idx < nLayers; idx++)
    {
        video->volInitialize[idx] = 1;
        video->refTick[idx] = 0;
        video->relLayerCodeTime[idx] = 1000;
        video->vol[idx] = (Vol *)M4VENC_MALLOC(sizeof(Vol));
        if (video->vol[idx] == NULL)  goto CLEAN_UP;

        pVol = video->vol[idx];
        pEncParams = video->encParams;

        M4VENC_MEMSET(video->vol[idx], 0, sizeof(Vol));
        /* Initialize some VOL parameters */
        pVol->volID = idx;  /* Set VOL ID */
        pVol->shortVideoHeader = pEncParams->H263_Enabled; /*Short Header */
        pVol->GOVStart = pEncParams->GOV_Enabled; /* GOV Header */
        pVol->timeIncrementResolution = video->encParams->TimeIncrementRes;
        pVol->nbitsTimeIncRes = 1;
        while (pVol->timeIncrementResolution > (1 << pVol->nbitsTimeIncRes))
        {
            pVol->nbitsTimeIncRes++;
        }

        /* timing stuff */
        pVol->timeIncrement = 0;
        pVol->moduloTimeBase = 0;
        pVol->fixedVopRate = 0; /* No fixed VOP rate */
        pVol->stream = (BitstreamEncVideo *)M4VENC_MALLOC(sizeof(BitstreamEncVideo)); /* allocate BitstreamEncVideo Instance */
        if (pVol->stream == NULL)  goto CLEAN_UP;

        pVol->width = pEncParams->LayerWidth[idx];      /* Layer Width */
        pVol->height = pEncParams->LayerHeight[idx];    /* Layer Height */
        //  pVol->intra_acdcPredDisable = pEncParams->ACDCPrediction; /* ACDC Prediction */
        pVol->ResyncMarkerDisable = pEncParams->ResyncMarkerDisable; /* Resync Marker Mode */
        pVol->dataPartitioning = pEncParams->DataPartitioning; /* Data Partitioning */
        pVol->useReverseVLC = pEncParams->ReversibleVLC; /* RVLC */
        if (idx > 0) /* Scalability layers */
        {
            pVol->ResyncMarkerDisable = 1;
            pVol->dataPartitioning = 0;
            pVol->useReverseVLC = 0; /*  No RVLC */
        }
        pVol->quantType = pEncParams->QuantType[idx];           /* Quantizer Type */

        /* no need to init Quant Matrices */

        pVol->scalability = 0;  /* Vol Scalability */
        if (idx > 0)
            pVol->scalability = 1; /* Multiple layers => Scalability */

        /* Initialize Vol to Temporal scalability.  It can change during encoding */
        pVol->scalType = 1;
        /* Initialize reference Vol ID to the base layer = 0 */
        pVol->refVolID = 0;
        /* Initialize layer resolution to same as the reference */
        pVol->refSampDir = 0;
        pVol->horSamp_m = 1;
        pVol->horSamp_n = 1;
        pVol->verSamp_m = 1;
        pVol->verSamp_n = 1;
        pVol->enhancementType = 0; /* We always enhance the entire region */

        pVol->nMBPerRow = (pVol->width + 15) / 16;
        pVol->nMBPerCol = (pVol->height + 15) / 16;
        pVol->nTotalMB = pVol->nMBPerRow * pVol->nMBPerCol;

        if (pVol->nTotalMB >= 1)
            pVol->nBitsForMBID = 1;
        if (pVol->nTotalMB >= 3)
            pVol->nBitsForMBID = 2;
        if (pVol->nTotalMB >= 5)
            pVol->nBitsForMBID = 3;
        if (pVol->nTotalMB >= 9)
            pVol->nBitsForMBID = 4;
        if (pVol->nTotalMB >= 17)
            pVol->nBitsForMBID = 5;
        if (pVol->nTotalMB >= 33)
            pVol->nBitsForMBID = 6;
        if (pVol->nTotalMB >= 65)
            pVol->nBitsForMBID = 7;
        if (pVol->nTotalMB >= 129)
            pVol->nBitsForMBID = 8;
        if (pVol->nTotalMB >= 257)
            pVol->nBitsForMBID = 9;
        if (pVol->nTotalMB >= 513)
            pVol->nBitsForMBID = 10;
        if (pVol->nTotalMB >= 1025)
            pVol->nBitsForMBID = 11;
        if (pVol->nTotalMB >= 2049)
            pVol->nBitsForMBID = 12;
        if (pVol->nTotalMB >= 4097)
            pVol->nBitsForMBID = 13;
        if (pVol->nTotalMB >= 8193)
            pVol->nBitsForMBID = 14;
        if (pVol->nTotalMB >= 16385)
            pVol->nBitsForMBID = 15;
        if (pVol->nTotalMB >= 32769)
            pVol->nBitsForMBID = 16;
        if (pVol->nTotalMB >= 65537)
            pVol->nBitsForMBID = 17;
        if (pVol->nTotalMB >= 131073)
            pVol->nBitsForMBID = 18;

        if (pVol->shortVideoHeader)
        {
            switch (pVol->width)
            {
                case 128:
                    if (pVol->height == 96)  /* source_format = 1 */
                    {
                        pVol->nGOBinVop = 6;
                        pVol->nMBinGOB = 8;
                    }
                    else
                        status = PV_FALSE;
                    break;

                case 176:
                    if (pVol->height == 144)  /* source_format = 2 */
                    {
                        pVol->nGOBinVop = 9;
                        pVol->nMBinGOB = 11;
                    }
                    else
                        status = PV_FALSE;
                    break;
                case 352:
                    if (pVol->height == 288)  /* source_format = 2 */
                    {
                        pVol->nGOBinVop = 18;
                        pVol->nMBinGOB = 22;
                    }
                    else
                        status = PV_FALSE;
                    break;

                case 704:
                    if (pVol->height == 576)  /* source_format = 2 */
                    {
                        pVol->nGOBinVop = 18;
                        pVol->nMBinGOB = 88;
                    }
                    else
                        status = PV_FALSE;
                    break;
                case 1408:
                    if (pVol->height == 1152)  /* source_format = 2 */
                    {
                        pVol->nGOBinVop = 18;
                        pVol->nMBinGOB = 352;
                    }
                    else
                        status = PV_FALSE;
                    break;

                default:
                    status = PV_FALSE;
                    break;
            }
        }
    }

    /***************************************************/
    /* allocate and initialize rate control parameters */
    /***************************************************/

    /* BEGIN INITIALIZATION OF ANNEX L RATE CONTROL */
    if (video->encParams->RC_Type != CONSTANT_Q)
    {
        for (idx = 0; idx < nLayers; idx++) /* 12/25/00 */
        {
            video->rc[idx] =
                (rateControl *)M4VENC_MALLOC(sizeof(rateControl));

            if (video->rc[idx] == NULL) goto CLEAN_UP;

            M4VENC_MEMSET(video->rc[idx], 0, sizeof(rateControl));
        }
        if (PV_SUCCESS != RC_Initialize(video))
        {
            goto CLEAN_UP;
        }
        /* initialization for 2-pass rate control */
    }
    /* END INITIALIZATION OF ANNEX L RATE CONTROL */

    /********** assign platform dependent functions ***********************/
    /* 1/23/01 */
    /* This must be done at run-time not a compile time */
    video->functionPointer = (FuncPtr*) M4VENC_MALLOC(sizeof(FuncPtr));
    if (video->functionPointer == NULL) goto CLEAN_UP;

    video->functionPointer->ComputeMBSum = &ComputeMBSum_C;
    video->functionPointer->SAD_MB_HalfPel[0] = NULL;
    video->functionPointer->SAD_MB_HalfPel[1] = &SAD_MB_HalfPel_Cxh;
    video->functionPointer->SAD_MB_HalfPel[2] = &SAD_MB_HalfPel_Cyh;
    video->functionPointer->SAD_MB_HalfPel[3] = &SAD_MB_HalfPel_Cxhyh;

#ifndef NO_INTER4V
    video->functionPointer->SAD_Blk_HalfPel = &SAD_Blk_HalfPel_C;
    video->functionPointer->SAD_Block = &SAD_Block_C;
#endif
    video->functionPointer->SAD_Macroblock = &SAD_Macroblock_C;
    video->functionPointer->ChooseMode = &ChooseMode_C;
    video->functionPointer->GetHalfPelMBRegion = &GetHalfPelMBRegion_C;
//  video->functionPointer->SAD_MB_PADDING = &SAD_MB_PADDING; /* 4/21/01 */


    encoderControl->videoEncoderInit = 1;  /* init done! */

    return PV_TRUE;

CLEAN_UP:
    PVCleanUpVideoEncoder(encoderControl);

    return PV_FALSE;
}


/* ======================================================================== */
/*  Function : PVCleanUpVideoEncoder()                                      */
/*  Date     : 08/22/2000                                                   */
/*  Purpose  : Deallocates allocated memory from InitVideoEncoder()         */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified : 5/21/01, free only yChan in Vop                          */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool    PVCleanUpVideoEncoder(VideoEncControls *encoderControl)
{
    Int idx, i;
    VideoEncData *video = (VideoEncData *)encoderControl->videoEncoderData;
    int nTotalMB;
    int max_width, offset;

#ifdef PRINT_RC_INFO
    if (facct != NULL)
    {
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "TOTAL NUM BITS GENERATED %d\n", tiTotalNumBitsGenerated);
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "TOTAL NUMBER OF FRAMES CODED %d\n",
                video->encParams->rc[0]->totalFrameNumber);
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "Average BitRate %d\n",
                (tiTotalNumBitsGenerated / (90 / 30)));
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "TOTAL NUMBER OF STUFF BITS %d\n", (iStuffBits + 10740));
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "TOTAL NUMBER OF BITS TO NETWORK %d\n", (35800*90 / 30));;
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "SUM OF STUFF BITS AND GENERATED BITS %d\n",
                (tiTotalNumBitsGenerated + iStuffBits + 10740));
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fprintf(facct, "UNACCOUNTED DIFFERENCE %d\n",
                ((35800*90 / 30) - (tiTotalNumBitsGenerated + iStuffBits + 10740)));
        fprintf(facct, "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
        fclose(facct);
    }
#endif

#ifdef PRINT_EC
    fclose(fec);
#endif

    if (video != NULL)
    {

        if (video->QPMB) M4VENC_FREE(video->QPMB);
        if (video->headerInfo.Mode)M4VENC_FREE(video->headerInfo.Mode);
        if (video->headerInfo.CBP)M4VENC_FREE(video->headerInfo.CBP);


        if (video->mot)
        {
            nTotalMB = video->vol[0]->nTotalMB;
            for (idx = 1; idx < video->currLayer; idx++)
                if (video->vol[idx]->nTotalMB > nTotalMB)
                    nTotalMB = video->vol[idx]->nTotalMB;
            for (idx = 0; idx < nTotalMB; idx++)
            {
                if (video->mot[idx])
                    M4VENC_FREE(video->mot[idx]);
            }
            M4VENC_FREE(video->mot);
        }

        if (video->intraArray) M4VENC_FREE(video->intraArray);

        if (video->sliceNo)M4VENC_FREE(video->sliceNo);
        if (video->acPredFlag)M4VENC_FREE(video->acPredFlag);
//      if(video->predDCAC)M4VENC_FREE(video->predDCAC);
        if (video->predDC) M4VENC_FREE(video->predDC);
        video->predDCAC_row = NULL;
        if (video->predDCAC_col) M4VENC_FREE(video->predDCAC_col);
        if (video->outputMB)M4VENC_FREE(video->outputMB);

        if (video->bitstream1)BitstreamCloseEnc(video->bitstream1);
        if (video->bitstream2)BitstreamCloseEnc(video->bitstream2);
        if (video->bitstream3)BitstreamCloseEnc(video->bitstream3);

        if (video->overrunBuffer) M4VENC_FREE(video->overrunBuffer);

        max_width = video->encParams->LayerWidth[0];
        max_width = (((max_width + 15) >> 4) << 4); /* 09/19/05 */
        if (video->encParams->H263_Enabled)
        {
            offset = 0;
        }
        else
        {
            offset = ((max_width + 32) << 4) + 16;
        }

        if (video->currVop)
        {
            if (video->currVop->yChan)
            {
                video->currVop->yChan -= offset;
                M4VENC_FREE(video->currVop->yChan);
            }
            M4VENC_FREE(video->currVop);
        }

        if (video->nextBaseVop)
        {
            if (video->nextBaseVop->yChan)
            {
                video->nextBaseVop->yChan -= offset;
                M4VENC_FREE(video->nextBaseVop->yChan);
            }
            M4VENC_FREE(video->nextBaseVop);
        }

        if (video->prevBaseVop)
        {
            if (video->prevBaseVop->yChan)
            {
                video->prevBaseVop->yChan -= offset;
                M4VENC_FREE(video->prevBaseVop->yChan);
            }
            M4VENC_FREE(video->prevBaseVop);
        }
        if (video->prevEnhanceVop)
        {
            if (video->prevEnhanceVop->yChan)
            {
                video->prevEnhanceVop->yChan -= offset;
                M4VENC_FREE(video->prevEnhanceVop->yChan);
            }
            M4VENC_FREE(video->prevEnhanceVop);
        }

        /* 04/09/01, for Vops in the use multipass processing */
        for (idx = 0; idx < video->encParams->nLayers; idx++)
        {
            if (video->pMP[idx])
            {
                if (video->pMP[idx]->pRDSamples)
                {
                    for (i = 0; i < 30; i++)
                    {
                        if (video->pMP[idx]->pRDSamples[i])
                            M4VENC_FREE(video->pMP[idx]->pRDSamples[i]);
                    }
                    M4VENC_FREE(video->pMP[idx]->pRDSamples);
                }

                M4VENC_MEMSET(video->pMP[idx], 0, sizeof(MultiPass));
                M4VENC_FREE(video->pMP[idx]);
            }
        }
        /* //  End /////////////////////////////////////// */

        if (video->vol)
        {
            for (idx = 0; idx < video->encParams->nLayers; idx++)
            {
                if (video->vol[idx])
                {
                    if (video->vol[idx]->stream)
                        M4VENC_FREE(video->vol[idx]->stream);
                    M4VENC_FREE(video->vol[idx]);
                }
            }
            M4VENC_FREE(video->vol);
        }

        /***************************************************/
        /* stop rate control parameters */
        /***************************************************/

        /* ANNEX L RATE CONTROL */
        if (video->encParams->RC_Type != CONSTANT_Q)
        {
            RC_Cleanup(video->rc, video->encParams->nLayers);

            for (idx = 0; idx < video->encParams->nLayers; idx++)
            {
                if (video->rc[idx])
                    M4VENC_FREE(video->rc[idx]);
            }
        }

        if (video->functionPointer) M4VENC_FREE(video->functionPointer);

        /* If application has called PVCleanUpVideoEncoder then we deallocate */
        /* If PVInitVideoEncoder class it, then we DO NOT deallocate */
        if (video->encParams)
        {
            M4VENC_FREE(video->encParams);
        }

        M4VENC_FREE(video);
        encoderControl->videoEncoderData = NULL; /* video */
    }

    encoderControl->videoEncoderInit = 0;

    return PV_TRUE;
}

/* ======================================================================== */
/*  Function : PVGetVolHeader()                                             */
/*  Date     : 7/17/2001,                                                   */
/*  Purpose  :                                                              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVGetVolHeader(VideoEncControls *encCtrl, UChar *volHeader, Int *size, Int layer)
{
    VideoEncData    *encData;
    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
    encData = (VideoEncData *)encCtrl->videoEncoderData;


    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;


    encData->currLayer = layer; /* Set Layer */
    /*pv_status = */
    EncodeVOS_Start(encCtrl); /* Encode VOL Header */

    encData->encParams->GetVolHeader[layer] = 1; /* Set usage flag: Needed to support old method*/

    /* Copy bitstream to buffer and set the size */

    if (*size > encData->bitstream1->byteCount)
    {
        *size = encData->bitstream1->byteCount;
        M4VENC_MEMCPY(volHeader, encData->bitstream1->bitstreamBuffer, *size);
    }
    else
        return PV_FALSE;

    /* Reset bitstream1 buffer parameters */
    BitstreamEncReset(encData->bitstream1);

    return PV_TRUE;
}

/* ======================================================================== */
/*  Function : PVGetOverrunBuffer()                                         */
/*  Purpose  : Get the overrun buffer `                                     */
/*  In/out   :                                                              */
/*  Return   : Pointer to overrun buffer.                                   */
/*  Modified :                                                              */
/* ======================================================================== */

OSCL_EXPORT_REF UChar* PVGetOverrunBuffer(VideoEncControls *encCtrl)
{
    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
    Int currLayer = video->currLayer;
    Vol *currVol = video->vol[currLayer];

    if (currVol->stream->bitstreamBuffer != video->overrunBuffer) // not used
    {
        return NULL;
    }

    return video->overrunBuffer;
}




/* ======================================================================== */
/*  Function : EncodeVideoFrame()                                           */
/*  Date     : 08/22/2000                                                   */
/*  Purpose  : Encode video frame and return bitstream                      */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*  02.14.2001                                      */
/*              Finishing new timestamp 32-bit input                        */
/*              Applications need to take care of wrap-around               */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVEncodeVideoFrame(VideoEncControls *encCtrl, VideoEncFrameIO *vid_in, VideoEncFrameIO *vid_out,
                                        ULong *nextModTime, UChar *bstream, Int *size, Int *nLayer)
{
    Bool status = PV_TRUE;
    PV_STATUS pv_status;
    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
    VideoEncParams *encParams = video->encParams;
    Vol *currVol;
    Vop *tempForwRefVop = NULL;
    Int tempRefSelCode = 0;
    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
    Int width_16, height_16;
    Int width, height;
    Vop *temp;
    Int encodeVop = 0;
    void  PaddingEdge(Vop *padVop);
    Int currLayer = -1;
    //Int nLayers = encParams->nLayers;

    ULong modTime = vid_in->timestamp;

#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
    Int random_val[30] = {0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0};
    static Int rand_idx = 0;
#endif

    /*******************************************************/
    /* Determine Next Vop to encode, if any, and nLayer    */
    /*******************************************************/
    //i = nLayers-1;

    if (video->volInitialize[0]) /* first vol to code */
    {
        video->nextModTime = video->modTimeRef = ((modTime) - ((modTime) % 1000));
    }

    encodeVop = DetermineCodingLayer(video, nLayer, modTime);
    currLayer = *nLayer;
    if ((currLayer < 0) || (currLayer > encParams->nLayers - 1))
        return PV_FALSE;

    /******************************************/
    /* If post-skipping still effective --- return */
    /******************************************/

    if (!encodeVop) /* skip enh layer, no base layer coded --- return */
    {
#ifdef _PRINT_STAT
        printf("No frame coded. Continue to next frame.");
#endif
        /* expected next code time, convert back to millisec */
        *nextModTime = video->nextModTime;

#ifdef ALLOW_VOP_NOT_CODED
        if (video->vol[0]->shortVideoHeader) /* Short Video Header = 1 */
        {
            *size = 0;
            *nLayer = -1;
        }
        else
        {
            *nLayer = 0;
            EncodeVopNotCoded(video, bstream, size, modTime);
            *size = video->vol[0]->stream->byteCount;
        }
#else
        *size = 0;
        *nLayer = -1;
#endif
        return status;
    }


//ENCODE_VOP_AGAIN:  /* 12/30/00 */

    /**************************************************************/
    /* Initialize Vol stream structure with application bitstream */
    /**************************************************************/

    currVol = video->vol[currLayer];
    currVol->stream->bitstreamBuffer = bstream;
    currVol->stream->bufferSize = *size;
    BitstreamEncReset(currVol->stream);
    BitstreamSetOverrunBuffer(currVol->stream, video->overrunBuffer, video->oBSize, video);

    /***********************************************************/
    /* Encode VOS and VOL Headers on first call for each layer */
    /***********************************************************/

    if (video->volInitialize[currLayer])
    {
        video->currVop->timeInc = 0;
        video->prevBaseVop->timeInc = 0;
        if (!video->encParams->GetVolHeader[currLayer])
            pv_status = EncodeVOS_Start(encCtrl);
    }

    /***************************************************/
    /* Copy Input Video Frame to Internal Video Buffer */
    /***************************************************/
    /* Determine Width and Height of Vop Layer */

    width = encParams->LayerWidth[currLayer];   /* Get input width */
    height = encParams->LayerHeight[currLayer]; /* Get input height */
    /* Round Up to nearest multiple of 16 : MPEG-4 Standard */

    width_16 = ((width + 15) / 16) * 16;            /* Round up to nearest multiple of 16 */
    height_16 = ((height + 15) / 16) * 16;          /* Round up to nearest multiple of 16 */

    video->input = vid_in;  /* point to the frame input */

    /*//  End ////////////////////////////// */


    /**************************************/
    /* Determine VOP Type                 */
    /* 6/2/2001, separate function      */
    /**************************************/
    DetermineVopType(video, currLayer);

    /****************************/
    /*    Initialize VOP        */
    /****************************/
    video->currVop->volID = currVol->volID;
    video->currVop->width = width_16;
    video->currVop->height = height_16;
    if (video->encParams->H263_Enabled) /*  11/28/05 */
    {
        video->currVop->pitch = width_16;
    }
    else
    {
        video->currVop->pitch = width_16 + 32;
    }
    video->currVop->timeInc = currVol->timeIncrement;
    video->currVop->vopCoded = 1;
    video->currVop->roundingType = 0;
    video->currVop->intraDCVlcThr = encParams->IntraDCVlcThr;

    if (currLayer == 0
#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
            || random_val[rand_idx] || video->volInitialize[currLayer]
#endif
       )
    {
        tempForwRefVop = video->forwardRefVop; /* keep initial state */
        if (tempForwRefVop != NULL) tempRefSelCode = tempForwRefVop->refSelectCode;

        video->forwardRefVop = video->prevBaseVop;
        video->forwardRefVop->refSelectCode = 1;
    }
#ifdef RANDOM_REFSELCODE
    else
    {
        tempForwRefVop = video->forwardRefVop; /* keep initial state */
        if (tempForwRefVop != NULL) tempRefSelCode = tempForwRefVop->refSelectCode;

        video->forwardRefVop = video->prevEnhanceVop;
        video->forwardRefVop->refSelectCode = 0;
    }
    rand_idx++;
    rand_idx %= 30;
#endif

    video->currVop->refSelectCode = video->forwardRefVop->refSelectCode;
    video->currVop->gobNumber = 0;
    video->currVop->gobFrameID = video->currVop->predictionType;
    video->currVop->temporalRef = (modTime * 30 / 1001) % 256;

    video->currVop->temporalInterval = 0;

    if (video->currVop->predictionType == I_VOP)
        video->currVop->quantizer = encParams->InitQuantIvop[currLayer];
    else
        video->currVop->quantizer = encParams->InitQuantPvop[currLayer];


    /****************/
    /* Encode Vop */
    /****************/
    video->slice_coding = 0;

    pv_status = EncodeVop(video);
#ifdef _PRINT_STAT
    if (video->currVop->predictionType == I_VOP)
        printf(" I-VOP ");
    else
        printf(" P-VOP (ref.%d)", video->forwardRefVop->refSelectCode);
#endif

    /************************************/
    /* Update Skip Next Frame           */
    /************************************/
    *nLayer = UpdateSkipNextFrame(video, nextModTime, size, pv_status);
    if (*nLayer == -1) /* skip current frame */
    {
        /* make sure that pointers are restored to the previous state */
        if (currLayer == 0)
        {
            video->forwardRefVop = tempForwRefVop; /* For P-Vop base only */
            video->forwardRefVop->refSelectCode = tempRefSelCode;
        }

        return status;
    }

    /* If I-VOP was encoded, reset IntraPeriod */
    if ((currLayer == 0) && (encParams->IntraPeriod > 0) && (video->currVop->predictionType == I_VOP))
        video->nextEncIVop = encParams->IntraPeriod;

    /* Set HintTrack Information */
    if (currLayer != -1)
    {
        if (currVol->prevModuloTimeBase)
            video->hintTrackInfo.MTB = 1;
        else
            video->hintTrackInfo.MTB = 0;
        video->hintTrackInfo.LayerID = (UChar)currVol->volID;
        video->hintTrackInfo.CodeType = (UChar)video->currVop->predictionType;
        video->hintTrackInfo.RefSelCode = (UChar)video->currVop->refSelectCode;
    }

    /************************************************/
    /* Determine nLayer and timeInc for next encode */
    /* 12/27/00 always go by the highest layer*/
    /************************************************/

    /**********************************************************/
    /* Copy Reconstructed Buffer to Output Video Frame Buffer */
    /**********************************************************/
    vid_out->yChan = video->currVop->yChan;
    vid_out->uChan = video->currVop->uChan;
    vid_out->vChan = video->currVop->vChan;
    if (video->encParams->H263_Enabled)
    {
        vid_out->height = video->currVop->height; /* padded height */
        vid_out->pitch = video->currVop->width; /* padded width */
    }
    else
    {
        vid_out->height = video->currVop->height + 32; /* padded height */
        vid_out->pitch = video->currVop->width + 32; /* padded width */
    }
    //video_out->timestamp = video->modTime;
    vid_out->timestamp = (ULong)(((video->prevFrameNum[currLayer] * 1000) / encParams->LayerFrameRate[currLayer]) + video->modTimeRef + 0.5);

    /*// End /////////////////////// */

    /***********************************/
    /* Update Ouput bstream byte count */
    /***********************************/

    *size = currVol->stream->byteCount;

    /****************************************/
    /* Swap Vop Pointers for Base Layer     */
    /****************************************/
    if (currLayer == 0)
    {
        temp = video->prevBaseVop;
        video->prevBaseVop = video->currVop;
        video->prevBaseVop->padded = 0; /* not padded */
        video->currVop  = temp;
        video->forwardRefVop = video->prevBaseVop; /* For P-Vop base only */
        video->forwardRefVop->refSelectCode = 1;
    }
    else
    {
        temp = video->prevEnhanceVop;
        video->prevEnhanceVop = video->currVop;
        video->prevEnhanceVop->padded = 0; /* not padded */
        video->currVop = temp;
        video->forwardRefVop = video->prevEnhanceVop;
        video->forwardRefVop->refSelectCode = 0;
    }

    /****************************************/
    /* Modify the intialize flag at the end.*/
    /****************************************/
    if (video->volInitialize[currLayer])
        video->volInitialize[currLayer] = 0;

    return status;
}

#ifndef NO_SLICE_ENCODE
/* ======================================================================== */
/*  Function : PVEncodeFrameSet()                                           */
/*  Date     : 04/18/2000                                                   */
/*  Purpose  : Enter a video frame and perform front-end time check plus ME */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVEncodeFrameSet(VideoEncControls *encCtrl, VideoEncFrameIO *vid_in, ULong *nextModTime, Int *nLayer)
{
    Bool status = PV_TRUE;
    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
    VideoEncParams *encParams = video->encParams;
    Vol *currVol;
    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
    Int width_16, height_16;
    Int width, height;
    Int encodeVop = 0;
    void  PaddingEdge(Vop *padVop);
    Int currLayer = -1;
    //Int nLayers = encParams->nLayers;

    ULong   modTime = vid_in->timestamp;

#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
    Int random_val[30] = {0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0};
    static Int rand_idx = 0;
#endif
    /*******************************************************/
    /* Determine Next Vop to encode, if any, and nLayer    */
    /*******************************************************/

    video->modTime = modTime;

    //i = nLayers-1;

    if (video->volInitialize[0]) /* first vol to code */
    {
        video->nextModTime = video->modTimeRef = ((modTime) - ((modTime) % 1000));
    }


    encodeVop = DetermineCodingLayer(video, nLayer, modTime);

    currLayer = *nLayer;

    /******************************************/
    /* If post-skipping still effective --- return */
    /******************************************/

    if (!encodeVop) /* skip enh layer, no base layer coded --- return */
    {
#ifdef _PRINT_STAT
        printf("No frame coded. Continue to next frame.");
#endif
        *nLayer = -1;

        /* expected next code time, convert back to millisec */
        *nextModTime = video->nextModTime;;
        return status;
    }

    /**************************************************************/
    /* Initialize Vol stream structure with application bitstream */
    /**************************************************************/

    currVol = video->vol[currLayer];
    currVol->stream->bufferSize = 0;
    BitstreamEncReset(currVol->stream);

    /***********************************************************/
    /* Encode VOS and VOL Headers on first call for each layer */
    /***********************************************************/

    if (video->volInitialize[currLayer])
    {
        video->currVop->timeInc = 0;
        video->prevBaseVop->timeInc = 0;
    }

    /***************************************************/
    /* Copy Input Video Frame to Internal Video Buffer */
    /***************************************************/
    /* Determine Width and Height of Vop Layer */

    width = encParams->LayerWidth[currLayer];   /* Get input width */
    height = encParams->LayerHeight[currLayer]; /* Get input height */
    /* Round Up to nearest multiple of 16 : MPEG-4 Standard */

    width_16 = ((width + 15) / 16) * 16;            /* Round up to nearest multiple of 16 */
    height_16 = ((height + 15) / 16) * 16;          /* Round up to nearest multiple of 16 */

    video->input = vid_in;  /* point to the frame input */

    /*//  End ////////////////////////////// */


    /**************************************/
    /* Determine VOP Type                 */
    /* 6/2/2001, separate function      */
    /**************************************/
    DetermineVopType(video, currLayer);

    /****************************/
    /*    Initialize VOP        */
    /****************************/
    video->currVop->volID = currVol->volID;
    video->currVop->width = width_16;
    video->currVop->height = height_16;
    if (video->encParams->H263_Enabled) /*  11/28/05 */
    {
        video->currVop->pitch = width_16;
    }
    else
    {
        video->currVop->pitch = width_16 + 32;
    }
    video->currVop->timeInc = currVol->timeIncrement;
    video->currVop->vopCoded = 1;
    video->currVop->roundingType = 0;
    video->currVop->intraDCVlcThr = encParams->IntraDCVlcThr;

    if (currLayer == 0
#ifdef RANDOM_REFSELCODE   /* add random selection of reference Vop */
            || random_val[rand_idx] || video->volInitialize[currLayer]
#endif
       )
    {
        video->tempForwRefVop = video->forwardRefVop; /* keep initial state */
        if (video->tempForwRefVop != NULL) video->tempRefSelCode = video->tempForwRefVop->refSelectCode;

        video->forwardRefVop = video->prevBaseVop;
        video->forwardRefVop->refSelectCode = 1;
    }
#ifdef RANDOM_REFSELCODE
    else
    {
        video->tempForwRefVop = video->forwardRefVop; /* keep initial state */
        if (video->tempForwRefVop != NULL) video->tempRefSelCode = video->tempForwRefVop->refSelectCode;

        video->forwardRefVop = video->prevEnhanceVop;
        video->forwardRefVop->refSelectCode = 0;
    }
    rand_idx++;
    rand_idx %= 30;
#endif

    video->currVop->refSelectCode = video->forwardRefVop->refSelectCode;
    video->currVop->gobNumber = 0;
    video->currVop->gobFrameID = video->currVop->predictionType;
    video->currVop->temporalRef = ((modTime) * 30 / 1001) % 256;

    video->currVop->temporalInterval = 0;

    if (video->currVop->predictionType == I_VOP)
        video->currVop->quantizer = encParams->InitQuantIvop[currLayer];
    else
        video->currVop->quantizer = encParams->InitQuantPvop[currLayer];

    /****************/
    /* Encode Vop   */
    /****************/
    video->slice_coding = 1;

    /*pv_status =*/
    EncodeVop(video);

#ifdef _PRINT_STAT
    if (video->currVop->predictionType == I_VOP)
        printf(" I-VOP ");
    else
        printf(" P-VOP (ref.%d)", video->forwardRefVop->refSelectCode);
#endif

    /* Set HintTrack Information */
    if (currVol->prevModuloTimeBase)
        video->hintTrackInfo.MTB = 1;
    else
        video->hintTrackInfo.MTB = 0;

    video->hintTrackInfo.LayerID = (UChar)currVol->volID;
    video->hintTrackInfo.CodeType = (UChar)video->currVop->predictionType;
    video->hintTrackInfo.RefSelCode = (UChar)video->currVop->refSelectCode;

    return status;
}
#endif /* NO_SLICE_ENCODE */

#ifndef NO_SLICE_ENCODE
/* ======================================================================== */
/*  Function : PVEncodePacket()                                             */
/*  Date     : 04/18/2002                                                   */
/*  Purpose  : Encode one packet and return bitstream                       */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVEncodeSlice(VideoEncControls *encCtrl, UChar *bstream, Int *size,
                                   Int *endofFrame, VideoEncFrameIO *vid_out, ULong *nextModTime)
{
    PV_STATUS pv_status;
    VideoEncData *video = (VideoEncData *)encCtrl->videoEncoderData;
    VideoEncParams *encParams = video->encParams;
    Vol *currVol;
    PV_STATUS   EncodeVOS_Start(VideoEncControls *encCtrl);
    Vop *temp;
    void  PaddingEdge(Vop *padVop);
    Int currLayer = video->currLayer;
    Int pre_skip;
    Int pre_size;
    /**************************************************************/
    /* Initialize Vol stream structure with application bitstream */
    /**************************************************************/

    currVol = video->vol[currLayer];
    currVol->stream->bitstreamBuffer = bstream;
    pre_size = currVol->stream->byteCount;
    currVol->stream->bufferSize = pre_size + (*size);

    /***********************************************************/
    /* Encode VOS and VOL Headers on first call for each layer */
    /***********************************************************/

    if (video->volInitialize[currLayer])
    {
        if (!video->encParams->GetVolHeader[currLayer])
            pv_status = EncodeVOS_Start(encCtrl);
    }

    /****************/
    /* Encode Slice */
    /****************/
    pv_status = EncodeSlice(video);

    *endofFrame = 0;

    if (video->mbnum >= currVol->nTotalMB && !video->end_of_buf)
    {
        *endofFrame = 1;

        /************************************/
        /* Update Skip Next Frame           */
        /************************************/
        pre_skip = UpdateSkipNextFrame(video, nextModTime, size, pv_status); /* modified such that no pre-skipped */

        if (pre_skip == -1) /* error */
        {
            *endofFrame = -1;
            /* make sure that pointers are restored to the previous state */
            if (currLayer == 0)
            {
                video->forwardRefVop = video->tempForwRefVop; /* For P-Vop base only */
                video->forwardRefVop->refSelectCode = video->tempRefSelCode;
            }

            return pv_status;
        }

        /* If I-VOP was encoded, reset IntraPeriod */
        if ((currLayer == 0) && (encParams->IntraPeriod > 0) && (video->currVop->predictionType == I_VOP))
            video->nextEncIVop = encParams->IntraPeriod;

        /**********************************************************/
        /* Copy Reconstructed Buffer to Output Video Frame Buffer */
        /**********************************************************/
        vid_out->yChan = video->currVop->yChan;
        vid_out->uChan = video->currVop->uChan;
        vid_out->vChan = video->currVop->vChan;
        if (video->encParams->H263_Enabled)
        {
            vid_out->height = video->currVop->height; /* padded height */
            vid_out->pitch = video->currVop->width; /* padded width */
        }
        else
        {
            vid_out->height = video->currVop->height + 32; /* padded height */
            vid_out->pitch = video->currVop->width + 32; /* padded width */
        }
        //vid_out->timestamp = video->modTime;
        vid_out->timestamp = (ULong)(((video->prevFrameNum[currLayer] * 1000) / encParams->LayerFrameRate[currLayer]) + video->modTimeRef + 0.5);

        /*// End /////////////////////// */

        /****************************************/
        /* Swap Vop Pointers for Base Layer     */
        /****************************************/

        if (currLayer == 0)
        {
            temp = video->prevBaseVop;
            video->prevBaseVop = video->currVop;
            video->prevBaseVop->padded = 0; /* not padded */
            video->currVop = temp;
            video->forwardRefVop = video->prevBaseVop; /* For P-Vop base only */
            video->forwardRefVop->refSelectCode = 1;
        }
        else
        {
            temp = video->prevEnhanceVop;
            video->prevEnhanceVop = video->currVop;
            video->prevEnhanceVop->padded = 0; /* not padded */
            video->currVop = temp;
            video->forwardRefVop = video->prevEnhanceVop;
            video->forwardRefVop->refSelectCode = 0;
        }
    }

    /***********************************/
    /* Update Ouput bstream byte count */
    /***********************************/

    *size = currVol->stream->byteCount - pre_size;

    /****************************************/
    /* Modify the intialize flag at the end.*/
    /****************************************/
    if (video->volInitialize[currLayer])
        video->volInitialize[currLayer] = 0;

    return pv_status;
}
#endif /* NO_SLICE_ENCODE */


/* ======================================================================== */
/*  Function : PVGetH263ProfileLevelID()                                    */
/*  Date     : 02/05/2003                                                   */
/*  Purpose  : Get H.263 Profile ID and level ID for profile 0              */
/*  In/out   : Profile ID=0, levelID is what we want                        */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*  Note     : h263Level[8], rBR_bound[8], max_h263_framerate[2]            */
/*             max_h263_width[2], max_h263_height[2] are global             */
/*                                                                          */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVGetH263ProfileLevelID(VideoEncControls *encCtrl, Int *profileID, Int *levelID)
{
    VideoEncData *encData;
    Int width, height;
    float bitrate_r, framerate;


    /* For this version, we only support H.263 profile 0 */
    *profileID = 0;

    *levelID = 0;
    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    if (!encData->encParams->H263_Enabled) return PV_FALSE;


    /* get image width, height, bitrate and framerate */
    width     = encData->encParams->LayerWidth[0];
    height    = encData->encParams->LayerHeight[0];
    bitrate_r = (float)(encData->encParams->LayerBitRate[0]) / (float)64000.0;
    framerate = encData->encParams->LayerFrameRate[0];
    if (!width || !height || !(bitrate_r > 0 && framerate > 0)) return PV_FALSE;

    /* This is the most frequent case : level 10 */
    if (bitrate_r <= rBR_bound[1] && framerate <= max_h263_framerate[0] &&
            (width <= max_h263_width[0] && height <= max_h263_height[0]))
    {
        *levelID = h263Level[1];
        return PV_TRUE;
    }
    else if (bitrate_r > rBR_bound[4] ||
             (width > max_h263_width[1] || height > max_h263_height[1]) ||
             framerate > max_h263_framerate[1])    /* check the highest level 70 */
    {
        *levelID = h263Level[7];
        return PV_TRUE;
    }
    else   /* search level 20, 30, 40 */
    {

        /* pick out level 20 */
        if (bitrate_r <= rBR_bound[2] &&
                ((width <= max_h263_width[0] && height <= max_h263_height[0] && framerate <= max_h263_framerate[1]) ||
                 (width <= max_h263_width[1] && height <= max_h263_height[1] && framerate <= max_h263_framerate[0])))
        {
            *levelID = h263Level[2];
            return PV_TRUE;
        }
        else   /* width, height and framerate are ok, now choose level 30 or 40 */
        {
            *levelID = (bitrate_r <= rBR_bound[3] ? h263Level[3] : h263Level[4]);
            return PV_TRUE;
        }
    }
}

/* ======================================================================== */
/*  Function : PVGetMPEG4ProfileLevelID()                                   */
/*  Date     : 26/06/2008                                                   */
/*  Purpose  : Get MPEG4 Level after initialized                            */
/*  In/out   : profile_level according to interface                         */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */
OSCL_EXPORT_REF Bool PVGetMPEG4ProfileLevelID(VideoEncControls *encCtrl, Int *profile_level, Int nLayer)
{
    VideoEncData* video;
    Int i;

    video = (VideoEncData *)encCtrl->videoEncoderData;

    if (nLayer == 0)
    {
        for (i = 0; i < 8; i++)
        {
            if (video->encParams->ProfileLevel[0] == profile_level_code[i])
            {
                break;
            }
        }
        *profile_level = i;
    }
    else
    {
        for (i = 0; i < 8; i++)
        {
            if (video->encParams->ProfileLevel[0] == scalable_profile_level_code[i])
            {
                break;
            }
        }
        *profile_level = i + SIMPLE_SCALABLE_PROFILE_LEVEL0;
    }

    return true;
}

#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVUpdateEncFrameRate                                         */
/*  Date     : 04/08/2002                                                   */
/*  Purpose  : Update target frame rates of the encoded base and enhance    */
/*             layer(if any) while encoding operation is ongoing            */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVUpdateEncFrameRate(VideoEncControls *encCtrl, float *frameRate)
{
    VideoEncData    *encData;
    Int i;// nTotalMB, mbPerSec;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    /* Update the framerates for all the layers */
    for (i = 0; i < encData->encParams->nLayers; i++)
    {

        /* New check: encoding framerate should be consistent with the given profile and level */
        //nTotalMB = (((encData->encParams->LayerWidth[i]+15)/16)*16)*(((encData->encParams->LayerHeight[i]+15)/16)*16)/(16*16);
        //mbPerSec = (Int)(nTotalMB * frameRate[i]);
        //if(mbPerSec > encData->encParams->LayerMaxMbsPerSec[i]) return PV_FALSE;
        if (frameRate[i] > encData->encParams->LayerMaxFrameRate[i]) return PV_FALSE; /* set by users or profile */

        encData->encParams->LayerFrameRate[i] = frameRate[i];
    }

    return RC_UpdateBXRCParams((void*) encData);

}
#endif
#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVUpdateBitRate                                              */
/*  Date     : 04/08/2002                                                   */
/*  Purpose  : Update target bit rates of the encoded base and enhance      */
/*             layer(if any) while encoding operation is ongoing            */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVUpdateBitRate(VideoEncControls *encCtrl, Int *bitRate)
{
    VideoEncData    *encData;
    Int i;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    /* Update the bitrates for all the layers */
    for (i = 0; i < encData->encParams->nLayers; i++)
    {
        if (bitRate[i] > encData->encParams->LayerMaxBitRate[i]) /* set by users or profile */
        {
            return PV_FALSE;
        }
        encData->encParams->LayerBitRate[i] = bitRate[i];
    }

    return RC_UpdateBXRCParams((void*) encData);

}
#endif
#ifndef LIMITED_API
/* ============================================================================ */
/*  Function : PVUpdateVBVDelay()                                                   */
/*  Date     : 4/23/2004                                                        */
/*  Purpose  : Update VBV buffer size(in delay)                                 */
/*  In/out   :                                                                  */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                        */
/*  Modified :                                                                  */
/*                                                                              */
/* ============================================================================ */

Bool PVUpdateVBVDelay(VideoEncControls *encCtrl, float delay)
{

    VideoEncData    *encData;
    Int total_bitrate, max_buffer_size;
    int index;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    /* Check whether the input delay is valid based on the given profile */
    total_bitrate   = (encData->encParams->nLayers == 1 ? encData->encParams->LayerBitRate[0] :
                       encData->encParams->LayerBitRate[1]);
    index = encData->encParams->profile_table_index;
    max_buffer_size = (encData->encParams->nLayers == 1 ? profile_level_max_VBV_size[index] :
                       scalable_profile_level_max_VBV_size[index]);

    if (total_bitrate*delay > (float)max_buffer_size)
        return PV_FALSE;

    encData->encParams->VBV_delay = delay;
    return PV_TRUE;

}
#endif
#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVUpdateIFrameInterval()                                         */
/*  Date     : 04/10/2002                                                   */
/*  Purpose  : updates the INTRA frame refresh interval while encoding      */
/*             is ongoing                                                   */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVUpdateIFrameInterval(VideoEncControls *encCtrl, Int aIFramePeriod)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    encData->encParams->IntraPeriod = aIFramePeriod;
    return PV_TRUE;
}
#endif
#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVSetNumIntraMBRefresh()                                     */
/*  Date     : 08/05/2003                                                   */
/*  Purpose  :                                                              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */
OSCL_EXPORT_REF Bool    PVUpdateNumIntraMBRefresh(VideoEncControls *encCtrl, Int numMB)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;

    encData->encParams->Refresh = numMB;

    return PV_TRUE;
}
#endif
#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVIFrameRequest()                                            */
/*  Date     : 04/10/2002                                                   */
/*  Purpose  : encodes the next base frame as an I-Vop                      */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVIFrameRequest(VideoEncControls *encCtrl)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    encData->nextEncIVop = 1;
    return PV_TRUE;
}
#endif
#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVGetEncMemoryUsage()                                        */
/*  Date     : 10/17/2000                                                   */
/*  Purpose  :                                                              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Int PVGetEncMemoryUsage(VideoEncControls *encCtrl)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;
    return encData->encParams->MemoryUsage;
}
#endif

/* ======================================================================== */
/*  Function : PVGetHintTrack()                                             */
/*  Date     : 1/17/2001,                                                   */
/*  Purpose  :                                                              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVGetHintTrack(VideoEncControls *encCtrl, MP4HintTrack *info)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;
    info->MTB = encData->hintTrackInfo.MTB;
    info->LayerID = encData->hintTrackInfo.LayerID;
    info->CodeType = encData->hintTrackInfo.CodeType;
    info->RefSelCode = encData->hintTrackInfo.RefSelCode;

    return PV_TRUE;
}

/* ======================================================================== */
/*  Function : PVGetMaxVideoFrameSize()                                     */
/*  Date     : 7/17/2001,                                                   */
/*  Purpose  : Function merely returns the maximum buffer size              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVGetMaxVideoFrameSize(VideoEncControls *encCtrl, Int *maxVideoFrameSize)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;



    *maxVideoFrameSize = encData->encParams->BufferSize[0];

    if (encData->encParams->nLayers == 2)
        if (*maxVideoFrameSize < encData->encParams->BufferSize[1])
            *maxVideoFrameSize = encData->encParams->BufferSize[1];
    *maxVideoFrameSize >>= 3;   /* Convert to Bytes */

    if (*maxVideoFrameSize <= 4000)
        *maxVideoFrameSize = 4000;

    return PV_TRUE;
}
#ifndef LIMITED_API
/* ======================================================================== */
/*  Function : PVGetVBVSize()                                               */
/*  Date     : 4/15/2002                                                    */
/*  Purpose  : Function merely returns the maximum buffer size              */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

OSCL_EXPORT_REF Bool PVGetVBVSize(VideoEncControls *encCtrl, Int *VBVSize)
{
    VideoEncData    *encData;

    encData = (VideoEncData *)encCtrl->videoEncoderData;

    if (encData == NULL)
        return PV_FALSE;
    if (encData->encParams == NULL)
        return PV_FALSE;

    *VBVSize = encData->encParams->BufferSize[0];
    if (encData->encParams->nLayers == 2)
        *VBVSize += encData->encParams->BufferSize[1];

    return PV_TRUE;

}
#endif
/* ======================================================================== */
/*  Function : EncodeVOS_Start()                                            */
/*  Date     : 08/22/2000                                                   */
/*  Purpose  : Encodes the VOS,VO, and VOL or Short Headers                 */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */
PV_STATUS EncodeVOS_Start(VideoEncControls *encoderControl)
{

    VideoEncData *video = (VideoEncData *)encoderControl->videoEncoderData;
    Vol         *currVol = video->vol[video->currLayer];
    PV_STATUS status = PV_SUCCESS;
    //int profile_level=0x01;
    BitstreamEncVideo *stream = video->bitstream1;
    int i, j;

    /********************************/
    /* Check for short_video_header */
    /********************************/
    if (currVol->shortVideoHeader == 1)
        return status;
    else
    {
        /* Short Video Header or M4V */

        /**************************/
        /* VisualObjectSequence ()*/
        /**************************/
        status = BitstreamPutGT16Bits(stream, 32, SESSION_START_CODE);
        /*  Determine profile_level */
        status = BitstreamPutBits(stream, 8, video->encParams->ProfileLevel[video->currLayer]);

        /******************/
        /* VisualObject() */
        /******************/

        status = BitstreamPutGT16Bits(stream, 32, VISUAL_OBJECT_START_CODE);
        status = BitstreamPut1Bits(stream, 0x00); /* visual object identifier */
        status = BitstreamPutBits(stream, 4, 0x01); /* visual object Type == "video ID" */
        status = BitstreamPut1Bits(stream, 0x00); /* no video signal type */

        /*temp   = */
        BitstreamMpeg4ByteAlignStuffing(stream);


        status = BitstreamPutGT16Bits(stream, 27, VO_START_CODE);/* byte align: should be 2 bits */
        status = BitstreamPutBits(stream, 5, 0x00);/*  Video ID = 0  */



        /**********************/
        /* VideoObjectLayer() */
        /**********************/
        if (currVol->shortVideoHeader == 0)
        { /* M4V  else Short Video Header */
            status = BitstreamPutGT16Bits(stream, VOL_START_CODE_LENGTH, VOL_START_CODE);
            status = BitstreamPutBits(stream, 4, currVol->volID);/*  video_object_layer_id */
            status = BitstreamPut1Bits(stream, 0x00);/*  Random Access = 0  */

            if (video->currLayer == 0)
                status = BitstreamPutBits(stream, 8, 0x01);/* Video Object Type Indication = 1  ... Simple Object Type */
            else
                status = BitstreamPutBits(stream, 8, 0x02);/* Video Object Type Indication = 2  ... Simple Scalable Object Type */

            status = BitstreamPut1Bits(stream, 0x00);/*  is_object_layer_identifer = 0 */


            status = BitstreamPutBits(stream, 4, 0x01); /* aspect_ratio_info = 1 ... 1:1(Square) */
            status = BitstreamPut1Bits(stream, 0x00);/* vol_control_parameters = 0 */
            status = BitstreamPutBits(stream, 2, 0x00);/* video_object_layer_shape = 00 ... rectangular */
            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
            status = BitstreamPutGT8Bits(stream, 16, currVol->timeIncrementResolution);/* vop_time_increment_resolution */
            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
            status = BitstreamPut1Bits(stream, currVol->fixedVopRate);/* fixed_vop_rate = 0 */

            /* For Rectangular VO layer shape */
            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
            status = BitstreamPutGT8Bits(stream, 13, currVol->width);/* video_object_layer_width */
            status = BitstreamPut1Bits(stream, 0x01);/* marker bit */
            status = BitstreamPutGT8Bits(stream, 13, currVol->height);/* video_object_layer_height */
            status = BitstreamPut1Bits(stream, 0x01);/*marker bit */

            status = BitstreamPut1Bits(stream, 0x00);/*interlaced = 0 */
            status = BitstreamPut1Bits(stream, 0x01);/* obmc_disable = 1 */
            status = BitstreamPut1Bits(stream, 0x00);/* sprite_enable = 0 */
            status = BitstreamPut1Bits(stream, 0x00);/* not_8_bit = 0 */
            status = BitstreamPut1Bits(stream, currVol->quantType);/*   quant_type */

            if (currVol->quantType)
            {
                status = BitstreamPut1Bits(stream, currVol->loadIntraQuantMat); /* Intra quant matrix */
                if (currVol->loadIntraQuantMat)
                {
                    for (j = 63; j >= 1; j--)
                        if (currVol->iqmat[*(zigzag_i+j)] != currVol->iqmat[*(zigzag_i+j-1)])
                            break;
                    if ((j == 1) && (currVol->iqmat[*(zigzag_i+j)] == currVol->iqmat[*(zigzag_i+j-1)]))
                        j = 0;
                    for (i = 0; i < j + 1; i++)
                        BitstreamPutBits(stream, 8, currVol->iqmat[*(zigzag_i+i)]);
                    if (j < 63)
                        BitstreamPutBits(stream, 8, 0);
                }
                else
                {
                    for (j = 0; j < 64; j++)
                        currVol->iqmat[j] = mpeg_iqmat_def[j];

                }
                status = BitstreamPut1Bits(stream, currVol->loadNonIntraQuantMat); /* Non-Intra quant matrix */
                if (currVol->loadNonIntraQuantMat)
                {
                    for (j = 63; j >= 1; j--)
                        if (currVol->niqmat[*(zigzag_i+j)] != currVol->niqmat[*(zigzag_i+j-1)])
                            break;
                    if ((j == 1) && (currVol->niqmat[*(zigzag_i+j)] == currVol->niqmat[*(zigzag_i+j-1)]))
                        j = 0;
                    for (i = 0; i < j + 1; i++)
                        BitstreamPutBits(stream, 8, currVol->niqmat[*(zigzag_i+i)]);
                    if (j < 63)
                        BitstreamPutBits(stream, 8, 0);
                }
                else
                {
                    for (j = 0; j < 64; j++)
                        currVol->niqmat[j] = mpeg_nqmat_def[j];
                }
            }

            status = BitstreamPut1Bits(stream, 0x01);   /* complexity_estimation_disable = 1 */
            status = BitstreamPut1Bits(stream, currVol->ResyncMarkerDisable);/* Resync_marker_disable */
            status = BitstreamPut1Bits(stream, currVol->dataPartitioning);/* Data partitioned */

            if (currVol->dataPartitioning)
                status = BitstreamPut1Bits(stream, currVol->useReverseVLC); /* Reversible_vlc */


            if (currVol->scalability) /* Scalability*/
            {

                status = BitstreamPut1Bits(stream, currVol->scalability);/* Scalability = 1 */
                status = BitstreamPut1Bits(stream, currVol->scalType);/* hierarchy _type ... Spatial= 0 and Temporal = 1 */
                status = BitstreamPutBits(stream, 4, currVol->refVolID);/* ref_layer_id  */
                status = BitstreamPut1Bits(stream, currVol->refSampDir);/* ref_layer_sampling_direc*/
                status = BitstreamPutBits(stream, 5, currVol->horSamp_n);/*hor_sampling_factor_n*/
                status = BitstreamPutBits(stream, 5, currVol->horSamp_m);/*hor_sampling_factor_m*/
                status = BitstreamPutBits(stream, 5, currVol->verSamp_n);/*vert_sampling_factor_n*/
                status = BitstreamPutBits(stream, 5, currVol->verSamp_m);/*vert_sampling_factor_m*/
                status = BitstreamPut1Bits(stream, currVol->enhancementType);/* enhancement_type*/
            }
            else /* No Scalability */
                status = BitstreamPut1Bits(stream, currVol->scalability);/* Scalability = 0 */

            /*temp = */
            BitstreamMpeg4ByteAlignStuffing(stream); /* Byte align Headers for VOP */
        }
    }

    return status;
}

/* ======================================================================== */
/*  Function : VOS_End()                                                    */
/*  Date     : 08/22/2000                                                   */
/*  Purpose  : Visual Object Sequence End                                   */
/*  In/out   :                                                              */
/*  Return   : PV_TRUE if successed, PV_FALSE if failed.                    */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

PV_STATUS VOS_End(VideoEncControls *encoderControl)
{
    PV_STATUS status = PV_SUCCESS;
    VideoEncData *video = (VideoEncData *)encoderControl->videoEncoderData;
    Vol         *currVol = video->vol[video->currLayer];
    BitstreamEncVideo *stream = currVol->stream;


    status = BitstreamPutBits(stream, SESSION_END_CODE, 32);

    return status;
}

/* ======================================================================== */
/*  Function : DetermineCodingLayer                                         */
/*  Date     : 06/02/2001                                                   */
/*  Purpose  : Find layer to code based on current mod time, assuming that
               it's time to encode enhanced layer.                          */
/*  In/out   :                                                              */
/*  Return   : Number of layer to code.                                     */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

Int DetermineCodingLayer(VideoEncData *video, Int *nLayer, ULong modTime)
{
    Vol **vol = video->vol;
    VideoEncParams *encParams = video->encParams;
    Int numLayers = encParams->nLayers;
    UInt modTimeRef = video->modTimeRef;
    float *LayerFrameRate = encParams->LayerFrameRate;
    UInt frameNum[4], frameTick;
    ULong frameModTime, nextFrmModTime;
#ifdef REDUCE_FRAME_VARIANCE    /* To limit how close 2 frames can be */
    float frameInterval;
#endif
    float srcFrameInterval;
    Int frameInc;
    Int i, extra_skip;
    Int encodeVop = 0;

    i = numLayers - 1;

    if (modTime - video->nextModTime > ((ULong)(-1)) >> 1) /* next time wrapped around */
        return 0; /* not time to code it yet */

    video->relLayerCodeTime[i] -= 1000;
    video->nextEncIVop--;  /* number of Vops in highest layer resolution. */
    video->numVopsInGOP++;

    /* from this point frameModTime and nextFrmModTime are internal */

    frameNum[i] = (UInt)((modTime - modTimeRef) * LayerFrameRate[i] + 500) / 1000;
    if (video->volInitialize[i])
    {
        video->prevFrameNum[i] = frameNum[i] - 1;
    }
    else if (frameNum[i] <= video->prevFrameNum[i])
    {
        return 0; /* do not encode this frame */
    }

    /**** this part computes expected next frame *******/
    frameModTime = (ULong)(((frameNum[i] * 1000) / LayerFrameRate[i]) + modTimeRef + 0.5); /* rec. time */
    nextFrmModTime = (ULong)((((frameNum[i] + 1) * 1000) / LayerFrameRate[i]) + modTimeRef + 0.5); /* rec. time */

    srcFrameInterval = 1000 / video->FrameRate;

    video->nextModTime = nextFrmModTime - (ULong)(srcFrameInterval / 2.) - 1; /* between current and next frame */

#ifdef REDUCE_FRAME_VARIANCE    /* To limit how close 2 frames can be */
    frameInterval = 1000 / LayerFrameRate[i]; /* next rec. time */
    delta = (Int)(frameInterval / 4); /* empirical number */
    if (video->nextModTime - modTime  < (ULong)delta) /* need to move nextModTime further. */
    {
        video->nextModTime += ((delta - video->nextModTime + modTime)); /* empirical formula  */
    }
#endif
    /****************************************************/

    /* map frame no.to tick from modTimeRef */
    /*frameTick = (frameNum[i]*vol[i]->timeIncrementResolution) ;
    frameTick = (UInt)((frameTick + (encParams->LayerFrameRate[i]/2))/encParams->LayerFrameRate[i]);*/
    /*  11/16/01, change frameTick to be the closest tick from the actual modTime */
    /*  12/12/02, add (double) to prevent large number wrap-around */
    frameTick = (Int)(((double)(modTime - modTimeRef) * vol[i]->timeIncrementResolution + 500) / 1000);

    /* find timeIncrement to be put in the bitstream */
    /* refTick is second boundary reference. */
    vol[i]->timeIncrement = frameTick - video->refTick[i];


    vol[i]->moduloTimeBase = 0;
    while (vol[i]->timeIncrement >= vol[i]->timeIncrementResolution)
    {
        vol[i]->timeIncrement -= vol[i]->timeIncrementResolution;
        vol[i]->moduloTimeBase++;
        /* do not update refTick and modTimeRef yet, do it after encoding!! */
    }

    if (video->relLayerCodeTime[i] <= 0)    /* no skipping */
    {
        encodeVop = 1;
        video->currLayer = *nLayer = i;
        video->relLayerCodeTime[i] += 1000;

        /* takes care of more dropped frame than expected */
        extra_skip = -1;
        frameInc = (frameNum[i] - video->prevFrameNum[i]);
        extra_skip += frameInc;

        if (extra_skip > 0)
        {   /* update rc->Nr, rc->B, (rc->Rr)*/
            video->nextEncIVop -= extra_skip;
            video->numVopsInGOP += extra_skip;
            if (encParams->RC_Type != CONSTANT_Q)
            {
                RC_UpdateBuffer(video, i, extra_skip);
            }
        }

    }
    /* update frame no. */
    video->prevFrameNum[i] = frameNum[i];

    /* go through all lower layer */
    for (i = (numLayers - 2); i >= 0; i--)
    {

        video->relLayerCodeTime[i] -= 1000;

        /* find timeIncrement to be put in the bitstream */
        vol[i]->timeIncrement = frameTick - video->refTick[i];

        if (video->relLayerCodeTime[i] <= 0) /* time to encode base */
        {
            /* 12/27/00 */
            encodeVop = 1;
            video->currLayer = *nLayer = i;
            video->relLayerCodeTime[i] +=
                (Int)((1000.0 * encParams->LayerFrameRate[numLayers-1]) / encParams->LayerFrameRate[i]);

            vol[i]->moduloTimeBase = 0;
            while (vol[i]->timeIncrement >= vol[i]->timeIncrementResolution)
            {
                vol[i]->timeIncrement -= vol[i]->timeIncrementResolution;
                vol[i]->moduloTimeBase++;
                /* do not update refTick and modTimeRef yet, do it after encoding!! */
            }

            /* takes care of more dropped frame than expected */
            frameNum[i] = (UInt)((frameModTime - modTimeRef) * encParams->LayerFrameRate[i] + 500) / 1000;
            if (video->volInitialize[i])
                video->prevFrameNum[i] = frameNum[i] - 1;

            extra_skip = -1;
            frameInc = (frameNum[i] - video->prevFrameNum[i]);
            extra_skip += frameInc;

            if (extra_skip > 0)
            {   /* update rc->Nr, rc->B, (rc->Rr)*/
                if (encParams->RC_Type != CONSTANT_Q)
                {
                    RC_UpdateBuffer(video, i, extra_skip);
                }
            }
            /* update frame no. */
            video->prevFrameNum[i] = frameNum[i];
        }
    }

#ifdef _PRINT_STAT
    if (encodeVop)
        printf(" TI: %d ", vol[*nLayer]->timeIncrement);
#endif

    return encodeVop;
}

/* ======================================================================== */
/*  Function : DetermineVopType                                             */
/*  Date     : 06/02/2001                                                   */
/*  Purpose  : The name says it all.                                        */
/*  In/out   :                                                              */
/*  Return   : void .                                                       */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

void DetermineVopType(VideoEncData *video, Int currLayer)
{
    VideoEncParams *encParams = video->encParams;
//  Vol *currVol = video->vol[currLayer];

    if (encParams->IntraPeriod == 0) /* I-VOPs only */
    {
        if (video->currLayer > 0)
            video->currVop->predictionType = P_VOP;
        else
        {
            video->currVop->predictionType = I_VOP;
            if (video->numVopsInGOP >= 132)
                video->numVopsInGOP = 0;
        }
    }
    else if (encParams->IntraPeriod == -1)  /* IPPPPP... */
    {

        /* maintain frame type if previous frame is pre-skipped, 06/02/2001 */
        if (encParams->RC_Type == CONSTANT_Q || video->rc[currLayer]->skip_next_frame != -1)
            video->currVop->predictionType = P_VOP;

        if (video->currLayer == 0)
        {
            if (/*video->numVopsInGOP>=132 || */video->volInitialize[currLayer])
            {
                video->currVop->predictionType = I_VOP;
                video->numVopsInGOP = 0; /* force INTRA update every 132 base frames*/
                video->nextEncIVop = 1;
            }
            else if (video->nextEncIVop == 0 || video->currVop->predictionType == I_VOP)
            {
                video->numVopsInGOP = 0;
                video->nextEncIVop = 1;
            }
        }
    }
    else   /* IntraPeriod>0 : IPPPPPIPPPPPI... */
    {

        /* maintain frame type if previous frame is pre-skipped, 06/02/2001 */
        if (encParams->RC_Type == CONSTANT_Q || video->rc[currLayer]->skip_next_frame != -1)
            video->currVop->predictionType = P_VOP;

        if (currLayer == 0)
        {
            if (video->nextEncIVop <= 0 || video->currVop->predictionType == I_VOP)
            {
                video->nextEncIVop = encParams->IntraPeriod;
                video->currVop->predictionType = I_VOP;
                video->numVopsInGOP = 0;
            }
        }
    }

    return ;
}

/* ======================================================================== */
/*  Function : UpdateSkipNextFrame                                          */
/*  Date     : 06/02/2001                                                   */
/*  Purpose  : From rate control frame skipping decision, update timing
                related parameters.                                         */
/*  In/out   :                                                              */
/*  Return   : Current coded layer.                                         */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

Int UpdateSkipNextFrame(VideoEncData *video, ULong *modTime, Int *size, PV_STATUS status)
{
    Int currLayer = video->currLayer;
    Int nLayer = currLayer;
    VideoEncParams *encParams = video->encParams;
    Int numLayers = encParams->nLayers;
    Vol *currVol = video->vol[currLayer];
    Vol **vol = video->vol;
    Int num_skip, extra_skip;
    Int i;
    UInt newRefTick, deltaModTime;
    UInt temp;

    if (encParams->RC_Type != CONSTANT_Q)
    {
        if (video->volInitialize[0] && currLayer == 0)  /* always encode the first frame */
        {
            RC_ResetSkipNextFrame(video, currLayer);
            //return currLayer;  09/15/05
        }
        else
        {
            if (RC_GetSkipNextFrame(video, currLayer) < 0 || status == PV_END_OF_BUF)   /* Skip Current Frame */
            {

#ifdef _PRINT_STAT
                printf("Skip current frame");
#endif
                currVol->moduloTimeBase = currVol->prevModuloTimeBase;

                /*********************/
                /* prepare to return */
                /*********************/
                *size = 0;  /* Set Bitstream buffer to zero */

                /* Determine nLayer and modTime for next encode */

                *modTime = video->nextModTime;
                nLayer = -1;

                return nLayer; /* return immediately without updating RefTick & modTimeRef */
                /* If I-VOP was attempted, then ensure next base is I-VOP */
                /*if((encParams->IntraPeriod>0) && (video->currVop->predictionType == I_VOP))
                video->nextEncIVop = 0; commented out by 06/05/01 */

            }
            else if ((num_skip = RC_GetSkipNextFrame(video, currLayer)) > 0)
            {

#ifdef _PRINT_STAT
                printf("Skip next %d frames", num_skip);
#endif
                /* to keep the Nr of enh layer the same */
                /* adjust relLayerCodeTime only, do not adjust layerCodeTime[numLayers-1] */
                extra_skip = 0;
                for (i = 0; i < currLayer; i++)
                {
                    if (video->relLayerCodeTime[i] <= 1000)
                    {
                        extra_skip = 1;
                        break;
                    }
                }

                for (i = currLayer; i < numLayers; i++)
                {
                    video->relLayerCodeTime[i] += (num_skip + extra_skip) *
                                                  ((Int)((1000.0 * encParams->LayerFrameRate[numLayers-1]) / encParams->LayerFrameRate[i]));
                }
            }
        }/* first frame */
    }
    /*****  current frame is encoded, now update refTick ******/

    video->refTick[currLayer] += vol[currLayer]->prevModuloTimeBase * vol[currLayer]->timeIncrementResolution;

    /* Reset layerCodeTime every I-VOP to prevent overflow */
    if (currLayer == 0)
    {
        /*  12/12/02, fix for weird targer frame rate of 9.99 fps or 3.33 fps */
        if (((encParams->IntraPeriod != 0) /*&& (video->currVop->predictionType==I_VOP)*/) ||
                ((encParams->IntraPeriod == 0) && (video->numVopsInGOP == 0)))
        {
            newRefTick = video->refTick[0];

            for (i = 1; i < numLayers; i++)
            {
                if (video->refTick[i] < newRefTick)
                    newRefTick = video->refTick[i];
            }

            /* check to make sure that the update is integer multiple of frame number */
            /* how many msec elapsed from last modTimeRef */
            deltaModTime = (newRefTick / vol[0]->timeIncrementResolution) * 1000;

            for (i = numLayers - 1; i >= 0; i--)
            {
                temp = (UInt)(deltaModTime * encParams->LayerFrameRate[i]); /* 12/12/02 */
                if (temp % 1000)
                    newRefTick = 0;

            }
            if (newRefTick > 0)
            {
                video->modTimeRef += deltaModTime;
                for (i = numLayers - 1; i >= 0; i--)
                {
                    video->prevFrameNum[i] -= (UInt)(deltaModTime * encParams->LayerFrameRate[i]) / 1000;
                    video->refTick[i] -= newRefTick;
                }
            }
        }
    }

    *modTime =  video->nextModTime;

    return nLayer;
}


#ifndef ORIGINAL_VERSION

/* ======================================================================== */
/*  Function : SetProfile_BufferSize                                        */
/*  Date     : 04/08/2002                                                   */
/*  Purpose  : Set profile and video buffer size, copied from Jim's code    */
/*             in PVInitVideoEncoder(.), since we have different places     */
/*             to reset profile and video buffer size                       */
/*  In/out   :                                                              */
/*  Return   :                                                              */
/*  Modified :                                                              */
/*                                                                          */
/* ======================================================================== */

Bool SetProfile_BufferSize(VideoEncData *video, float delay, Int bInitialized)
{
    Int i, j, start, end;
//  Int BaseMBsPerSec = 0, EnhMBsPerSec = 0;
    Int nTotalMB = 0;
    Int idx, temp_w, temp_h, max = 0, max_width, max_height;

    Int nLayers = video->encParams->nLayers; /* Number of Layers to be encoded */

    Int total_bitrate = 0, base_bitrate;
    Int total_packet_size = 0, base_packet_size;
    Int total_MBsPerSec = 0, base_MBsPerSec;
    Int total_VBV_size = 0, base_VBV_size, enhance_VBV_size = 0;
    float total_framerate, base_framerate;
    float upper_bound_ratio;
    Int bFound = 0;
    Int k = 0, width16, height16, index;
    Int lowest_level;

#define MIN_BUFF    16000 /* 16k minimum buffer size */
#define BUFF_CONST  2.0    /* 2000ms */
#define UPPER_BOUND_RATIO 8.54 /* upper_bound = 1.4*(1.1+bound/10)*bitrate/framerate */

#define QCIF_WIDTH  176
#define QCIF_HEIGHT 144

    index = video->encParams->profile_table_index;

    /* Calculate "nTotalMB" */
    /* Find the maximum width*height for memory allocation of the VOPs */
    for (idx = 0; idx < nLayers; idx++)
    {
        temp_w = video->encParams->LayerWidth[idx];
        temp_h = video->encParams->LayerHeight[idx];

        if ((temp_w*temp_h) > max)
        {
            max = temp_w * temp_h;
            max_width = temp_w;
            max_height = temp_h;
            nTotalMB = ((max_width + 15) >> 4) * ((max_height + 15) >> 4);
        }
    }
    upper_bound_ratio = (video->encParams->RC_Type == CBR_LOWDELAY ? (float)5.0 : (float)UPPER_BOUND_RATIO);


    /* Get the basic information: bitrate, packet_size, MBs/s and VBV_size */
    base_bitrate        = video->encParams->LayerBitRate[0];
    if (video->encParams->LayerMaxBitRate[0] != 0) /* video->encParams->LayerMaxBitRate[0] == 0 means it has not been set */
    {
        base_bitrate    = PV_MAX(base_bitrate, video->encParams->LayerMaxBitRate[0]);
    }
    else /* if the max is not set, set it to the specified profile/level */
    {
        video->encParams->LayerMaxBitRate[0] = profile_level_max_bitrate[index];
    }

    base_framerate      = video->encParams->LayerFrameRate[0];
    if (video->encParams->LayerMaxFrameRate[0] != 0)
    {
        base_framerate  = PV_MAX(base_framerate, video->encParams->LayerMaxFrameRate[0]);
    }
    else /* if the max is not set, set it to the specified profile/level */
    {
        video->encParams->LayerMaxFrameRate[0] = (float)profile_level_max_mbsPerSec[index] / nTotalMB;
    }

    base_packet_size    = video->encParams->ResyncPacketsize;
    base_MBsPerSec      = (Int)(base_framerate * nTotalMB);
    base_VBV_size       = PV_MAX((Int)(base_bitrate * delay),
                                 (Int)(upper_bound_ratio * base_bitrate / base_framerate));
    base_VBV_size       = PV_MAX(base_VBV_size, MIN_BUFF);

    /* if the buffer is larger than maximum buffer size, we'll clip it */
    if (base_VBV_size > profile_level_max_VBV_size[5])
        base_VBV_size = profile_level_max_VBV_size[5];


    /* Check if the buffer exceeds the maximum buffer size given the maximum profile and level */
    if (nLayers == 1 && base_VBV_size > profile_level_max_VBV_size[index])
        return FALSE;


    if (nLayers == 2)
    {
        total_bitrate       = video->encParams->LayerBitRate[1];
        if (video->encParams->LayerMaxBitRate[1] != 0)
        {
            total_bitrate   = PV_MIN(total_bitrate, video->encParams->LayerMaxBitRate[1]);
        }
        else /* if the max is not set, set it to the specified profile/level */
        {
            video->encParams->LayerMaxBitRate[1] = scalable_profile_level_max_bitrate[index];
        }

        total_framerate     = video->encParams->LayerFrameRate[1];
        if (video->encParams->LayerMaxFrameRate[1] != 0)
        {
            total_framerate     = PV_MIN(total_framerate, video->encParams->LayerMaxFrameRate[1]);
        }
        else /* if the max is not set, set it to the specified profile/level */
        {
            video->encParams->LayerMaxFrameRate[1] = (float)scalable_profile_level_max_mbsPerSec[index] / nTotalMB;
        }

        total_packet_size   = video->encParams->ResyncPacketsize;
        total_MBsPerSec     = (Int)(total_framerate * nTotalMB);

        enhance_VBV_size    = PV_MAX((Int)((total_bitrate - base_bitrate) * delay),
                                     (Int)(upper_bound_ratio * (total_bitrate - base_bitrate) / (total_framerate - base_framerate)));
        enhance_VBV_size    = PV_MAX(enhance_VBV_size, MIN_BUFF);

        total_VBV_size      = base_VBV_size + enhance_VBV_size;

        /* if the buffer is larger than maximum buffer size, we'll clip it */
        if (total_VBV_size > scalable_profile_level_max_VBV_size[6])
        {
            total_VBV_size = scalable_profile_level_max_VBV_size[6];
            enhance_VBV_size = total_VBV_size - base_VBV_size;
        }

        /* Check if the buffer exceeds the maximum buffer size given the maximum profile and level */
        if (total_VBV_size > scalable_profile_level_max_VBV_size[index])
            return FALSE;
    }


    if (!bInitialized) /* Has been initialized --> profile @ level has been figured out! */
    {
        video->encParams->BufferSize[0] = base_VBV_size;
        if (nLayers > 1)
            video->encParams->BufferSize[1] = enhance_VBV_size;

        return PV_TRUE;
    }


    /* Profile @ level determination */
    if (nLayers == 1)
    {
        /* BASE ONLY : Simple Profile(SP) Or Core Profile(CP) */
        if (base_bitrate     > profile_level_max_bitrate[index]     ||
                base_packet_size > profile_level_max_packet_size[index] ||
                base_MBsPerSec   > profile_level_max_mbsPerSec[index]   ||
                base_VBV_size    > profile_level_max_VBV_size[index])

            return PV_FALSE; /* Beyond the bound of Core Profile @ Level2 */

        /* For H263/Short header, determine k*16384 */
        width16  = ((video->encParams->LayerWidth[0] + 15) >> 4) << 4;
        height16 = ((video->encParams->LayerHeight[0] + 15) >> 4) << 4;
        if (video->encParams->H263_Enabled)
        {
            k = 4;
            if (width16  == 2*QCIF_WIDTH && height16 == 2*QCIF_HEIGHT)  /* CIF */
                k = 16;

            else if (width16  == 4*QCIF_WIDTH && height16 == 4*QCIF_HEIGHT)  /* 4CIF */
                k = 32;

            else if (width16  == 8*QCIF_WIDTH && height16 == 8*QCIF_HEIGHT)  /* 16CIF */
                k = 64;

            video->encParams->maxFrameSize  = k * 16384;

            /* Make sure the buffer size is limited to the top profile and level: the Core profile and level 2 */
            if (base_VBV_size > (Int)(k*16384 + 4*(float)profile_level_max_bitrate[5]*1001.0 / 30000.0))
                base_VBV_size = (Int)(k * 16384 + 4 * (float)profile_level_max_bitrate[5] * 1001.0 / 30000.0);

            if (base_VBV_size > (Int)(k*16384 + 4*(float)profile_level_max_bitrate[index]*1001.0 / 30000.0))
                return PV_FALSE;
        }

        /* Search the appropriate profile@level index */
        if (!video->encParams->H263_Enabled &&
                (video->encParams->IntraDCVlcThr != 0 || video->encParams->SearchRange > 16))
        {
            lowest_level = 1; /* cannot allow SPL0 */
        }
        else
        {
            lowest_level = 0; /* SPL0 */
        }

        for (i = lowest_level; i <= index; i++)
        {
            if (i != 4 && /* skip Core Profile@Level1 because the parameters in it are smaller than those in Simple Profile@Level3 */
                    base_bitrate     <= profile_level_max_bitrate[i]     &&
                    base_packet_size <= profile_level_max_packet_size[i] &&
                    base_MBsPerSec   <= profile_level_max_mbsPerSec[i]   &&
                    base_VBV_size    <= (video->encParams->H263_Enabled ? (Int)(k*16384 + 4*(float)profile_level_max_bitrate[i]*1001.0 / 30000.0) :
                                         profile_level_max_VBV_size[i]))
                break;
        }
        if (i > index) return PV_FALSE; /* Nothing found!! */

        /* Found out the actual profile @ level : index "i" */
        if (i == 0)
        {
            /* For Simple Profile @ Level 0, we need to do one more check: image size <= QCIF */
            if (width16 > QCIF_WIDTH || height16 > QCIF_HEIGHT)
                i = 1; /* image size > QCIF, then set SP level1 */
        }

        video->encParams->ProfileLevel[0] = profile_level_code[i];
        video->encParams->BufferSize[0]   = base_VBV_size;

        if (video->encParams->LayerMaxBitRate[0] == 0)
            video->encParams->LayerMaxBitRate[0] = profile_level_max_bitrate[i];

        if (video->encParams->LayerMaxFrameRate[0] == 0)
            video->encParams->LayerMaxFrameRate[0] = PV_MIN(30, (float)profile_level_max_mbsPerSec[i] / nTotalMB);

        /* For H263/Short header, one special constraint for VBV buffer size */
        if (video->encParams->H263_Enabled)
            video->encParams->BufferSize[0] = (Int)(k * 16384 + 4 * (float)profile_level_max_bitrate[i] * 1001.0 / 30000.0);

    }
    else
    {
        /* SCALABALE MODE: Simple Scalable Profile(SSP) Or Core Scalable Profile(CSP) */

        if (total_bitrate       > scalable_profile_level_max_bitrate[index]     ||
                total_packet_size   > scalable_profile_level_max_packet_size[index] ||
                total_MBsPerSec     > scalable_profile_level_max_mbsPerSec[index]   ||
                total_VBV_size      > scalable_profile_level_max_VBV_size[index])

            return PV_FALSE; /* Beyond given profile and level */

        /* One-time check: Simple Scalable Profile or Core Scalable Profile */
        if (total_bitrate       <= scalable_profile_level_max_bitrate[2]        &&
                total_packet_size   <= scalable_profile_level_max_packet_size[2]    &&
                total_MBsPerSec     <= scalable_profile_level_max_mbsPerSec[2]      &&
                total_VBV_size      <= scalable_profile_level_max_VBV_size[2])

        {
            start = 0;
            end = index;
        }

        else
        {
            start = 4;
            end = index;
        }


        /* Search the scalable profile */
        for (i = start; i <= end; i++)
        {
            if (total_bitrate       <= scalable_profile_level_max_bitrate[i]     &&
                    total_packet_size   <= scalable_profile_level_max_packet_size[i] &&
                    total_MBsPerSec     <= scalable_profile_level_max_mbsPerSec[i]   &&
                    total_VBV_size      <= scalable_profile_level_max_VBV_size[i])

                break;
        }
        if (i > end) return PV_FALSE;

        /* Search the base profile */
        if (i == 0)
        {
            j = 0;
            bFound = 1;
        }
        else        bFound = 0;

        for (j = start; !bFound && j <= i; j++)
        {
            if (base_bitrate        <= profile_level_max_bitrate[j]      &&
                    base_packet_size    <= profile_level_max_packet_size[j]  &&
                    base_MBsPerSec      <= profile_level_max_mbsPerSec[j]    &&
                    base_VBV_size       <= profile_level_max_VBV_size[j])

            {
                bFound = 1;
                break;
            }
        }

        if (!bFound) // && start == 4)
            return PV_FALSE; /* mis-match in the profiles between base layer and enhancement layer */

        /* j for base layer, i for enhancement layer */
        video->encParams->ProfileLevel[0] = profile_level_code[j];
        video->encParams->ProfileLevel[1] = scalable_profile_level_code[i];
        video->encParams->BufferSize[0]   = base_VBV_size;
        video->encParams->BufferSize[1]   = enhance_VBV_size;

        if (video->encParams->LayerMaxBitRate[0] == 0)
            video->encParams->LayerMaxBitRate[0] = profile_level_max_bitrate[j];

        if (video->encParams->LayerMaxBitRate[1] == 0)
            video->encParams->LayerMaxBitRate[1] = scalable_profile_level_max_bitrate[i];

        if (video->encParams->LayerMaxFrameRate[0] == 0)
            video->encParams->LayerMaxFrameRate[0] = PV_MIN(30, (float)profile_level_max_mbsPerSec[j] / nTotalMB);

        if (video->encParams->LayerMaxFrameRate[1] == 0)
            video->encParams->LayerMaxFrameRate[1] = PV_MIN(30, (float)scalable_profile_level_max_mbsPerSec[i] / nTotalMB);


    } /* end of: if(nLayers == 1) */


    if (!video->encParams->H263_Enabled && (video->encParams->ProfileLevel[0] == 0x08)) /* SPL0 restriction*/
    {
        /* PV only allow frame-based rate control, no QP change from one MB to another
        if(video->encParams->ACDCPrediction == TRUE && MB-based rate control)
         return PV_FALSE */
    }

    return PV_TRUE;
}

#endif /* #ifndef ORIGINAL_VERSION */