umc_mpeg2_dec_pic.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

        PictureHeader.field_buffer_index = 0;
      }
    }

    if(m_dPlaybackRate < 0 && PictureHeader.picture_coding_type == I_FRAME)
        Reset();

    pPic->low_in_range[0] = pPic->low_in_range[1] =
    pPic->low_in_range[2] = pPic->low_in_range[3] = -16;
    pPic->high_in_range[0] = pPic->high_in_range[1] =
    pPic->high_in_range[2] = pPic->high_in_range[3] = 15;
    pPic->range[0] = pPic->range[1] =
    pPic->range[2] = pPic->range[3] = 32;

    if(PictureHeader.picture_coding_type == B_FRAME)
    {
        GET_1BIT(video->bs,PictureHeader.full_pel_forward_vector)
        GET_TO9BITS(video->bs, 3, PictureHeader.forward_f_code)
        GET_1BIT(video->bs,PictureHeader.full_pel_backward_vector)
        GET_TO9BITS(video->bs, 3, PictureHeader.backward_f_code)

        PictureHeader.f_code[1] = PictureHeader.f_code[0] = PictureHeader.forward_f_code;
        PictureHeader.f_code[3] = PictureHeader.f_code[2] = PictureHeader.backward_f_code;
        if(PictureHeader.f_code[0] == 0 || PictureHeader.f_code[2] == 0)
        {
            VM_ASSERT(PictureHeader.f_code[0] != 0 && PictureHeader.f_code[2] != 0);
            return (UMC_BAD_STREAM);
        }
        pPic->r_size[0] = PictureHeader.f_code[0] - 1;
        pPic->r_size[1] = PictureHeader.f_code[1] - 1;
        pPic->r_size[2] = PictureHeader.f_code[2] - 1;
        pPic->r_size[3] = PictureHeader.f_code[3] - 1;
    }
    else if(PictureHeader.picture_coding_type == P_FRAME )
    {
        GET_1BIT(video->bs,PictureHeader.full_pel_forward_vector)
        GET_TO9BITS(video->bs, 3, PictureHeader.forward_f_code)
        PictureHeader.f_code[1] = PictureHeader.f_code[0] = PictureHeader.forward_f_code;
        VM_ASSERT(PictureHeader.f_code[0] != 0);

        if(PictureHeader.f_code[0] == 0)
            return (UMC_BAD_STREAM);
        pPic->r_size[0] = PictureHeader.f_code[0] - 1;
        pPic->r_size[1] = PictureHeader.f_code[1] - 1;
        pPic->r_size[2] = 0;
        pPic->r_size[3] = 0;
    }
    GET_1BIT(video->bs,code)
    while(code)
    {
        GET_TO9BITS(video->bs, 8 ,code) //extra information picture
        GET_1BIT(video->bs,code)
    }
    //set for MPEG1
    PictureHeader.picture_structure          = IPPVC_FRAME_PICTURE;
    PictureHeader.frame_pred_frame_dct       = 1;
    PictureHeader.intra_vlc_format           = 0;
    PictureHeader.progressive_frame          = 1;
    PictureHeader.curr_intra_dc_multi        = intra_dc_multi[0];
    PictureHeader.curr_reset_dc              = 1024;//reset_dc[0];

    int i, f;
    for(i = 0; i < 4; i++) {
        f = 1 << pPic->r_size[i];
        pPic->low_in_range[i] = -(f * 16);
        pPic->high_in_range[i] = (f * 16) - 1;
        pPic->range[i] = f * 32;
    }

    FIND_START_CODE(video->bs, code);

    unsigned int ecode = 0;
    if(code == EXTENSION_START_CODE)
    {
        SKIP_BITS_32(video->bs);
        SHOW_TO9BITS(video->bs, 4, ecode)
    }
    if((ecode == PICTURE_CODING_EXTENSION_ID) != (sequenceHeader.stream_type == MPEG2_VIDEO))
      return (UMC_BAD_STREAM);

    // compute maximum slice vertical position
    if(PictureHeader.picture_structure == IPPVC_FRAME_PICTURE)
      PictureHeader.max_slice_vert_pos = sequenceHeader.mb_height;
    else
      PictureHeader.max_slice_vert_pos = sequenceHeader.mb_height >> 1;

    if(code == EXTENSION_START_CODE)
    {
        DecodeHeader(EXTENSION_START_CODE,0);

        FIND_START_CODE(video->bs, code);
    }

    while (code == EXTENSION_START_CODE || code == USER_DATA_START_CODE)
    {
        SKIP_BITS_32(video->bs);
        DecodeHeader(code,0);

        FIND_START_CODE(video->bs, code);
    }

    if(!sequenceHeader.first_i_occure)
    {
      if (I_FRAME != PictureHeader.picture_coding_type &&
          D_FRAME != PictureHeader.picture_coding_type)
      {
        return (UMC_NOT_ENOUGH_DATA);
      }
    }

    switch(PictureHeader.picture_coding_type)
    {
    case I_FRAME:
    case P_FRAME:
    case D_FRAME:
        if(sequenceHeader.anlize_seq && !sequenceHeader.b_count_btw_ip)
            sequenceHeader.b_count_btw_ip = 0;
        else if(sequenceHeader.b_count_btw_ip)
        {
            sequenceHeader.anlize_seq = false;
        }

        sequenceHeader.b_curr_number = 0;

        if (PictureHeader.picture_structure == IPPVC_FRAME_PICTURE
            || PictureHeader.field_buffer_index == 0)
        {
            // reset index(es) of frames
            video->frame_buffer.prev_index = video->frame_buffer.next_index;
            video->frame_buffer.next_index = (0 == video->frame_buffer.next_index) ? (1) : (0);
            video->frame_buffer.curr_index = video->frame_buffer.next_index;

#ifdef KEEP_HISTORY
            video->frame_buffer.ind_his_ref  = video->frame_buffer.ind_his_p;
            video->frame_buffer.ind_his_curr = video->frame_buffer.ind_his_free;
            SWAP(int, video->frame_buffer.ind_his_p, video->frame_buffer.ind_his_free);
#endif /* KEEP_HISTORY */
        }

        if (PictureHeader.picture_structure == IPPVC_FRAME_PICTURE
            || PictureHeader.field_buffer_index == 1)
        { // complete frame
          // reorder frames
          if (m_lFlags & FLAG_VDEC_REORDER) {
            if(m_decodedFrameNum > 0)
              video->frame_buffer.retrieve = video->frame_buffer.prev_index;
            else
              video->frame_buffer.retrieve = -1;
          }
          // not reorder frames
          else
            video->frame_buffer.retrieve = video->frame_buffer.curr_index;
        }
        else
          video->frame_buffer.retrieve = -1;
        break;
    case B_FRAME:

        if(PictureHeader.field_buffer_index == 0) {
          if (sequenceHeader.anlize_seq) {
            sequenceHeader.b_count_btw_ip ++;
          }
          sequenceHeader.b_curr_number++;
        }
        // reset index(es) of frames
        video->frame_buffer.curr_index = 2;
        if (PictureHeader.picture_structure == IPPVC_FRAME_PICTURE
            || PictureHeader.field_buffer_index == 1)
        { // complete frame
          video->frame_buffer.retrieve = 2;
        } else {
          video->frame_buffer.retrieve = -1;
        }
#ifdef KEEP_HISTORY
        video->frame_buffer.ind_his_ref  = video->frame_buffer.ind_his_b;
        video->frame_buffer.ind_his_curr = video->frame_buffer.ind_his_free;
        SWAP(int, video->frame_buffer.ind_his_b, video->frame_buffer.ind_his_free);
#endif /* KEEP_HISTORY */
        break;
    default:
        VM_ASSERT(0);
        return (UMC_BAD_STREAM);
    }

    video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].frame_type = PictureHeader.picture_coding_type;

    return (UMC_OK);
}


