umc_mpeg2_dec_pic.cpp

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

        frame_buffer.field_buffer_index = 0;
      }
    }

    if(m_dPlaybackRate < 0 && m_dPlaybackRate > -4 && 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.f_code[0])
        GET_1BIT(video->bs,PictureHeader.full_pel_backward_vector)
        GET_TO9BITS(video->bs, 3, PictureHeader.f_code[2])

        PictureHeader.f_code[1] = PictureHeader.f_code[0];
        PictureHeader.f_code[3] = PictureHeader.f_code[2];
        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_ERR_INVALID_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.f_code[0])
        PictureHeader.f_code[1] = PictureHeader.f_code[0];
        VM_ASSERT(PictureHeader.f_code[0] != 0);

        if(PictureHeader.f_code[0] == 0)
            return (UMC_ERR_INVALID_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              = reset_dc[0];

    Ipp32s 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);

    //VM_ASSERT(code == EXTENSION_START_CODE);
    Ipp32u ecode = 0;
    if(code == EXTENSION_START_CODE)
    {
        SKIP_BITS_32(video->bs);
        SHOW_TO9BITS(video->bs, 4, ecode)
    }
    if((ecode == PICTURE_CODING_EXTENSION_ID) != (m_ClipInfo.stream_type == MPEG2_VIDEO))
      return (UMC_ERR_INVALID_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, video);

        FIND_START_CODE(video->bs, code);
    }

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

        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_ERR_NOT_ENOUGH_DATA);
      }
    }

    switch(PictureHeader.picture_coding_type)
    {
    case I_FRAME:
    case P_FRAME:
    case D_FRAME:
        sequenceHeader.b_curr_number = 0;

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

#ifdef KEEP_HISTORY
            frame_buffer.ind_his_ref  = frame_buffer.ind_his_p;
            frame_buffer.ind_his_curr = frame_buffer.ind_his_free;
            SWAP(Ipp32s, frame_buffer.ind_his_p, frame_buffer.ind_his_free);
#endif /* KEEP_HISTORY */
        }

        // to optimize logic !!
        if (PictureHeader.picture_structure == IPPVC_FRAME_PICTURE
            || frame_buffer.field_buffer_index == 1)
        { // complete frame
          // reorder frames
          if (m_lFlags & FLAG_VDEC_REORDER) {
            if(m_decodedFrameNum > 0)
              frame_buffer.retrieve = frame_buffer.prev_index;
            else
              frame_buffer.retrieve = -1;
          }
          // not reorder frames
          else
            frame_buffer.retrieve = frame_buffer.curr_index;
        }
        else
          frame_buffer.retrieve = -1;
        //printf("IP: %d %d\n", frame_buffer.ind_his_ref, frame_buffer.ind_his_curr);
        break;
    case B_FRAME:

        if(frame_buffer.field_buffer_index == 0) {
          sequenceHeader.b_curr_number++;
        }
        // reset index(es) of frames
        frame_buffer.curr_index = 2;

        if (PictureHeader.picture_structure == IPPVC_FRAME_PICTURE
            || frame_buffer.field_buffer_index == 1)
        { // complete frame
          frame_buffer.retrieve = 2;
        } else {
          frame_buffer.retrieve = -1;
        }
#ifdef KEEP_HISTORY
        frame_buffer.ind_his_ref  = frame_buffer.ind_his_b;
        frame_buffer.ind_his_curr = frame_buffer.ind_his_free;
        SWAP(Ipp32s, frame_buffer.ind_his_b, frame_buffer.ind_his_free);
#endif /* KEEP_HISTORY */
        //printf("B%d: %d %d\n", sequenceHeader.b_curr_number, frame_buffer.ind_his_ref, frame_buffer.ind_his_curr);
        break;
    default:
        VM_ASSERT(0);
        return (UMC_ERR_INVALID_STREAM);
    }

    frame_buffer.frame_p_c_n[frame_buffer.curr_index].frame_type = PictureHeader.picture_coding_type;

    return (UMC_OK);
}

void MPEG2VideoDecoderBase::quant_matrix_extension(void)
{
    Ipp32s i;
    Ipp32u code;
    IppVideoContext* video = Video[0];
    Ipp32s load_intra_quantizer_matrix, load_non_intra_quantizer_matrix, load_chroma_intra_quantizer_matrix, load_chroma_non_intra_quantizer_matrix;
    Ipp8u q_matrix[4][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[0][i]);
        }
        for (i = 0; i < m_nNumberOfThreads; i++) {
          ippiDecodeIntraInit_MPEG2(q_matrix[0], IPPVC_LEAVE_SCAN_UNCHANGED, PictureHeader.intra_vlc_format, PictureHeader.curr_intra_dc_multi, &Video[i]->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[1][i]);
        }
        for (i = 0; i < m_nNumberOfThreads; i++) {
          ippiDecodeInterInit_MPEG2(q_matrix[1], IPPVC_LEAVE_SCAN_UNCHANGED, &Video[i]->decodeInterSpec);
        }
    }

    GET_1BIT(video->bs,load_chroma_intra_quantizer_matrix);
    if(load_chroma_intra_quantizer_matrix && m_ClipInfo.color_format != YUV420)
    {
        for(i= 0; i < 64; i++) {
            GET_TO9BITS(video->bs, 8, q_matrix[2][i])
        }
        for (i = 0; i < m_nNumberOfThreads; i++) {
            ippiDecodeIntraInit_MPEG2(q_matrix[2], IPPVC_LEAVE_SCAN_UNCHANGED, PictureHeader.intra_vlc_format, PictureHeader.curr_intra_dc_multi, &Video[i]->decodeIntraSpecChroma);
        }
    }
    else
    {
        for (i = 0; i < m_nNumberOfThreads; i++) {
            Video[i]->decodeIntraSpecChroma = Video[i]->decodeIntraSpec;
        }
    }

    GET_1BIT(video->bs,load_chroma_non_intra_quantizer_matrix);
    if(load_chroma_non_intra_quantizer_matrix && m_ClipInfo.color_format != YUV420)
    {
        for(i= 0; i < 64; i++) {
            GET_TO9BITS(video->bs, 8, q_matrix[3][i])
        }
        for (i = 0; i < m_nNumberOfThreads; i++) {
            ippiDecodeInterInit_MPEG2(q_matrix[3], IPPVC_LEAVE_SCAN_UNCHANGED, &Video[i]->decodeInterSpecChroma);
        }
    }
    else
    {
        for (i = 0; i < m_nNumberOfThreads; i++) {
            Video[i]->decodeInterSpecChroma = Video[i]->decodeInterSpec;
        }
    }

} //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()
{
    Ipp32s number_of_frame_center_offsets = 0, i;
    Ipp32u 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::GetUserData(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);
}

#endif // UMC_ENABLE_MPEG2_VIDEO_DECODER