umc_h264_video_encoder.cpp

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

//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2004 - 2007 Intel Corporation. All Rights Reserved.
//

#if defined _OPENMP
#include "omp.h"
#endif // _OPENMP

#include "umc_memory_allocator.h"
#include "umc_h264_video_encoder.h"
#include "umc_h264_pub.h"
#include "umc_h264_tables.h"
#include "umc_h264_deblocking_tools.h"
#include "vm_debug.h"

namespace UMC
{
    VideoEncoder *CreateH264Encoder()
    {
        VideoEncoder *enc;
        vm_debug_trace(VM_DEBUG_INFO, VM_STRING("CreateH264Encoder()"));
        enc = new H264VideoEncoder;
        return enc;
    }

    H264VideoEncoder::H264VideoEncoder()
    {
        m_CurrEncoderType = H264_VIDEO_ENCODER_NONE;
        m_pEncoder_8u_16s = NULL;  // For 8 bit video.

#if defined BITDEPTH_9_12
        m_pEncoder_16u_32s = NULL; // For 9-12 bit video.
#endif // BITDEPTH_9_12
    }

    H264VideoEncoder::~H264VideoEncoder()
    {
        if(m_pEncoder_8u_16s != NULL) {
            delete m_pEncoder_8u_16s;
            m_pEncoder_8u_16s = NULL;
        }
#if defined BITDEPTH_9_12
        if(m_pEncoder_16u_32s != NULL) {
            delete m_pEncoder_16u_32s;
            m_pEncoder_16u_32s = NULL;
        }
#endif // BITDEPTH_9_12
    }

    Status H264VideoEncoder::Init(BaseCodecParams *init)
    {
        Status res = UMC_OK;

        //Init base class (needed for external memory allocator)
        if( (res = BaseCodec::Init( init )) != UMC_OK ) return res;

        H264EncoderParams *info = DynamicCast<H264EncoderParams, BaseCodecParams> (init);
#if defined BITDEPTH_9_12
        if(info == NULL) {
            // 8 bits
            m_CurrEncoderType = H264_VIDEO_ENCODER_8U_16S;
            m_pEncoder_8u_16s = new H264CoreEncoder<Ipp8u, Ipp16s>(res);
            if(res != UMC_OK) return(res);
            return(m_pEncoder_8u_16s->Init(init, m_pMemoryAllocator));
        }
        if(info->bit_depth_luma > 8 || info->bit_depth_chroma > 8 ||
            (info->aux_format_idc && info->bit_depth_aux > 8)) {
            // 16 bits
                m_CurrEncoderType = H264_VIDEO_ENCODER_16U_32S;
                m_pEncoder_16u_32s = new H264CoreEncoder<Ipp16u, Ipp32s>(res);
                if(res != UMC_OK) return(res);
                return(m_pEncoder_16u_32s->Init(init, m_pMemoryAllocator));
        }
#endif // BITDEPTH_9_12
        // 8 bits
        m_CurrEncoderType = H264_VIDEO_ENCODER_8U_16S;
        m_pEncoder_8u_16s = new H264CoreEncoder<Ipp8u, Ipp16s>(res);
        if(res != UMC_OK) return(res);
        return(m_pEncoder_8u_16s->Init(init, m_pMemoryAllocator));
    }

Status H264VideoEncoder::GetFrame(MediaData *in, MediaData *out)
    {
        switch(m_CurrEncoderType) {
            case H264_VIDEO_ENCODER_8U_16S:
                return(m_pEncoder_8u_16s->GetFrame(in, out));
#if defined BITDEPTH_9_12
            case H264_VIDEO_ENCODER_16U_32S:
                return(m_pEncoder_16u_32s->GetFrame(in, out));
#endif // BITDEPTH_9_12
            default:
                return(UMC::UMC_ERR_NOT_INITIALIZED);
        }
    }

    Status H264VideoEncoder::GetInfo(BaseCodecParams *info)
    {
        switch(m_CurrEncoderType) {
            case H264_VIDEO_ENCODER_8U_16S:
                return(m_pEncoder_8u_16s->GetInfo(info));
#if defined BITDEPTH_9_12
            case H264_VIDEO_ENCODER_16U_32S:
                return(m_pEncoder_16u_32s->GetInfo(info));
#endif // BITDEPTH_9_12
            default:
                return(UMC::UMC_ERR_NOT_INITIALIZED);
        }
    }

    Status H264VideoEncoder::Close()
    {
        switch(m_CurrEncoderType) {
            case H264_VIDEO_ENCODER_8U_16S:
                return(m_pEncoder_8u_16s->Close());
#if defined BITDEPTH_9_12
            case H264_VIDEO_ENCODER_16U_32S:
                return(m_pEncoder_16u_32s->Close());
#endif // BITDEPTH_9_12
            default:
                return(UMC::UMC_ERR_NOT_INITIALIZED);
        }

        BaseCodec::Close();
    }

    Status H264VideoEncoder::SetParams(BaseCodecParams* params)
    {
        switch(m_CurrEncoderType) {
            case H264_VIDEO_ENCODER_8U_16S:
                return(m_pEncoder_8u_16s->SetParams(params));
#if defined BITDEPTH_9_12
            case H264_VIDEO_ENCODER_16U_32S:
                return(m_pEncoder_16u_32s->SetParams(params));
#endif // BITDEPTH_9_12
            default:
                return(UMC::UMC_ERR_NOT_INITIALIZED);
        }
    }