void MPEG2VideoDecoderBase::ConvertSlice(unsigned int lSliceNum, int /*threadID*/)
{
    if (NULL != m_lpConverter)
    {
        m_lpConverter->ConvertSlice(&m_Convert, lSliceNum - 1);
        if (m_bTwoPictures)
            m_lpConverter->ConvertSlice(&m_ConvertPreview, lSliceNum - 1);
    }
}


void MPEG2VideoDecoderBase::quant_matrix_extension(void)
{
    int i;
    unsigned int code;
    IppVideoContext* video = &Video[0];
    int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix, load_chroma_intra_quantizer_matrix, load_chroma_non_intra_quantizer_matrix;
    Ipp8u q_matrix[64];

    GET_TO9BITS(video->bs, 4 ,code)
    GET_1BIT(video->bs,load_intra_quantizer_matrix)
    if(load_intra_quantizer_matrix)
    {
        for(i= 0; i < 64; i++) {
            GET_BITS(video->bs, 8, q_matrix[i]);
        }
        ippiDecodeIntraInit_MPEG2(q_matrix, IPPVC_LEAVE_SCAN_UNCHANGED, PictureHeader.intra_vlc_format, PictureHeader.curr_intra_dc_multi, decodeIntraSpec);
    }

    GET_1BIT(video->bs,load_non_intra_quantizer_matrix)
    if(load_non_intra_quantizer_matrix)
    {
        for(i= 0; i < 64; i++) {
            GET_BITS(video->bs, 8, q_matrix[i]);
        }
        ippiDecodeInterInit_MPEG2(q_matrix, IPPVC_LEAVE_SCAN_UNCHANGED, decodeInterSpec);
    }
    GET_1BIT(video->bs,load_chroma_intra_quantizer_matrix)
    if(load_chroma_intra_quantizer_matrix)
    {
        Ipp8u chroma_intra_quantizer_matrix[64];
        for(i= 0; i < 64; i++) {
            GET_TO9BITS(video->bs, 8, chroma_intra_quantizer_matrix[i])
        }
    }

    GET_1BIT(video->bs,load_chroma_non_intra_quantizer_matrix)
    if(load_chroma_non_intra_quantizer_matrix)
    {
        Ipp8u chroma_non_intra_quantizer_matrix[64];
        for(i= 0; i < 64; i++) {
            GET_TO9BITS(video->bs, 8, chroma_non_intra_quantizer_matrix[i])
        }
    }

} //void quant_matrix_extension()


