#include "viddec_mp4_videoobjectplane.h"

mp4_Status_t mp4_Parse_GroupOfVideoObjectPlane(void *parent, viddec_mp4_parser_t *parser)
{
    mp4_Info_t* pInfo = &(parser->info);
    uint32_t  code;
    int32_t getbits=0;
    mp4_Status_t ret = MP4_STATUS_REQD_DATA_ERROR;
    mp4_GroupOfVideoObjectPlane_t *data;
    uint32_t time_code = 0;

    data = &(pInfo->VisualObject.VideoObject.GroupOfVideoObjectPlane);
    
    do
    {
        getbits = viddec_pm_get_bits(parent, &code, 20);
        BREAK_GETBITS_FAIL(getbits, ret);
        ret = MP4_STATUS_OK;

        data->broken_link = ((code & 0x1) > 0);
        data->closed_gov = ((code & 0x2) > 0);
        time_code = code = code >> 2;
        data->time_code_seconds = code & 0x3F;
        code = code >> 6;
        if((code & 1) == 0)
        {/* SGA:Should we ignore marker bit? */
            DEB("Error:mp4_Parse_GroupOfVideoObjectPlane: Invalid marker\n");
        }
        code = code >>1;
        data->time_code_minutes = code & 0x3F;
        code = code >> 6;
        data->time_code_hours = code & 0x1F;

        // This is the timebase in full second units
        data->time_base = data->time_code_seconds + (60*data->time_code_minutes) + (3600*data->time_code_hours);
        // Need to convert this into no. of ticks
        data->time_base *= pInfo->VisualObject.VideoObject.vop_time_increment_resolution;
      
    } while(0);

    mp4_set_hdr_bitstream_error(parser, true, ret);

    // POPULATE WORKLOAD ITEM
    {
        viddec_workload_item_t wi;
    
        wi.vwi_type = VIDDEC_WORKLOAD_MPEG4_GRP_VIDEO_OBJ;

        wi.mp4_gvop.gvop_info = 0;
        wi.mp4_gvop.pad1 = 0;
        wi.mp4_gvop.pad2 = 0;

        viddec_fw_mp4_gvop_set_broken_link(&wi.mp4_gvop, data->broken_link);
        viddec_fw_mp4_gvop_set_closed_gov(&wi.mp4_gvop, data->closed_gov);
        viddec_fw_mp4_gvop_set_time_code(&wi.mp4_gvop, time_code);

        ret = viddec_pm_append_workitem(parent, &wi, false);
        if(ret == 1)
            ret = MP4_STATUS_OK;
    }

    return ret;
}

static inline mp4_Status_t mp4_brightness_change(void *parent, int32_t *b_change)
{
    uint32_t code;
    int32_t getbits=0;

    *b_change = 0;
    getbits = viddec_pm_peek_bits(parent, &code, 4);
    if (code == 15)
    {
        getbits = viddec_pm_skip_bits(parent, 4);
        getbits = viddec_pm_get_bits(parent, &code, 10);
        *b_change = 625 + code;
    }
    else if (code == 14)
    {
        getbits = viddec_pm_skip_bits(parent, 4);
        getbits = viddec_pm_get_bits(parent, &code, 9);
        *b_change = 113 + code;        
    }
    else if (code >= 12)
    {
        getbits = viddec_pm_skip_bits(parent, 3);
        getbits = viddec_pm_get_bits(parent, &code, 7);
        *b_change = (code < 64) ? ((int32_t)code - 112) : ((int32_t)code - 15);
    }
    else if (code >= 8)
    {
        getbits = viddec_pm_skip_bits(parent, 2);
        getbits = viddec_pm_get_bits(parent, &code, 6);
        *b_change = (code < 32) ? ((int32_t)code - 48) : ((int32_t)code - 15);        
    }
    else
    {
        getbits = viddec_pm_skip_bits(parent, 1);
        getbits = viddec_pm_get_bits(parent, &code, 5);
        *b_change = (code < 16) ? ((int32_t)code - 16) : ((int32_t)code - 15);
    }

    return ( (getbits == -1) ? MP4_STATUS_PARSE_ERROR: MP4_STATUS_OK);
}
static inline int32_t mp4_Sprite_dmv_length(void * parent, int32_t *dmv_length)
{
    uint32_t code, skip;
    int32_t getbits=0;
    mp4_Status_t ret= MP4_STATUS_PARSE_ERROR;
    *dmv_length=0;
    skip=3;
    do{
        getbits = viddec_pm_peek_bits(parent, &code, skip);
        BREAK_GETBITS_REQD_MISSING(getbits, ret);
        
        if(code == 7)
        {
            viddec_pm_skip_bits(parent, skip);
            getbits = viddec_pm_peek_bits(parent, &code, 9);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            
            skip=1;
            while((code & 256) != 0)
            {/* count number of 1 bits */
                code <<=1;
                skip++;
            }
            *dmv_length = 5 + skip;
        }
        else
        {
            skip=(code <= 1) ? 2 : 3;
            *dmv_length = code - 1;
        }
        viddec_pm_skip_bits(parent, skip);
        ret= MP4_STATUS_OK;
        
    }while(0);
    return ret;
}

