xref: /hardware/intel/common/libmix/mix_vbp/viddec_fw/fw/codecs/mp2/parser/viddec_mpeg2_parse.c

/**
 * viddec_mpeg2_parse.c
 * --------------------
 * This file acts as the main interface between the parser manager and MPEG2
 * parser. All the operations done by the MPEG2 parser are defined here and
 * functions pointers for each operation is returned to the parser manager.
 */

#include "viddec_mpeg2.h"

/* viddec_mpeg2_parser_init() - Initializes parser context. */
static void viddec_mpeg2_parser_init
(
    void        *ctxt,
    uint32_t    *persist_mem,
    uint32_t     preserve
)
{
    struct viddec_mpeg2_parser *parser = (struct viddec_mpeg2_parser *) ctxt;

    /* Avoid compiler warning */
    persist_mem = persist_mem;

    /* Initialize state variables */
    parser->mpeg2_pic_metadata_complete         =  false;
    parser->mpeg2_picture_interlaced            =  false;
    parser->mpeg2_first_field                   =  false;
    parser->mpeg2_frame_start                   =  false;
    parser->mpeg2_ref_table_updated             =  false;
    parser->mpeg2_use_next_workload             =  false;
    parser->mpeg2_first_slice_flag              =  false;
    parser->mpeg2_curr_frame_headers            =  MPEG2_HEADER_NONE;
    parser->mpeg2_last_parsed_sc                =  MPEG2_SC_ALL;
    parser->mpeg2_last_parsed_slice_sc          =  MPEG2_SC_SLICE_MAX;
    parser->mpeg2_wl_status                     =  MPEG2_WL_EMPTY;
    parser->mpeg2_prev_picture_structure        =  MPEG2_PIC_STRUCT_FRAME;
    parser->mpeg2_prev_temp_ref                 =  0;
    parser->mpeg2_num_pan_scan_offsets          =  0;

    if(preserve)
    {
    	/* Init all picture level header info */
    	memset(&parser->info.pic_hdr, 0, sizeof(struct mpeg2_picture_hdr_info));
    	memset(&parser->info.pic_cod_ext, 0, sizeof(struct mpeg2_picture_coding_ext_info));
    	memset(&parser->info.pic_disp_ext, 0, sizeof(struct mpeg2_picture_disp_ext_info));
    }
    else
    {
    	/* Init all header info */
    	memset(&parser->info, 0, sizeof(struct mpeg2_info));

    	parser->mpeg2_stream                        =  false;
    	parser->mpeg2_custom_qmat_parsed            =  false;
    	parser->mpeg2_valid_seq_hdr_parsed          =  false;
    	parser->mpeg2_curr_seq_headers              =  MPEG2_HEADER_NONE;
	}

    MPEG2_DEB("MPEG2 Parser: Context Initialized.\n");

    return;
}

/* viddec_mpeg2_get_context_size() - Returns the memory size required by the */
/* MPEG2 parser. */
static void viddec_mpeg2_get_context_size
(
    viddec_parser_memory_sizes_t    *size
)
{
    /* Should return size of my structure */
    size->context_size = sizeof(struct viddec_mpeg2_parser);
    size->persist_size = 0;
}

