umc_mpeg2_dec_pic.cpp

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

    GET_TO9BITS(video->bs, 3, code)//video_format
    GET_1BIT(video->bs, code)//colour_description
    if(code)
    {
        GET_BITS_LONG(video->bs, 24, code)
    }
    GET_BITS_LONG(video->bs, 29, code)
}


void MPEG2VideoDecoderBase::sequence_scalable_extension()
{
    unsigned int code;
    IppVideoContext* video = &Video[0];
    sequenceHeader.extension_start_code_ID = SEQUENCE_SCALABLE_EXTENSION_ID;

    GET_TO9BITS(video->bs, 2, sequenceHeader.scalable_mode)//scalable_mode
    GET_TO9BITS(video->bs, 4, code);//layer_id
    if(sequenceHeader.scalable_mode == SPARTIAL_SCALABILITY)
    {
        SKIP_BITS_32(video->bs)
        SKIP_BITS_LONG(video->bs, 17)
    }
    else if(sequenceHeader.scalable_mode == TEMPORAL_SCALABILITY)
    {
        GET_1BIT(video->bs,code)//picture mux enable
        if(code)
            GET_1BIT(video->bs,code)//mux to progressive sequence
        SKIP_BITS(video->bs, 6)
    }

}


Status MPEG2VideoDecoderBase::DecodeBegin(double time, sVideoStreamInfo * /*info*/)
{
    IppVideoContext*    video   = &Video[0];
    sMacroblock         *pMacro = &Video[0].macroblock;

    unsigned int        code;
    unsigned int        pitch = 0;
    int                 width, height;
    int                 height_uv, size_y, size_uv = 0;
    Status              umcRes;

    sequenceHeader.frame_count    = 0;
    sequenceHeader.stream_time    = 0;
    sequenceHeader.is_skipped_b    = 0;
    PictureHeader.field_buffer_index = 0;


    //get sequence header start code
    FIND_START_CODE(video->bs, code);
    SKIP_BITS_32(video->bs);

    if(SEQUENCE_HEADER_CODE != code)
        return (UMC_BAD_STREAM);

    if(UMC_OK != DecodeSequenceHeader())
        return (UMC_BAD_STREAM);

    sequenceHeader.num_of_skipped   = 0;
    sequenceHeader.bdied            = 0;
    sequenceHeader.b_count_btw_ip   = 0;
    sequenceHeader.anlize_seq       = true;

    width = sequenceHeader.horizontal_size;
    height= sequenceHeader.vertical_size;

    size_y = align_value<int> (width, ALIGN_VALUE) *( height + 16);

    switch(sequenceHeader.chroma_format)
    {
    case CHROMA_420:
        size_uv = size_y >> 2;
        height_uv = height >> 2;
        pitch = align_value<int> (width, ALIGN_VALUE) >> 1;
        break;
    case CHROMA_422:
        size_uv = size_y >> 1;
        height_uv = height;
        pitch = align_value<int> (width, ALIGN_VALUE) >> 1;
        break;
    case CHROMA_444:
        size_uv = size_y;
        height_uv = height;
        pitch = align_value<int> (width, ALIGN_VALUE);
       break;
    default:
        break;
    }

    // set correct size in color converter
    m_Convert.ConversionInit.SizeSource.width = width;
    m_Convert.ConversionInit.SizeSource.height = height;
    if (NULL != m_lpConverter &&
        UMC_OK != m_lpConverter->Init(m_Convert.ConversionInit))
        return (UMC_ALLOC);

    if (m_bTwoPictures)
    {
        m_ConvertPreview.ConversionInit.SizeSource.width = width;
        m_ConvertPreview.ConversionInit.SizeSource.height = height;
        if (NULL != m_lpConverter &&
            UMC_OK != m_lpConverter->Init(m_ConvertPreview.ConversionInit))
            return (UMC_ALLOC);
    }

    sequenceHeader.ptr_context_data = (unsigned char *) ippsMalloc_8u
                                        (3*size_y + 6*size_uv + ALIGN_VALUE * 3);
    if(!sequenceHeader.ptr_context_data)
        return (UMC_ALLOC);

    video->frame_buffer.frame_p_c_n[0].Y_comp_data =
            align_pointer<unsigned char *> (sequenceHeader.ptr_context_data, ALIGN_VALUE);

    video->frame_buffer.frame_p_c_n[0].U_comp_data =
                                       video->frame_buffer.frame_p_c_n[0].Y_comp_data + size_y;
    video->frame_buffer.frame_p_c_n[0].V_comp_data =
                                       video->frame_buffer.frame_p_c_n[0].U_comp_data + size_uv;

    video->frame_buffer.frame_p_c_n[1].Y_comp_data =
    align_pointer<unsigned char *> (video->frame_buffer.frame_p_c_n[0].U_comp_data + 2*size_uv, ALIGN_VALUE);
    video->frame_buffer.frame_p_c_n[1].U_comp_data =
                                       video->frame_buffer.frame_p_c_n[1].Y_comp_data + size_y;
    video->frame_buffer.frame_p_c_n[1].V_comp_data =
                                       video->frame_buffer.frame_p_c_n[1].U_comp_data + size_uv;

     video->frame_buffer.frame_p_c_n[2].Y_comp_data =
      align_pointer<unsigned char *> (video->frame_buffer.frame_p_c_n[1].U_comp_data + 2*size_uv, ALIGN_VALUE);
    video->frame_buffer.frame_p_c_n[2].U_comp_data =
                                       video->frame_buffer.frame_p_c_n[2].Y_comp_data + size_y;
    video->frame_buffer.frame_p_c_n[2].V_comp_data =
                                       video->frame_buffer.frame_p_c_n[2].U_comp_data + size_uv;

#ifdef KEEP_HISTORY
    video->frame_buffer.frame_p_c_n[0].frame_history = (unsigned char *) ippsMalloc_8u
                                        (sequenceHeader.mb_width*sequenceHeader.mb_height);
    if(!video->frame_buffer.frame_p_c_n[0].frame_history)
        return (UMC_ALLOC);
    video->frame_buffer.frame_p_c_n[1].frame_history = (unsigned char *) ippsMalloc_8u
                                        (sequenceHeader.mb_width*sequenceHeader.mb_height);
    if(!video->frame_buffer.frame_p_c_n[1].frame_history)
        return (UMC_ALLOC);
    video->frame_buffer.frame_p_c_n[2].frame_history = (unsigned char *) ippsMalloc_8u
                                        (sequenceHeader.mb_width*sequenceHeader.mb_height);
    if(!video->frame_buffer.frame_p_c_n[2].frame_history)
        return (UMC_ALLOC);

    memset(video->frame_buffer.frame_p_c_n[0].frame_history, 0,
                        sequenceHeader.mb_width*sequenceHeader.mb_height);
    memset(video->frame_buffer.frame_p_c_n[1].frame_history, 0,
                        sequenceHeader.mb_width*sequenceHeader.mb_height);
    memset(video->frame_buffer.frame_p_c_n[2].frame_history, 0,
                        sequenceHeader.mb_width*sequenceHeader.mb_height);
#endif
    video->frame_buffer.Y_comp_width     = width;
    video->frame_buffer.Y_comp_pitch     = align_value<int> (width, ALIGN_VALUE);
    video->frame_buffer.U_comp_pitch     = pitch;
    video->frame_buffer.V_comp_pitch     = pitch;

    int pitch_l = video->frame_buffer.Y_comp_pitch;
    int pitch_c = pitch;
    blkOffsets[0][0] = 0;
    blkOffsets[0][1] = 8;
    blkOffsets[0][2] = 8*pitch_l;
    blkOffsets[0][3] = 8*pitch_l + 8;
    blkOffsets[0][4] = 0;
    blkOffsets[0][5] = 0;
    blkOffsets[0][6] = 8*pitch_c;
    blkOffsets[0][7] = 8*pitch_c;
    blkOffsets[1][0] = 0;
    blkOffsets[1][1] = 8;
    blkOffsets[1][2] = pitch_l;
    blkOffsets[1][3] = pitch_l + 8;
    blkOffsets[1][4] = 0;
    blkOffsets[1][5] = 0;
    blkOffsets[1][6] = 8*pitch_c;
    blkOffsets[1][7] = 8*pitch_c;
    blkOffsets[2][0] = 0;
    blkOffsets[2][1] = 8;
    blkOffsets[2][2] = 16*pitch_l;
    blkOffsets[2][3] = 16*pitch_l + 8;
    blkOffsets[2][4] = 0;
    blkOffsets[2][5] = 0;
    blkOffsets[2][6] = 16*pitch_c;
    blkOffsets[2][7] = 16*pitch_c;

    blkPitches[0][0] = pitch_l;
    blkPitches[0][1] = pitch_c;
    blkPitches[1][0] = 2*pitch_l;
    blkPitches[1][1] = pitch_c;
    blkPitches[2][0] = 2*pitch_l;
    blkPitches[2][1] = 2*pitch_c;

    sSlice *pSlice = &Video[0/*threadID*/].slice;
    pDC[0] = &pSlice->dct_dc_y_past;
    pDC[1] = &pSlice->dct_dc_cb_past;
    pDC[2] = &pSlice->dct_dc_cr_past;

    video->frame_buffer.prev_index =  0;
    video->frame_buffer.curr_index =  0;
    video->frame_buffer.next_index =  1;
    video->frame_buffer.retrieve   = -1;
    video->frame_buffer.ind_his_p = 0;
    video->frame_buffer.ind_his_b = 1;
    video->frame_buffer.ind_his_free = 2;

    pMacro->offset_field_y[0]  = pMacro->offset_field_uv[0] = 0;
    pMacro->offset_field_y[1]  = video->frame_buffer.Y_comp_pitch;
    pMacro->offset_field_uv[1] = video->frame_buffer.U_comp_pitch;

    //get gop or picture start code
    FIND_START_CODE(video->bs, code);

    //TBD GOP process
    while(code != PICTURE_START_CODE && code != (unsigned int)UMC_NOT_ENOUGH_DATA)
    {
        SKIP_BITS_32(video->bs);
        DecodeHeader(code,0);
        FIND_START_CODE(video->bs, code);
    }

    if(time > 0)
        sequenceHeader.stream_time = time;
    else
        sequenceHeader.stream_time = 0;
    sequenceHeader.stream_time_temporal_reference = -2;
    sequenceHeader.stream_time -= sequenceHeader.delta_frame_time;
    video->frame_buffer.frame_p_c_n[0].frame_time = -1;
    video->frame_buffer.frame_p_c_n[1].frame_time = -1;

    if ((m_lFlags & FLAG_VDEC_REORDER) && GET_REMAINED_BYTES(video->bs) > 15)
    {
      double start_time; // result unused

        GET_BITS32(video->bs, code);
        VM_ASSERT(code == PICTURE_START_CODE);
        umcRes = DecodeHeader(code, 0);
        if(umcRes != UMC_OK)
          return (umcRes);

        sequenceHeader.stream_time_temporal_reference++;

        if(PictureHeader.picture_coding_type == I_PICTURE)
        {
            sequenceHeader.bdied = 0;
            sequenceHeader.first_i_occure = 1;
        }
        else if(PictureHeader.picture_coding_type != D_PICTURE)
            return (UMC_NOT_ENOUGH_BUFFER);

        umcRes = DecodePicture();
        CalculateFrameTime(time, &start_time);
    }

    return (UMC_OK);
}