void MPEG2VideoDecoderBase::copyright_extension()
{
    IppVideoContext* video = &Video[0];

    SKIP_BITS_32(video->bs)
    SKIP_BITS_32(video->bs)
    SKIP_BITS_LONG(video->bs, 22)
}


void MPEG2VideoDecoderBase::picture_display_extension()
{
    int number_of_frame_center_offsets = 0, i;
    unsigned int code;
    IppVideoContext* video = &Video[0];

    GET_TO9BITS(video->bs, 4 ,code)

    if(sequenceHeader.progressive_sequence)
    {
        if(PictureHeader.repeat_first_field)
        {
            if(PictureHeader.top_field_first)
                number_of_frame_center_offsets = 3;
            else
                number_of_frame_center_offsets = 2;
        }
        else
            number_of_frame_center_offsets = 1;
    }
    else
    {
        if(PictureHeader.picture_structure != IPPVC_FRAME_PICTURE)
            number_of_frame_center_offsets = 1;
        else
        {
            if(PictureHeader.repeat_first_field)
                number_of_frame_center_offsets = 3;
            else
                number_of_frame_center_offsets = 2;
        }
    }
    for(i = 0; i < number_of_frame_center_offsets; i++)
    {
        SKIP_BITS_32(video->bs)
        SKIP_BITS(video->bs, 2)
    }

} //void picture_display_extension()


void MPEG2VideoDecoderBase::picture_spartial_scalable_extension()
{
    IppVideoContext* video = &Video[0];
    SKIP_BITS_32(video->bs)
    SKIP_BITS_LONG(video->bs, 18)
}


void MPEG2VideoDecoderBase::picture_temporal_scalable_extension()
{
    IppVideoContext* video = &Video[0];
    SKIP_BITS_LONG(video->bs, 27)
}

Status MPEG2VideoDecoderBase::GetClosedCaptureData(MediaData* pCC)
{
    Status umcRes = UMC_OK;

    if(m_ccCurrData.GetBufferSize())
    {
        umcRes = m_pCCData->UnLockOutputBuffer(&m_ccCurrData);
        m_ccCurrData.SetBufferPointer(0,0);
    }

    umcRes = m_pCCData->LockOutputBuffer(&m_ccCurrData);

    if(UMC_OK == umcRes)
    {
        *pCC = m_ccCurrData;
        m_ccCurrData.SetDataSize(0);
    }

    return (umcRes);
}