mp4dpars.c

Linux下的基于intel的ipp库的MPEG4解码程序源码

//                    and VOL header is decoded 
//      dec_state   - Pointer to the updated general state structure of MPEG-4
//                    decoder
//
//  Returns:    
//      SAMPLE_STATUS_NOERR             If succeeds
//      SAMPLE_STATUS_ERR               If stream parsing error occurs
//      SAMPLE_STATUS_SYNCNOTFOUND_ERR  If cannot find sync code
//      SAMPLE_STATUS_NOTSUPPORTED_ERR  If stream syntax is not supported by
//                                      current sample decoder
******************************************************************************/
sample_status parse_voandvol_header_mpeg4
(sample_bitstream  *stream_buf, mp4_dec_state *dec_state)
{
    Ipp8u   *buf_border = stream_buf->bs_buffer + stream_buf->bs_bytelen;
    Ipp32u  code = 0;
    int     i, j;
    
    /* read 32 bit video_object_start_code / 22 bit picture_start_code
    // sync code */
    code = get_bits_mpeg4(stream_buf, 32);

    /* loop to find video_object_start_code / picture_start_code sync code */
    while ((MPEG4_VOSC != (code & 0xFFFFFFE0)) && (MPEG4_H263_PSC
        != (code >> 10)) && (stream_buf->bs_cur_byte < buf_border)) {
        code = (code << 8) | get_bits_mpeg4(stream_buf, 8); 
    }

    /* short header */
    if (MPEG4_H263_PSC == (code >> 10)) {
        dec_state->short_head = 1;
        stream_buf->bs_cur_byte -= 4;
        return  SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }
    /* sync code not found */
    else if (MPEG4_VOSC != (code & 0xFFFFFFE0)) {
        printf ("Error: Not find visual object sync code!\n");
        return SAMPLE_STATUS_SYNCNOTFOUND_ERR;
    }

    dec_state->short_head = 0;

    /* read 32 bit video_object_layer_start_code sync code */
    code = get_bits_mpeg4(stream_buf, 32);
    if (MPEG4_VOLSC != (code & 0xFFFFFFF0)) {
        printf ("Error: Not find video object layer sync code!\n");
        return SAMPLE_STATUS_SYNCNOTFOUND_ERR;
    }    
    
    /* 1 bit random_accessible_vol */
    code = get_bits_mpeg4(stream_buf, 1);
    /* 8 bit video_object_type_indication */
    dec_state->vol_typeid = (int)get_bits_mpeg4(stream_buf, 8);
    /* 1 bit is_object_layer_identifier */
    code = get_bits_mpeg4(stream_buf, 1);
    if (code) {
        /* 4 bit video_object_layer_verid */
        dec_state->vol_verid = (int)get_bits_mpeg4(stream_buf, 4);
        /* 3 bit video_object_layer_priority */
        dec_state->vol_prior = (int)get_bits_mpeg4(stream_buf, 3);
    }
    else {
        dec_state->vol_verid = 1;
    }

    /* 4 bit aspect_ratio_info */
    code = get_bits_mpeg4(stream_buf, 4);
    /* aspect_ratio_info == "extended PAR" */
    if (15 == code) {
        /* 8 bit par_width */
        code = get_bits_mpeg4(stream_buf, 8);
        /* 8 bit par_height */
        code = get_bits_mpeg4(stream_buf, 8);
    }

    /* 1 bit vol_control_parameters */
    dec_state->vol_control_para = get_bits_mpeg4(stream_buf, 1);
    if (dec_state->vol_control_para) {
        /* 2 bit chroma_format */
        dec_state->chroma_fmt = get_bits_mpeg4(stream_buf, 2);
        /* chroma_format != YUV 4:2:0 */
        if (1 != dec_state->chroma_fmt) {
            return SAMPLE_STATUS_NOTSUPPORTED_ERR;
        }

        /* 1 bit low_delay */
        dec_state->low_delay = get_bits_mpeg4(stream_buf, 1);

        /* 1 bit vbv_parameters */
        code = get_bits_mpeg4(stream_buf, 1);
        if (code) {
            /* 15 bit first_half_bit_rate */
            dec_state->bit_rate = get_bits_mpeg4(stream_buf, 15);
            /* marker bit */
            ASSERT_MARKER_BIT(stream_buf);
            /* 15 bit latter_half_bit_rate */
            code = get_bits_mpeg4(stream_buf, 15);
            /* marker bit */
            ASSERT_MARKER_BIT(stream_buf);
            dec_state->bit_rate = (dec_state->bit_rate << 15) + code;
            if (0 == dec_state->bit_rate) {
                return SAMPLE_STATUS_ERR;
            }
            
            /* 15 bit first_half_vbv_buffer_size */
            dec_state->vbv_buf_size = get_bits_mpeg4(stream_buf, 15);
            /* marker bit */
            ASSERT_MARKER_BIT(stream_buf);
            /* 3 bit latter_half_vbv_buffer_size */
            code = get_bits_mpeg4(stream_buf, 3);
            dec_state->vbv_buf_size = (dec_state->vbv_buf_size << 3)
                + code;
            if (0 == dec_state->vbv_buf_size) {
                return SAMPLE_STATUS_ERR;
            }

            /* 11 bit first_half_vbv_occupancy */
            dec_state->vbv_occupancy = get_bits_mpeg4(stream_buf, 11);
            /* marker bit */
            ASSERT_MARKER_BIT(stream_buf);
            /* 15 bit latter_half_vbv_occupancy */
            code = get_bits_mpeg4(stream_buf, 15);
            /* marker bit */
            ASSERT_MARKER_BIT(stream_buf);
            dec_state->vbv_occupancy = (dec_state->vbv_occupancy << 15)
                + code;
        }
    }
    
    /* 2 bit video_object_layer_shape */
    dec_state->vol_shape_type = get_bits_mpeg4(stream_buf, 2);
    /* video_object_layer_shape != "rectangular" */
    if (RECTANGULAR != dec_state->vol_shape_type) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    /* marker bit */
    ASSERT_MARKER_BIT(stream_buf);
    /* 16 bit vop_time_increment_resolution */
    dec_state->clock_rate = get_bits_mpeg4(stream_buf, 16);
    dec_state->numbits_time_incr = 1;
    code = dec_state->clock_rate;
    if (1 < code) {
        code -= 1;
        while (1 < code) {
            code = code >> 1;
            dec_state->numbits_time_incr++;
        }
    }

    /* marker bit */
    ASSERT_MARKER_BIT(stream_buf);
    /* 1 bit fixed_vop_rate */
    dec_state->fix_vop_rate = get_bits_mpeg4(stream_buf, 1);

    if (dec_state->fix_vop_rate) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }


    /* marker bit */
    ASSERT_MARKER_BIT(stream_buf);
    /* 13 bit video_object_layer_width */
    dec_state->vol_display_width = get_bits_mpeg4(stream_buf,
        MPEG4_NUMBITS_VOP_WIDTH); 
    /* marker bit */
    ASSERT_MARKER_BIT(stream_buf);
    /* 13 bit video_object_layer_height */
    dec_state->vol_display_height = get_bits_mpeg4(stream_buf,
        MPEG4_NUMBITS_VOP_HEIGHT);
    /* marker bit */
    ASSERT_MARKER_BIT(stream_buf);

    /* 1 bit interlaced */
    dec_state->interlaced = get_bits_mpeg4(stream_buf, 1);
    if (1 == dec_state->interlaced) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    /* 1 bit obmc_disable */
    dec_state->obmc_disabled = get_bits_mpeg4(stream_buf, 1);
    if (0 == dec_state->obmc_disabled) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }


    /* 1 or 2 bit sprite_enable */
    if(1 == dec_state->vol_verid) {
        dec_state->sprite_type = get_bits_mpeg4(stream_buf, 1);
    } else {
        dec_state->sprite_type = get_bits_mpeg4(stream_buf, 2);
    }

    if (dec_state->sprite_type != 0) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    /* sadct_disable */
    dec_state->sadct_disabled = TRUE;
    
    /* 1 bit not_8_bit */
    code = get_bits_mpeg4(stream_buf, 1);
    if (1 == code) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    /* 1 bit quant_type */
    dec_state->quant_type = get_bits_mpeg4(stream_buf, 1);
    if (Q_MPEG4 == dec_state->quant_type) {
        /* 1 bit load_intra_quant_mat */
        code = get_bits_mpeg4(stream_buf, 1);
        if (code) {
            /* intra_quant_mat: 8*[2-64] bits */
            for (i = 0; i < SAMPLE_VIDEO_BLOCK_SQUARE_SIZE; i++) {
                code = get_bits_mpeg4(stream_buf, MPEG4_NUMBITS_QMATRIX);
                if (0 != code) {
                    dec_state->qmatrix_intra_tbl[classic_zigzag_tbl[i]]
                        = (Ipp8u)code;
                } else {
                    break;
                }
            }           
            for (j = i; j < SAMPLE_VIDEO_BLOCK_SQUARE_SIZE; j++) {
                dec_state->qmatrix_intra_tbl[classic_zigzag_tbl[j]] = 
                    dec_state->qmatrix_intra_tbl[classic_zigzag_tbl[i-1]];
            }
            dec_state->qmatrix_intra = dec_state->qmatrix_intra_tbl;
        } else {
            dec_state->qmatrix_intra = default_qmat_intra_tbl;
        }

        /* 1 bit load_nonintra_quant_mat */
        code = get_bits_mpeg4(stream_buf, 1);
        if (code) {
            /* nonintra_quant_mat: 8*[2-64] bits */
            for (i = 0; i < SAMPLE_VIDEO_BLOCK_SQUARE_SIZE; i++) {
                code = get_bits_mpeg4(stream_buf, MPEG4_NUMBITS_QMATRIX);
                if (0 != code) {
                    dec_state->qmatrix_inter_tbl[classic_zigzag_tbl[i]]
                        = (Ipp8u)code;
                } else {
                    break;
                }
            }
            for (j = i; j < SAMPLE_VIDEO_BLOCK_SQUARE_SIZE; j++) {
                dec_state->qmatrix_inter_tbl[classic_zigzag_tbl[j]] = 
                    dec_state->qmatrix_inter_tbl[classic_zigzag_tbl[i-1]];
            }
            dec_state->qmatrix_inter = dec_state->qmatrix_inter_tbl;
        } else {
            dec_state->qmatrix_inter = default_qmat_inter_tbl;
        }
    } else {
        dec_state->qmatrix_intra = NULL;
        dec_state->qmatrix_inter = NULL;
    }

    /* 1 bit quarter_sample */
    if (1 != dec_state->vol_verid) {
        dec_state->quater_sample = get_bits_mpeg4(stream_buf, 1);
    } else {
        dec_state->quater_sample = 0;
    }

    /* 1 bit complexity_estimation_disable */
    dec_state->complex_est_disable = get_bits_mpeg4(stream_buf, 1);
    if (0 == dec_state->complex_est_disable) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    /* 1 bit resync_marker_disable */
    dec_state->resync_disabled = get_bits_mpeg4(stream_buf, 1);
    if (0 == dec_state->resync_disabled) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    /* 1 bit data_partitioned */
    dec_state->data_patitioned = get_bits_mpeg4(stream_buf, 1);
    if (1 == dec_state->data_patitioned) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    if (1 != dec_state->vol_verid) {
        /* 1 bit newpred_enable */
        dec_state->new_pred = get_bits_mpeg4(stream_buf, 1);
        if (dec_state->new_pred) {
            return SAMPLE_STATUS_NOTSUPPORTED_ERR;
        }
        /* 1 bit reduced_resolution_vop_enable */
        dec_state->reduced_resolution = get_bits_mpeg4(stream_buf, 1);
        if (dec_state->reduced_resolution) {
            return SAMPLE_STATUS_NOTSUPPORTED_ERR;
        }
    } else {
        dec_state->new_pred = 0;
        dec_state->reduced_resolution = 0;
    }
    
    /* 1 bit scalability */
    dec_state->scalable = get_bits_mpeg4(stream_buf, 1);
    if (dec_state->scalable) {
        return SAMPLE_STATUS_NOTSUPPORTED_ERR;
    }

    return SAMPLE_STATUS_NOERR;
}