    VideoData* H264VideoEncoder::GetReconstructedFrame()
    {
        switch(m_CurrEncoderType) {
            case H264_VIDEO_ENCODER_8U_16S:
                return(m_pEncoder_8u_16s->GetReconstructedFrame());
#if defined BITDEPTH_9_12
            case H264_VIDEO_ENCODER_16U_32S:
                return(m_pEncoder_8u_16s->GetReconstructedFrame());
#endif // BITDEPTH_9_12
            default:
                return NULL;
        }
    }

    Status H264EncoderParams::ReadParamFile(const vm_char *FileName)
    {
#define SSCANF(N, X) if (N != vm_string_sscanf X) return UMC_ERR_INVALID_STREAM;

        vm_file* InputFile;
        vm_char line[256];
        Ipp32s arg0, arg1, arg2, arg3;
        Ipp32s frame_rate_code;

        InputFile = vm_file_open(FileName, VM_STRING("r"));
        if (!InputFile)
        {
            return UMC_ERR_OPEN_FAILED;
        }

        vm_file_fgets(line, 254, InputFile); // sequence name
        vm_file_fgets(line, 254, InputFile);
        //if (SrcFileName) SSCANF(1, (line, VM_STRING("%s"), SrcFileName));

        vm_file_fgets(line, 254, InputFile); SSCANF(1, (line, VM_STRING("%d"), &numFramesToEncode));
        vm_file_fgets(line, 254, InputFile); SSCANF(3, (line, VM_STRING("%d %d %d"),
            &key_frame_controls.method,
            &key_frame_controls.interval,
            &key_frame_controls.idr_interval
            ));

        vm_file_fgets(line, 254, InputFile); SSCANF(2, (line, VM_STRING("%d %d"), &B_frame_rate, &treat_B_as_reference));
        vm_file_fgets(line, 254, InputFile); SSCANF(3, (line, VM_STRING("%d %d %d"), &num_ref_frames, &num_ref_to_start_code_B_slice, &arg2));
        num_slices = (Ipp16s)arg2;
        vm_file_fgets(line, 254, InputFile); SSCANF(2, (line, VM_STRING("%d %d"), &arg0, &arg1));
        profile_idc = (H264_PROFILE_IDC)arg0;
        level_idc = (Ipp8s)arg1;

        vm_file_fgets(line, 254, InputFile); SSCANF(1, (line, VM_STRING("%d"), &info.clip_info.width));
        vm_file_fgets(line, 254, InputFile); SSCANF(1, (line, VM_STRING("%d"), &info.clip_info.height));
        vm_file_fgets(line, 254, InputFile); SSCANF(1, (line, VM_STRING("%d"), &frame_rate_code));
        vm_file_fgets(line, 254, InputFile); SSCANF(3, (line, VM_STRING("%d %d %d"),
            &chroma_format_idc, &bit_depth_luma, &bit_depth_chroma));
        vm_file_fgets(line, 254, InputFile); SSCANF(5, (line, VM_STRING("%d %d %d %d %d"),
            &aux_format_idc, &bit_depth_aux, &alpha_incr_flag, &alpha_opaque_value, &alpha_transparent_value));

        vm_file_fgets(line, 254, InputFile); SSCANF(5, (line,VM_STRING("%d %d %d %d %d"),
            &arg0, &arg1, &arg2, &arg3, &info.bitrate));

        rate_controls.method = (H264_Rate_Control_Method) arg0;
        rate_controls.quantI = (Ipp8s) arg1;
        rate_controls.quantP = (Ipp8s) arg2;
        rate_controls.quantB = (Ipp8s) arg3;

        vm_file_fgets(line, 254, InputFile); SSCANF(4, (line, VM_STRING("%d %d %d %d"),
            &mv_search_method,
            &me_split_mode,
            &me_search_x,
            &me_search_y
            ));

        vm_file_fgets(line, 254, InputFile); SSCANF(3, (line, VM_STRING("%d %d %d"),
            &use_weighted_pred,
            &use_weighted_bipred,
            &use_implicit_weighted_bipred
            ));

        vm_file_fgets(line, 254, InputFile); SSCANF(2, (line, VM_STRING("%d %d"), &arg0, &use_direct_inference));
        direct_pred_mode = (Ipp8s) arg0;
        vm_file_fgets(line, 254, InputFile); SSCANF(3, (line, VM_STRING("%d %d %d"),
            &arg0,
            &deblocking_filter_alpha,
            &deblocking_filter_beta));
        deblocking_filter_idc = (Ipp8s) arg0;
        deblocking_filter_alpha = deblocking_filter_alpha&~1; // must be even, since a value div2 is coded.
        deblocking_filter_beta = deblocking_filter_beta&~1;

        vm_file_fgets(line, 254, InputFile); SSCANF(3, (line, VM_STRING("%d %d %d"), &transform_8x8_mode_flag, &use_default_scaling_matrix, &qpprime_y_zero_transform_bypass_flag));
        vm_file_fgets(line, 254, InputFile); SSCANF(1, (line, VM_STRING("%d"), &arg0)); //Old design
        vm_file_fgets(line, 254, InputFile); SSCANF(1, (line, VM_STRING("%d"), &arg1));  //Old design