umc_mpeg4_video_encoder.cpp

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

        return status;
    status = AllocateBuffers();
    if (status != UMC_OK)
        return status;
    m_Param.m_SuggestedOutputSize = m_Param.info.clip_info.width * m_Param.info.clip_info.height;
    m_IsInit = true;
    return UMC_OK;
}

Status MPEG4VideoEncoder::GetInfo(BaseCodecParams* baseParams)
{
    MPEG4EncoderParams* mp4Params = DynamicCast<MPEG4EncoderParams>(baseParams);
    VideoEncoderParams *encParams = DynamicCast<VideoEncoderParams>(baseParams);

    if (!m_IsInit)
        return UMC_ERR_NOT_INITIALIZED;
    m_Param.info.stream_type = MPEG4_VIDEO;
    m_Param.qualityMeasure = 100 - m_Param.m_Param.quantPVOP * 100 / 33;
    if (mp4Params) {
        *mp4Params = m_Param;
    } else if (encParams) {
        *encParams = m_Param;
    } else if (baseParams) {
        *baseParams = m_Param;
    } else
        return UMC_ERR_NULL_PTR;
    return UMC_OK;
}

Status MPEG4VideoEncoder::Close()
{
    if (!m_IsInit)
        return UMC_ERR_NOT_INITIALIZED;
    FreeBuffers();
    // close default memory allocator if exist
    BaseCodec::Close();
    if (m_Param.m_Param.BVOPdist)
        delete [] bTime;
    mp4enc->Close();
    delete mp4enc;
    m_IsInit = false;
    return UMC_OK;
}

Status MPEG4VideoEncoder::GetFrame(MediaData* pIn, MediaData* pOut)
{
    if (!m_IsInit)
        return UMC_ERR_NOT_INITIALIZED;
    VideoData* pVideoDataIn = DynamicCast<VideoData> (pIn);
    if (!pOut)
        return UMC_ERR_NULL_PTR;
    mp4enc->InitBuffer((Ipp8u*)pOut->GetDataPointer() + pOut->GetDataSize(), (Ipp8u*)pOut->GetBufferPointer() - (Ipp8u*)pOut->GetDataPointer() + pOut->GetBufferSize() - pOut->GetDataSize());
    if (m_FrameCount == 0)
        mp4enc->EncodeHeader();
    LockBuffers();
    if (pIn && ((m_Param.m_Param.sprite_enable != MP4_SPRITE_STATIC) || (m_FrameCount == 0))) {
        // copy YUV to internal frame
        IppiSize  roi;
        Ipp8u    *pY, *pU, *pV;
        Ipp32s    stepL, stepC;

        mp4enc->GetCurrentFrameInfo(&pY, &pU, &pV, &stepL, &stepC);
        roi.width = m_Param.info.clip_info.width;
        roi.height = m_Param.info.clip_info.height;
        ippiCopy_8u_C1R((Ipp8u*)pVideoDataIn->GetPlanePointer(0), pVideoDataIn->GetPlanePitch(0), pY, stepL, roi);
        roi.width >>= 1;
        roi.height >>= 1;
        ippiCopy_8u_C1R((Ipp8u*)pVideoDataIn->GetPlanePointer(1), pVideoDataIn->GetPlanePitch(1), pU, stepC, roi);
        ippiCopy_8u_C1R((Ipp8u*)pVideoDataIn->GetPlanePointer(2), pVideoDataIn->GetPlanePitch(2), pV, stepC, roi);
    }
    Ipp32s  sts = mp4enc->EncodeFrame(pIn == NULL);
    Ipp64f  pts = gTime;
    if (pIn) {
        pIn->SetDataSize(0);
        if (pIn->GetTime() >= 0)
            pts = pIn->GetTime();
    }
    if (sts == MPEG4_ENC::MP4_STS_BUFFERED) {
        //pOut->SetDataSize(0);
        pOut->SetTime(-1.0);
        if (pIn) {
            bTime[bTimePos] = pts;
            bTimePos ++;
            if (bTimePos >= m_Param.m_Param.BVOPdist)
                bTimePos = 0;
        }
    } else {
        if (sts != MPEG4_ENC::MP4_STS_NODATA)
            m_FrameCount ++;
        pOut->SetDataSize(mp4enc->GetBufferFullness() + pOut->GetDataSize());
        if (mp4enc->GetFrameType() != MPEG4_ENC::MP4_VOP_TYPE_B) {
            pOut->SetTime(pts);
        } else {
            pOut->SetTime(bTime[bTimePos]);
            bTime[bTimePos] = pts;
            bTimePos ++;
            if (bTimePos >= m_Param.m_Param.BVOPdist)
                bTimePos = 0;
        }
        switch (mp4enc->GetFrameType()) {
          case MPEG4_ENC::MP4_VOP_TYPE_I:
            pOut->SetFrameType(I_PICTURE);
            break;
          case MPEG4_ENC::MP4_VOP_TYPE_P:
            pOut->SetFrameType(P_PICTURE);
            break;
          case MPEG4_ENC::MP4_VOP_TYPE_B:
            pOut->SetFrameType(B_PICTURE);
            break;
          default:
            pOut->SetFrameType(NONE_PICTURE);
            break;
        }
    }
    gTime += iTime;
    UnlockBuffers();
    //return (sts == MPEG4_ENC::MP4_STS_BUFFERED) ? UMC_ERR_NOT_ENOUGH_DATA : (sts == MPEG4_ENC::MP4_STS_NODATA) ? UMC_ERR_END_OF_STREAM : UMC_OK;
    return (sts == MPEG4_ENC::MP4_STS_NODATA) ? UMC_ERR_END_OF_STREAM : UMC_OK;
    //return UMC_OK;
}