// in incomp mode must start right after picture_start_code
Status MPEG2VideoDecoderBase::GetNextFrame(MediaData *input, MediaData *output)
{
    unsigned int     code    = 0;
    VideoData        *lpVData    = DynamicCast<VideoData, MediaData> (output);
    IppVideoContext  *video        = &Video[0];
    Status          umcRes = UMC_OK;

    if ((NULL != input) && (NULL != input->GetDataPointer()))
    {
        if((m_lFlags & FLAG_VDEC_COMPATIBLE))
        do {
          GET_START_CODE(video->bs, code);
          // some headers are possible here
          if(code == (unsigned int)UMC_NOT_ENOUGH_DATA)
            return (UMC_NOT_ENOUGH_DATA); //UMC_END_OF_STREAM;
          if(code == SEQUENCE_END_CODE)
            return (UMC_END_OF_STREAM);
          if(code != PICTURE_START_CODE) {
            umcRes = DecodeHeader(code, 0);
            if(umcRes == UMC_NOT_ENOUGH_DATA)
              return (UMC_NOT_ENOUGH_DATA);
          }
        } while (code != PICTURE_START_CODE);

        umcRes = DecodeHeader(PICTURE_START_CODE, 0);
        if(umcRes != UMC_OK)
          return (umcRes);

        if (NULL != lpVData) {
            // set dest pointer(s) for slice conversion
            m_Convert.lpDest0 = (Ipp8u *) (lpVData->m_lpDest[0]);
            m_Convert.lpDest1 = (Ipp8u *) (lpVData->m_lpDest[1]);
            m_Convert.lpDest2 = (Ipp8u *) (lpVData->m_lpDest[2]);

            m_Convert.PitchDest0 = lpVData->m_lPitch[0];
            m_Convert.PitchDest1 = lpVData->m_lPitch[1];
            m_Convert.PitchDest2 = lpVData->m_lPitch[2];

            lpVData->SetColorFormat(m_Convert.ConversionInit.FormatDest);

            lpVData->SetFrameType(PictureHeader.picture_coding_type);
            lpVData->SetVideoParameters(sequenceHeader.horizontal_size,
                sequenceHeader.vertical_size, m_Convert.ConversionInit.FormatDest);
            // restore original pitches changed in SetVideoParameters()
            lpVData->SetPitch(m_Convert.PitchDest0, m_Convert.PitchDest1, m_Convert.PitchDest2);
        }

        if (NONE_PICTURE >= PictureHeader.picture_coding_type ||
            B_PICTURE < PictureHeader.picture_coding_type)
        {
            if(!(PictureHeader.picture_coding_type == D_PICTURE &&
               sequenceHeader.stream_type == MPEG1_VIDEO))
            {
                umcRes = UMC_NOT_ENOUGH_DATA;
            }
        }

        if(UMC_OK == umcRes)
        {
            if(PictureHeader.field_buffer_index == 0) // not for second field
            {
              sequenceHeader.stream_time_temporal_reference++;
              if(PictureHeader.picture_coding_type == I_PICTURE)
              {
                sequenceHeader.bdied = 0;
                if(sequenceHeader.first_i_occure)
                    sequenceHeader.first_p_occure = 1;
                sequenceHeader.first_i_occure = 1;
              }
              else if(!sequenceHeader.first_i_occure) {
                umcRes =  UMC_NOT_ENOUGH_DATA;
              }
              else if(PictureHeader.picture_coding_type == P_PICTURE) {
                sequenceHeader.bdied = 0;
                sequenceHeader.first_p_occure = 1;