static inline mp4_Status_t
mp4_Sprite_Trajectory(void *parent, mp4_VideoObjectLayer_t *vidObjLay, mp4_VideoObjectPlane_t *vidObjPlane)
{
    uint32_t code, i;
    int32_t dmv_length=0, dmv_code=0, getbits=0;
    mp4_Status_t ret = MP4_STATUS_OK;
    for(i=0; i < (uint32_t)vidObjLay->sprite_info.no_of_sprite_warping_points; i++ )
    {
        ret = mp4_Sprite_dmv_length(parent, &dmv_length);
        if(ret != MP4_STATUS_OK)
        {
            break;
        }
        if(dmv_length <= 0)
        {
            dmv_code = 0;
        }
        else
        {
            getbits = viddec_pm_get_bits(parent, &code, (uint32_t)dmv_length);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            dmv_code = (int32_t)code;
            if ((dmv_code & (1 << (dmv_length - 1))) == 0)
            {
                dmv_code -= (1 << dmv_length) - 1;
            }
        }
        getbits = viddec_pm_get_bits(parent, &code, 1);
        BREAK_GETBITS_REQD_MISSING(getbits, ret);
        if(code != 1)
        {
            ret = MP4_STATUS_NOTSUPPORT;
            break;
        }
        vidObjPlane->warping_mv_code_du[i] = dmv_code;
        /* TODO: create another inline function to avoid code duplication */
        ret = mp4_Sprite_dmv_length(parent, &dmv_length);
        if(ret != MP4_STATUS_OK)
        {
            break;
        }
        if(dmv_length <= 0)
        {
            dmv_code = 0;
        }
        else
        {
            getbits = viddec_pm_get_bits(parent, &code, (uint32_t)dmv_length);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            dmv_code = (int32_t)code;
            if ((dmv_code & (1 << (dmv_length - 1))) == 0)
            {
                dmv_code -= (1 << dmv_length) - 1;
            }
        }
        getbits = viddec_pm_get_bits(parent, &code, 1);
        BREAK_GETBITS_REQD_MISSING(getbits, ret);
        if(code != 1)
        {
            ret = MP4_STATUS_NOTSUPPORT;
            break;
        }
        vidObjPlane->warping_mv_code_dv[i] = dmv_code;
        
    }
    return ret;
}

static inline mp4_Status_t mp4_pvt_extract_modulotimebase_from_VideoObjectPlane(void *parent, uint32_t *base)
{
    mp4_Status_t ret= MP4_STATUS_OK;
    int32_t getbits=0;
    uint32_t  code = 0;

    *base = 0;
    do
    {
        getbits = viddec_pm_get_bits(parent, &code, 1);
        BREAK_GETBITS_REQD_MISSING(getbits, ret);
        *base += code;
    }while(code != 0);
    return ret;
}