/* viddec_mpeg2_get_error_code() - Returns the error code for the current */
/* workload. */
static void viddec_mpeg2_get_error_code
(
    struct viddec_mpeg2_parser  *parser,
    viddec_workload_t           *wl,
    uint32_t                    *error_code
)
{
    *error_code = 0;

    /* Dangling field error */
    if (parser->mpeg2_wl_status & MPEG2_WL_DANGLING_FIELD)
    {
        *error_code |= VIDDEC_FW_WORKLOAD_ERR_DANGLING_FLD;
        if (parser->mpeg2_wl_status & MPEG2_WL_DANGLING_FIELD_TOP)
        {
            *error_code |= VIDDEC_FW_WORKLOAD_ERR_TOPFIELD;
        }
        else
        {
            *error_code |= VIDDEC_FW_WORKLOAD_ERR_BOTTOMFIELD;
        }
    }

    /* Repeated same field */
    if (parser->mpeg2_wl_status & MPEG2_WL_REPEAT_FIELD)
    {
        *error_code |= (VIDDEC_FW_WORKLOAD_ERR_DANGLING_FLD
                        | VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE);
    }

    /* If workload is not complete, set non-decodeable flag */
    if (!(parser->mpeg2_wl_status & MPEG2_WL_COMPLETE))
    {
        *error_code |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
    }

    /* If reference info is not updated, set missing reference flag */
    if (!(parser->mpeg2_wl_status & MPEG2_WL_REF_INFO))
    {
        *error_code |= VIDDEC_FW_WORKLOAD_ERR_MISSING_REFERENCE;
    }

    /* Missing DMEM data flag and irrecoverable flag is set */
    if (!(parser->mpeg2_wl_status & MPEG2_WL_DMEM_DATA))
    {
        *error_code |= ( VIDDEC_FW_WORKLOAD_ERR_MISSING_DMEM
                         | VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE ) ;
    }

    /* Missing sequence header and irrecoverable flag is set */
    if ((!(parser->mpeg2_curr_seq_headers & MPEG2_HEADER_SEQ))
    		&& (!parser->mpeg2_valid_seq_hdr_parsed))
    {
        *error_code |= ( VIDDEC_FW_WORKLOAD_ERR_MISSING_SEQ_INFO
                         | VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE ) ;
    }

    /* Unsupported features found in stream */
    if (parser->mpeg2_wl_status & MPEG2_WL_UNSUPPORTED)
    {
        *error_code |= ( VIDDEC_FW_WORKLOAD_ERR_UNSUPPORTED
                         | VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE ) ;
    }

    /* If frame type is unknown, default to I frame. */
    if ((wl->attrs.frame_type != VIDDEC_FRAME_TYPE_I)
            && (wl->attrs.frame_type != VIDDEC_FRAME_TYPE_P)
            && (wl->attrs.frame_type != VIDDEC_FRAME_TYPE_B))
    {
        wl->attrs.frame_type = VIDDEC_FRAME_TYPE_I;
    }

    /* If there is a mismatch between the frame type and reference information */
    /* then mark the workload as not decodable */
    if (wl->attrs.frame_type == VIDDEC_FRAME_TYPE_B)
    {
        if (wl->is_reference_frame != 0) *error_code |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
    }
    else
    {
        if (wl->is_reference_frame == 0) *error_code |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
    }

    /* For non-decodable frames, do not set reference info so that the workload */
    /* manager does not increment ref count. */
    if (*error_code & VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE)
    {
        wl->is_reference_frame = 0;
    }

    /* Corrupted header notification */
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_SEQ_HDR)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_SEQ_HDR;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_SEQ_EXT)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_SEQ_EXT;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_SEQ_DISP_EXT)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_SEQ_DISP_EXT;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_GOP_HDR)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_GOP_HDR;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_PIC_HDR)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_PIC_HDR;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_PIC_COD_EXT)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_PIC_COD_EXT;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_PIC_DISP_EXT)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_PIC_DISP_EXT;
    if (parser->mpeg2_wl_status & MPEG2_WL_CORRUPTED_QMAT_EXT)
        *error_code |= VIDDEC_FW_MPEG2_ERR_CORRUPTED_QMAT_EXT;

    MPEG2_DEB("Workload error code: 0x%8X.\n", *error_code);
    return;
}

/* viddec_mpeg2_is_start_frame() - Returns if the current chunk of parsed */
/* data has start of a frame. */
static uint32_t viddec_mpeg2_is_start_frame
(
    void    *ctxt
)
{
    struct viddec_mpeg2_parser *parser = (struct viddec_mpeg2_parser *) ctxt;
    return (parser->mpeg2_frame_start);
}

/* viddec_mpeg2_is_workload_done() - Returns current frame parsing status */
/* to the parser manager. */
static uint32_t viddec_mpeg2_is_workload_done
(
    void            *parent,
    void            *ctxt,
    unsigned int    next_sc,
    uint32_t        *codec_specific_errors
)
{
    struct viddec_mpeg2_parser *parser = (struct viddec_mpeg2_parser *) ctxt;
    viddec_workload_t *wl = viddec_pm_get_header(parent);
    uint32_t ret = VIDDEC_PARSE_SUCESS;
    uint32_t frame_boundary = 0;
	uint8_t force_frame_complete = 0;
    parent = parent;

    /* Detect Frame Boundary */
    frame_boundary = ((MPEG2_SC_PICTURE == next_sc) || (MPEG2_SC_SEQ_HDR == next_sc) || (MPEG2_SC_GROUP == next_sc));
    if (frame_boundary)
    {
        parser->mpeg2_first_slice_flag = false;
    }

	force_frame_complete = ((VIDDEC_PARSE_EOS == next_sc) || (VIDDEC_PARSE_DISCONTINUITY == next_sc));

    if (force_frame_complete || (frame_boundary && (parser->mpeg2_pic_metadata_complete)))
    {
		if(!force_frame_complete)
        {
            parser->mpeg2_wl_status            |= MPEG2_WL_COMPLETE;
            parser->mpeg2_last_parsed_slice_sc  =  MPEG2_SC_SLICE_MAX;
            parser->mpeg2_pic_metadata_complete = false;
            parser->mpeg2_first_slice_flag = false;
        }

        viddec_mpeg2_get_error_code(parser, wl, codec_specific_errors);
        parser->mpeg2_wl_status          = MPEG2_WL_EMPTY;
        parser->mpeg2_curr_frame_headers = MPEG2_HEADER_NONE;
        /* Reset mpeg2_use_next_workload flag if it is set */
        if (parser->mpeg2_use_next_workload)
        {
            viddec_pm_set_late_frame_detect(parent);
            parser->mpeg2_use_next_workload  = false;
        }
        ret = VIDDEC_PARSE_FRMDONE;
    }
    return ret;
}