VideoEncoder* CreateMPEG4Encoder()
{
    MPEG4VideoEncoder* ptr = new MPEG4VideoEncoder;
    return ptr;
}

Status MPEG4EncoderParams::ReadParamFile(const vm_char *FileName)
{
    vm_file *InputFile;
    vm_char str[STR_LEN+1], IntraQMatrixFileName[STR_LEN+1], NonIntraQMatrixFileName[STR_LEN+1];
    Ipp32s   i, j, k, numFramesToEncode;

    InputFile = vm_file_open(FileName, VM_STRING("rt"));
    if (!InputFile) {
        vm_debug_trace1(VM_DEBUG_INFO,__VM_STRING("Error: Couldn't open file '%s'\n"), FileName);
        return UMC_ERR_FAILED;
    }
    vm_file_gets(str, STR_LEN, InputFile);
    vm_file_gets(str, STR_LEN, InputFile); //vm_string_sscanf(str, VM_STRING("%s"), SrcFileName);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.Width);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.Height);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &numFramesToEncode);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.TimeResolution);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.TimeIncrement);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quant_type);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantIVOP);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantPVOP);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.quantBVOP);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%s"), IntraQMatrixFileName);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%s"), NonIntraQMatrixFileName);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.short_video_header);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.IVOPdist);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BVOPdist);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PVOPsearchWidth);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.PVOPsearchHeight);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BVOPsearchWidthForw);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BVOPsearchHeightForw);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BVOPsearchWidthBack);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BVOPsearchHeightBack);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.MEalgorithm);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.MEaccuracy);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.ME4mv);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.obmc_disable);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.RoundingControl);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.calcPSNR);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.RateControl);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.BitRate);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.SceneChangeThreshold);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.insertGOV);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.repeatHeaders);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.resync);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.VideoPacketLenght);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.data_partitioned);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.reversible_vlc);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.interlaced);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.top_field_first);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.alternate_vertical_scan_flag);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.interlacedME);
    vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.sprite_enable);
    if (m_Param.sprite_enable) {
        vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.no_of_sprite_warping_points);
        vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.sprite_warping_accuracy);
    }
    if (m_Param.sprite_enable == IPPVC_SPRITE_STATIC) {
        vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d"), &m_Param.sprite_brightness_change);
        vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d %d"), &m_Param.sprite_left_coordinate, &m_Param.sprite_top_coordinate);
        vm_file_gets(str, STR_LEN, InputFile); vm_string_sscanf(str, VM_STRING("%d %d"), &m_Param.sprite_width, &m_Param.sprite_height);
        if (numFramesToEncode < 1)
            numFramesToEncode = 1;
        if (m_Param.no_of_sprite_warping_points < 0 || m_Param.no_of_sprite_warping_points > 3)
            m_Param.no_of_sprite_warping_points = 0;
        if (m_Param.no_of_sprite_warping_points > 0) {
            m_Param.warping_mv_code_du = new Ipp32s [m_Param.no_of_sprite_warping_points * numFramesToEncode];
            m_Param.warping_mv_code_dv = new Ipp32s [m_Param.no_of_sprite_warping_points * numFramesToEncode];
            m_Param.brightness_change_factor = new Ipp32s [numFramesToEncode];
            for (i = 0; i < (Ipp32s)numFramesToEncode; i ++) {
                for (j = 0; j < m_Param.no_of_sprite_warping_points; j ++) {
                    vm_file_fscanf(InputFile, VM_STRING("%d"), &m_Param.warping_mv_code_du[i*m_Param.no_of_sprite_warping_points+j]);
                    vm_file_fscanf(InputFile, VM_STRING("%d"), &m_Param.warping_mv_code_dv[i*m_Param.no_of_sprite_warping_points+j]);
                }
                if (m_Param.sprite_brightness_change)
                    vm_file_fscanf(InputFile, VM_STRING("%d"), &m_Param.brightness_change_factor[i]);
            }
        }
    }
    vm_file_fclose(InputFile);
    // read quant matrix
    m_Param.load_intra_quant_mat = 0;
    m_Param.load_intra_quant_mat_len = 0;
    if (IntraQMatrixFileName[0] != '-' ) {
        InputFile = vm_file_open(IntraQMatrixFileName, VM_STRING("rt"));
        if (!InputFile) {
            vm_debug_trace1(VM_DEBUG_INFO,__VM_STRING("Error: Couldn't open quant matrix file '%s'\n"), IntraQMatrixFileName);
            return UMC_ERR_FAILED;
        } else {
            m_Param.load_intra_quant_mat = 1;
            for (i = 0; i < 64; i++) {
                k = vm_file_fscanf(InputFile, VM_STRING("%d"), &j);
                if (k <= 0 || j < 1 || j > 255 )
                    break;
                m_Param.intra_quant_mat[i] = (Ipp8u)j;
            }
            m_Param.load_intra_quant_mat_len = i;
            if (m_Param.load_intra_quant_mat_len < 2) {
                m_Param.load_intra_quant_mat = 0;
                m_Param.load_intra_quant_mat_len = 0;
            }
        }
        vm_file_fclose(InputFile);
        m_Param.quant_type = 1;
    }
    m_Param.load_nonintra_quant_mat = 0;
    m_Param.load_nonintra_quant_mat_len = 0;
    if (NonIntraQMatrixFileName[0] != '-' ) {
        InputFile = vm_file_open(NonIntraQMatrixFileName, VM_STRING("rt"));
        if (!InputFile) {
            vm_debug_trace1(VM_DEBUG_INFO,__VM_STRING("Error: Couldn't open quant matrix file '%s'\n"), NonIntraQMatrixFileName);
            return UMC_ERR_FAILED;
        } else {
            m_Param.load_nonintra_quant_mat = 1;
            for (i = 0; i < 64; i++) {
                k = vm_file_fscanf(InputFile, VM_STRING("%d"), &j);
                if (k <= 0 || j < 1 || j > 255 )
                    break;
                m_Param.nonintra_quant_mat[i] = (Ipp8u)j;
            }
            m_Param.load_nonintra_quant_mat_len = i;
            if (m_Param.load_nonintra_quant_mat_len < 2) {
                m_Param.load_nonintra_quant_mat = 0;
                m_Param.load_nonintra_quant_mat_len = 0;
            }
        }
        vm_file_fclose(InputFile);
        m_Param.quant_type = 1;
    }
    m_Param.bsBuffer = (Ipp8u*)1;
    m_Param.bsBuffSize = 1; // encoder will not allocate buffer
    m_Param.padType = 0; // set 1 for QuickTime(tm) and 2 for DivX (tm) v. >= 5
    info.clip_info.width = m_Param.Width;
    info.clip_info.height = m_Param.Height;
    if (m_Param.sprite_enable == IPPVC_SPRITE_STATIC) {
        info.clip_info.width = m_Param.sprite_width;
        info.clip_info.height = m_Param.sprite_height;
    }
    info.framerate = (Ipp64f)m_Param.TimeResolution / m_Param.TimeIncrement;
    info.bitrate = (m_Param.RateControl > 0) ? m_Param.BitRate : 0;
    return UMC_OK;
}

} // namespace UMC

#endif //defined (UMC_ENABLE_MPEG4_VIDEO_ENCODER)