mp4_Status_t mp4_Parse_VideoObjectPlane(void *parent, viddec_mp4_parser_t *parser)
{
    uint32_t  code;
    mp4_Info_t               *pInfo = &(parser->info);
    mp4_VideoObjectLayer_t   *vidObjLay  = &(pInfo->VisualObject.VideoObject);    
    mp4_VideoObjectPlane_t   *vidObjPlane = &(pInfo->VisualObject.VideoObject.VideoObjectPlane);
    int32_t getbits=0;
    mp4_Status_t ret= MP4_STATUS_PARSE_ERROR;

    do
    {
        getbits = viddec_pm_get_bits(parent, &code, 2);
        BREAK_GETBITS_REQD_MISSING(getbits, ret);
        vidObjPlane->vop_coding_type = code & 0x3;
        if( mp4_pvt_extract_modulotimebase_from_VideoObjectPlane(parent,
                                                                 &(vidObjPlane->modulo_time_base)) == MP4_STATUS_REQD_DATA_ERROR)
        {
            break;
        }

        getbits = viddec_pm_get_bits(parent, &code, 1);
        /* TODO: check for marker bit validity */
        {
            uint32_t numbits=0;
            numbits = vidObjLay->vop_time_increment_resolution_bits;
            if(numbits == 0) numbits=1; /*TODO:check if its greater than 16 bits ?? */
            getbits = viddec_pm_get_bits(parent, &code, numbits);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            vidObjPlane->vop_time_increment = code;
        }

        getbits = viddec_pm_get_bits(parent, &code, 2);
        BREAK_GETBITS_REQD_MISSING(getbits, ret);

        vidObjPlane->vop_coded = code & 0x1;
        if(vidObjPlane->vop_coded == 0)
        {
            ret = MP4_STATUS_OK;/* Exit point 1 */
            break;
        }

        if(vidObjLay->newpred_enable)
        {
            /* New pred mode not supported in HW */
            DEB("Error: mp4_Parse_VideoObjectPlane: New pred in vidObjPlane is not supported\n");
            ret = MP4_STATUS_NOTSUPPORT;
            break;
        }

        if ((vidObjLay->video_object_layer_shape != MP4_SHAPE_TYPE_BINARYONLY) &&
            ((vidObjPlane->vop_coding_type == MP4_VOP_TYPE_P) ||
             ((vidObjPlane->vop_coding_type == MP4_VOP_TYPE_S) &&
              (vidObjLay->sprite_enable == MP4_SPRITE_GMC))))
        {
            getbits = viddec_pm_get_bits(parent, &code, 1);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            vidObjPlane->vop_rounding_type = code;
        }

        if (vidObjLay->reduced_resolution_vop_enable &&
            (vidObjLay->video_object_layer_shape == MP4_SHAPE_TYPE_RECTANGULAR) &&
            ((vidObjPlane->vop_coding_type == MP4_VOP_TYPE_I) ||
             (vidObjPlane->vop_coding_type == MP4_VOP_TYPE_P)))
        {
            getbits = viddec_pm_get_bits(parent, &code, 1);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            vidObjPlane->vop_reduced_resolution = code;
            if (vidObjPlane->vop_reduced_resolution)
            {
                DEB("Error: mp4_Parse_VideoObjectPlane: Reduced Resolution vidObjPlane is not supported\n");
                ret = MP4_STATUS_NOTSUPPORT;
                break;
            }
        }

        if (vidObjLay->video_object_layer_shape != MP4_SHAPE_TYPE_RECTANGULAR)
        {
            /* we support only rectangular shapes so the following logic is not required */
            ret = MP4_STATUS_NOTSUPPORT;
            break; 
        }

        if ((vidObjLay->video_object_layer_shape != MP4_SHAPE_TYPE_BINARYONLY) &&
            (!vidObjLay->complexity_estimation_disable))
        {
            /* Not required according to DE team */
            //read_vop_complexity_estimation_header(); 
            ret = MP4_STATUS_NOTSUPPORT;
            break;
        }

        if (vidObjLay->video_object_layer_shape != MP4_SHAPE_TYPE_BINARYONLY)
        {
            getbits = viddec_pm_get_bits(parent, &code, 3);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            vidObjPlane->intra_dc_vlc_thr = code;
            if (vidObjLay->interlaced)
            {
                getbits = viddec_pm_get_bits(parent, &code, 2);
                BREAK_GETBITS_REQD_MISSING(getbits, ret);
                vidObjPlane->top_field_first = ((code & 0x2) > 0);
                vidObjPlane->alternate_vertical_scan_flag = code & 0x1;
            }
        }
    
        if (((vidObjLay->sprite_enable == MP4_SPRITE_STATIC) || (vidObjLay->sprite_enable == MP4_SPRITE_GMC)) &&
            (vidObjPlane->vop_coding_type == MP4_VOP_TYPE_S))
        {
            if (vidObjLay->sprite_info.no_of_sprite_warping_points > 0){
                if (mp4_Sprite_Trajectory(parent, vidObjLay, vidObjPlane) != MP4_STATUS_OK){
                    break;
                }
            }
            vidObjPlane->brightness_change_factor = 0;
            if (vidObjLay->sprite_info.sprite_brightness_change)
            {
                int32_t change=0;
                if(mp4_brightness_change(parent, &change) == MP4_STATUS_PARSE_ERROR)
                {
                    break;
                }
                vidObjPlane->brightness_change_factor = change;
            }

            if (vidObjLay->sprite_enable == MP4_SPRITE_STATIC)
            {
                /* SGA: IS decode sprite not required. Is static even supported */
                ret = MP4_STATUS_OK;/* Exit point 2 */
                break;
            }
        }

        if (vidObjLay->video_object_layer_shape != MP4_SHAPE_TYPE_BINARYONLY)
        {
            // Length of vop_quant is specified by quant_precision
            getbits = viddec_pm_get_bits(parent, &code, vidObjLay->quant_precision);
            BREAK_GETBITS_REQD_MISSING(getbits, ret);
            vidObjPlane->vop_quant = code;
            if (vidObjLay->video_object_layer_shape == MP4_SHAPE_TYPE_GRAYSCALE)
            {
                ret = MP4_STATUS_NOTSUPPORT;
                break;
            }
            if (vidObjPlane->vop_coding_type != MP4_VOP_TYPE_I)
            {
                vidObjPlane->vop_fcode_forward = 0;
                getbits = viddec_pm_get_bits(parent, &code, 3);
                BREAK_GETBITS_REQD_MISSING(getbits, ret);
                vidObjPlane->vop_fcode_forward = code & 0x7;
                if (vidObjPlane->vop_fcode_forward == 0)
                {
                    DEB("Error: vop_fcode_forward == 0\n");
                    break;
                }
            }
            if (vidObjPlane->vop_coding_type == MP4_VOP_TYPE_B)
            {
                vidObjPlane->vop_fcode_backward = 0;
                getbits = viddec_pm_get_bits(parent, &code, 3);
                BREAK_GETBITS_REQD_MISSING(getbits, ret);
                vidObjPlane->vop_fcode_backward = code &0x7;
                if (vidObjPlane->vop_fcode_backward == 0)
                {
                    DEB("Error: vop_fcode_backward == 0\n");
                    break;
                }
            }
            if (!vidObjLay->scalability)
            {
                if ((vidObjLay->video_object_layer_shape != MP4_SHAPE_TYPE_RECTANGULAR) &&
                    (vidObjPlane->vop_coding_type != MP4_VOP_TYPE_I))
                {
                    ret = MP4_STATUS_NOTSUPPORT;
                    break;
                }
                // The remaining data contains the macroblock information that is handled by the BSP
                // The offsets to be sent to the BSP are obtained in the workload population
            }
            else
            {
                ret = MP4_STATUS_NOTSUPPORT;
                break;
            }
        }
        else
        {/* Binary Not supported */
            ret = MP4_STATUS_NOTSUPPORT;
            break;
        }
        /* Since we made it all the way here it a success condition */
        ret = MP4_STATUS_OK;  /* Exit point 3 */
    }while(0);

    mp4_set_hdr_bitstream_error(parser, false, ret);

    return ret;
} // mp4_Parse_VideoObjectPlane