umc_h264_au_stream.cpp

audio-video-codecs.rar语音编解码器

        if( profile_idc == 100 || profile_idc == 110
            || profile_idc == 122 || profile_idc == 144){
            Ipp32u chroma_format_idc = 0;
            GO_OR_QUIT( ReadUE( chroma_format_idc ));
            if( chroma_format_idc == 3 ){
                GO_OR_QUIT( ReadU(1, iValue) );
            }
            GO_OR_QUIT( ReadUE(iValue) );
            GO_OR_QUIT( ReadUE(iValue) );
            GO_OR_QUIT( ReadU(1, iValue) );

            Ipp32u seq_scaling_matrix_present_flag = 0;
            GO_OR_QUIT( ReadU(1, seq_scaling_matrix_present_flag) );
            if(seq_scaling_matrix_present_flag){
                for (Ipp32s i=0; i<8; i++) {
                    Ipp32u seq_scaling_matrix_present_flag_i = 0;
                    GO_OR_QUIT( ReadU(1, seq_scaling_matrix_present_flag_i) );
                    if(seq_scaling_matrix_present_flag_i){
                        if( i < 6){
                            GO_OR_QUIT_SIMPLE ( Read_scaling_list(p_reader , 16 ) );
                        } else {
                            GO_OR_QUIT_SIMPLE ( Read_scaling_list(p_reader , 64 ) );
                        }
                    }
                }
            }
        }

        GO_OR_QUIT( ReadUE(p_SequenceSet.log2_max_frame_num_minus4) );
        GO_OR_QUIT( ReadUE(p_SequenceSet.pic_order_cnt_type) );
        if( p_SequenceSet.pic_order_cnt_type == 0 ){
            GO_OR_QUIT( ReadUE(p_SequenceSet.log2_max_pic_order_cnt_lsb_minus4) );
        } else if( p_SequenceSet.pic_order_cnt_type == 1 ) {
            GO_OR_QUIT( ReadU( 1, p_SequenceSet.delta_pic_order_always_zero_flag) );
            GO_OR_QUIT( ReadSE(siValue) );
            GO_OR_QUIT( ReadSE(siValue) );
            Ipp32u num_ref_frames_in_pic_order_cnt_cycle = 0;
            GO_OR_QUIT( ReadUE(num_ref_frames_in_pic_order_cnt_cycle) );
            for (Ipp32u i=0; i<num_ref_frames_in_pic_order_cnt_cycle; i++)
            {
                GO_OR_QUIT( ReadSE(siValue) );
            }
        }
        GO_OR_QUIT( ReadUE(iValue) );
        GO_OR_QUIT( ReadU(1, iValue) );
        GO_OR_QUIT( ReadUE(p_SequenceSet.pic_width_in_mbs_minus1) );
        GO_OR_QUIT( ReadUE(p_SequenceSet.pic_height_in_map_units_minus1) );

        GO_OR_QUIT( ReadU(1, p_SequenceSet.frame_mbs_only_flag) );
        if( !p_SequenceSet.frame_mbs_only_flag){
            GO_OR_QUIT( ReadU(1, iValue) );
        }
        GO_OR_QUIT( ReadU(1, iValue) );
        GO_OR_QUIT( ReadU(1, p_SequenceSet.frame_cropping_flag) );
        if(p_SequenceSet.frame_cropping_flag){
            GO_OR_QUIT( ReadUE(p_SequenceSet.frame_crop_left_offset) );
            GO_OR_QUIT( ReadUE(p_SequenceSet.frame_crop_right_offset) );
            GO_OR_QUIT( ReadUE(p_SequenceSet.frame_crop_top_offset) );
            GO_OR_QUIT( ReadUE(p_SequenceSet.frame_crop_bottom_offset) );
        }

        /// No need to parse further -- Skipping

        return UMC_OK;
    }

    Status H264_AU_Stream::Read_scaling_list(H264_SyntaxReader & p_reader, Ipp32u p_iSizeOfScalingList)
    {
        Ipp32s lastScale = 8,
               nextScale = 8;
        for(Ipp32u j=0; j<p_iSizeOfScalingList; j++){
            if( nextScale != 0 ){
                Ipp32s delta_scale = 0;
                GO_OR_QUIT( ReadSE(delta_scale) );
                nextScale = (lastScale + delta_scale + 256 ) % 256;
            }
            Ipp32s n_lastScale = ( nextScale == 0 ) ? lastScale : nextScale;
            lastScale = n_lastScale;
        }
        return UMC_OK;
    }

    Status H264_AU_Stream::Read_pic_parameter_set_rbsp(H264PictureSetParse & p_PictureSet, H264_SyntaxReader & p_reader)
    {
        Ipp32u iValue = 0;
        GO_OR_QUIT( ReadUE(p_PictureSet.pic_parameter_set_id) );
        GO_OR_QUIT( ReadUE(p_PictureSet.seq_parameter_set_id) );
        GO_OR_QUIT( ReadU(1, iValue) );
        GO_OR_QUIT( ReadU(1, p_PictureSet.pic_order_present_flag) );

        /// No need to parse further -- Skipping

        return UMC_OK;
    }

    Status H264_AU_Stream::Read_slice_header(H264SliceHeaderParse & p_SliceHeader, H264_SyntaxReader & p_reader,
                                             H264SequenceSetParse * & o_pSeqSet)
    {
        GO_OR_QUIT( ReadUE( p_SliceHeader.first_mb_in_slice) );
        GO_OR_QUIT( ReadUE( p_SliceHeader.slice_type) );
        GO_OR_QUIT( ReadUE( p_SliceHeader.pic_parameter_set_id) );

        H264SequenceSetParse * pSeqSet = 0;
        H264PictureSetParse * pPicSet = 0;
        GO_OR_QUIT_SIMPLE ( FindSets ( p_SliceHeader.pic_parameter_set_id, pSeqSet, pPicSet ) );

        Ipp32u iFNLen = (pSeqSet->log2_max_frame_num_minus4 + 4);
        GO_OR_QUIT( ReadU( iFNLen, p_SliceHeader.frame_num) );

#ifdef AU_TRACING
        printf( " frame_num=%d", p_SliceHeader.frame_num);
#endif

        if(pSeqSet->frame_mbs_only_flag == 0){
            GO_OR_QUIT( ReadU( 1, p_SliceHeader.field_pic_flag) );
            if(p_SliceHeader.field_pic_flag){
                GO_OR_QUIT( ReadU( 1, p_SliceHeader.bottom_field_flag) );
            }
        }

        if(p_SliceHeader.octet.Type == 5){
            GO_OR_QUIT( ReadUE( p_SliceHeader.idr_pic_id) );
        }
        if(pSeqSet->pic_order_cnt_type == 0){
            Ipp32u iLen = (pSeqSet->log2_max_pic_order_cnt_lsb_minus4 + 4);
            GO_OR_QUIT( ReadU( iLen, p_SliceHeader.pic_order_cnt_lsb) );
            if(pPicSet->pic_order_present_flag && !p_SliceHeader.field_pic_flag){
                GO_OR_QUIT( ReadSE( p_SliceHeader.delta_pic_order_cnt_bottom ) );
            }
        }
        if(pSeqSet->pic_order_cnt_type == 1 && !pSeqSet->delta_pic_order_always_zero_flag){
            GO_OR_QUIT( ReadSE( p_SliceHeader.delta_pic_order_cnt[0] ) );
            if(pPicSet->pic_order_present_flag && !p_SliceHeader.field_pic_flag){
                GO_OR_QUIT( ReadSE( p_SliceHeader.delta_pic_order_cnt[1] ) );
            }
        }

        /// No need to parse further -- Skipping

        o_pSeqSet = pSeqSet;

        return UMC_OK;
    }

    H264PictureSetParse * H264_AU_Stream::FindPicSet(Ipp32u p_PicSetID)
    {
        PIC_SET_MAP::iterator iter = m_mapPic.find(p_PicSetID);
        if( m_mapPic.end() == iter ){
            return 0;
        }
        return &(iter->second);
    }

    H264SequenceSetParse * H264_AU_Stream::FindSeqSet(Ipp32u p_SeqSetID)
    {
        SEQ_SET_MAP::iterator iter = m_mapSeq.find(p_SeqSetID);
        if( m_mapSeq.end() == iter ){
            return 0;
        }
        return &(iter->second);
    }

    Status H264_AU_Stream::FindSets(Ipp32u p_iPicSet, H264SequenceSetParse * & p_seq, H264PictureSetParse * & p_pic)
    {
        H264PictureSetParse * pPicSet = FindPicSet(p_iPicSet);
        if( 0 == pPicSet){
            return UMC_ERR_FAILED;
        }
        H264SequenceSetParse * pSeqSet = FindSeqSet(pPicSet->seq_parameter_set_id);
        if( 0 == pSeqSet){
            return UMC_ERR_FAILED;
        }

        p_seq = pSeqSet;
        p_pic = pPicSet;
        return UMC_OK;
    }

    Status H264_AU_Stream::GetActiveSets(MediaData & p_SequenceSet, MediaData & p_PictureSet)
    {
        H264SequenceSetParse * pSeqSet = 0;
        H264PictureSetParse * pPicSet = 0;

        Ipp32s iNum = m_iActiveUA;

        GO_OR_QUIT_SIMPLE ( FindSets ( m_au[iNum].pic_parameter_set_id, pSeqSet, pPicSet ) );

        p_SequenceSet.SetBufferPointer(&pSeqSet->buffer[0], pSeqSet->buffer.size());
        p_SequenceSet.SetDataSize(pSeqSet->buffer.size());
        p_PictureSet.SetBufferPointer(&pPicSet->buffer[0], pPicSet->buffer.size());
        p_PictureSet.SetDataSize(pPicSet->buffer.size());

        return UMC_OK;
    }

    bool H264_AU_Stream::IsPictureSame(H264SliceHeaderParse & p_newHeader)
    {
        if ((p_newHeader.frame_num != m_lastSlice.frame_num) ||
            (p_newHeader.pic_parameter_set_id != p_newHeader.pic_parameter_set_id) ||
            (p_newHeader.field_pic_flag != p_newHeader.field_pic_flag) ||
            (p_newHeader.bottom_field_flag != m_lastSlice.bottom_field_flag)
            ){
            return false;
        }

        if ((p_newHeader.octet.NRI != m_lastSlice.octet.NRI) &&
            (0 == IPP_MIN(p_newHeader.octet.NRI, m_lastSlice.octet.NRI))){
            return false;
        }

        H264SequenceSetParse * pSeqSetNew = 0;
        H264PictureSetParse * pPicSetNew = 0;
        if( UMC_OK != FindSets(p_newHeader.pic_parameter_set_id, pSeqSetNew, pPicSetNew ) ){
            return false;
        }

        H264SequenceSetParse * pSeqSetLast = 0;
        H264PictureSetParse * pPicSetLast = 0;
        if ( UMC_OK != FindSets(m_lastSlice.pic_parameter_set_id, pSeqSetLast, pPicSetLast ) ){
            return false;
        }


        if (  0 == pSeqSetLast->pic_order_cnt_type  )
        {
            if ((p_newHeader.pic_order_cnt_lsb != m_lastSlice.pic_order_cnt_lsb) ||
                (p_newHeader.delta_pic_order_cnt_bottom != m_lastSlice.delta_pic_order_cnt_bottom)){
                    return false;
            }
        }  else {
            if ((p_newHeader.delta_pic_order_cnt[0] != m_lastSlice.delta_pic_order_cnt[0]) ||
                (p_newHeader.delta_pic_order_cnt[1] != m_lastSlice.delta_pic_order_cnt[1]))
                return false;
        }

        if (p_newHeader.octet.Type != m_lastSlice.octet.Type)
        {
            if ((H264_NAL_SLICE_IDR == p_newHeader.octet.Type) ||
                (H264_NAL_SLICE_IDR == m_lastSlice.octet.Type))
                return false;
        }
        else if (H264_NAL_SLICE_IDR == m_lastSlice.octet.Type)
        {
            if (p_newHeader.idr_pic_id != m_lastSlice.idr_pic_id)
                return false;
        }
        return true;
    }

    void H264_AU_Stream::SetLastAttrs(H264SequenceSetParse & p_seqSet, H264SliceHeaderParse & p_Slice)
    {
        m_au[m_iActiveUA].width =
            ( p_seqSet.pic_width_in_mbs_minus1 + 1) *16
            -(p_seqSet.frame_crop_left_offset+
            p_seqSet.frame_crop_right_offset)*2;
        m_au[m_iActiveUA].height =
            (2 - p_seqSet.frame_mbs_only_flag)*
            (p_seqSet.pic_height_in_map_units_minus1 + 1) *16
            -(p_seqSet.frame_crop_top_offset+
            p_seqSet.frame_crop_bottom_offset)*2*
            (2 - p_seqSet.frame_mbs_only_flag);

        m_au[m_iActiveUA].pic_parameter_set_id = p_Slice.pic_parameter_set_id;
    }
}

#endif // UMC_ENABLE_H264_SPLITTER