/* viddec_mpeg2_parse() - Parse metadata info from the buffer for the prev */
/* start code found. */
static mpeg2_status viddec_mpeg2_parse
(
    void    *parent,
    void    *ctxt
)
{
    uint32_t current_sc = 0, sc_bits = MPEG2_SC_AND_PREFIX_SIZE;
    int32_t  ret = MPEG2_SUCCESS;
    struct viddec_mpeg2_parser *parser = (struct viddec_mpeg2_parser *) ctxt;

    /* Reset frame start flag. For Mpeg1 we want to set frame start after
     we parsed pich header, since there is no extension*/
    parser->mpeg2_frame_start =  (!parser->mpeg2_stream) && (parser->mpeg2_last_parsed_sc == MPEG2_SC_PICTURE);

    /* Peak current start code - First 32 bits of the stream */
    ret = viddec_pm_peek_bits(parent, &current_sc, sc_bits);
    if (ret == -1)
    {
        MPEG2_DEB("Unable to get start code.\n");
        return MPEG2_PARSE_ERROR;
    }
    current_sc &= MPEG2_BIT_MASK_8;
    MPEG2_DEB("Start Code found = 0x%.8X\n", current_sc);

    /* Get rid of the start code prefix for all start codes except slice */
    /* start codes. */
    if ((current_sc < MPEG2_SC_SLICE_MIN) || (current_sc > MPEG2_SC_SLICE_MAX))
    {
        viddec_pm_skip_bits(parent, sc_bits);
    }

    /* Parse Metadata based on the start code found */
    switch( current_sc )
    {
        /* Sequence Start Code */
        case MPEG2_SC_SEQ_HDR:
        {
            parser->mpeg2_curr_seq_headers = MPEG2_HEADER_NONE;
            viddec_mpeg2_parse_seq_hdr(parent, ctxt);
        }
        break;

        /* Picture Start Code */
        case MPEG2_SC_PICTURE:
        {
            viddec_mpeg2_parse_pic_hdr(parent, ctxt);
        }
        break;

        /* Extension Code */
        case MPEG2_SC_EXT:
        {
            viddec_mpeg2_parse_ext(parent, ctxt);
        }
        break;

        /* Group of Pictures Header */
        case MPEG2_SC_GROUP:
        {
            viddec_mpeg2_parse_gop_hdr(parent, ctxt);
        }
        break;

        /* Unused Start Code */
        case MPEG2_SC_SEQ_END:
        case MPEG2_SC_SEQ_ERR:
            break;

        /* User Data */
        case MPEG2_SC_USER_DATA:
        {
            viddec_mpeg2_parse_and_append_user_data(parent, ctxt);
        }
        break;

        default:
        {
            /* Slice Data - Append slice data to the workload */
            if ((current_sc >= MPEG2_SC_SLICE_MIN) &&
                (current_sc <= MPEG2_SC_SLICE_MAX))
            {
                if (!parser->mpeg2_first_slice_flag)
                {
                    /* At this point, all the metadata required by the MPEG2 */
                    /* hardware for decoding is extracted and stored. So the */
                    /* metadata can be packed into workitems and emitted out.*/
                    viddec_mpeg2_emit_workload(parent, ctxt);

                    /* If the current picture is progressive or it is the */
                    /* second field of interlaced field picture then, set */
                    /* the workload done flag. */
                    if ((!parser->mpeg2_picture_interlaced)
                        || ((parser->mpeg2_picture_interlaced) && (!parser->mpeg2_first_field)))
                    {
                        parser->mpeg2_pic_metadata_complete = true;
                    }
                    else if ((parser->mpeg2_picture_interlaced) && (parser->mpeg2_first_field))
                    {
                        parser->mpeg2_curr_frame_headers = MPEG2_HEADER_NONE;
                    }

                    parser->mpeg2_first_slice_flag = true;
                }
                parser->mpeg2_last_parsed_slice_sc = current_sc;
                viddec_mpeg2_parse_and_append_slice_data(parent, ctxt);
                parser->mpeg2_wl_status |= MPEG2_WL_PARTIAL_SLICE;
            }
        }
    } /* Switch */

    /* Save last parsed start code */
    parser->mpeg2_last_parsed_sc = current_sc;
    return ret;
}

/* viddec_mpeg2_get_ops() - Register parser ops with the parser manager. */
void viddec_mpeg2_get_ops
(
    viddec_parser_ops_t     *ops
)
{
    ops->init         = viddec_mpeg2_parser_init;
    ops->parse_syntax = viddec_mpeg2_parse;
    ops->get_cxt_size = viddec_mpeg2_get_context_size;
    ops->is_wkld_done = viddec_mpeg2_is_workload_done;
    ops->is_frame_start = viddec_mpeg2_is_start_frame;
    return;
}