umc_h264_crc.cpp

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

            we assume here that encoder will skip (not to encode at all)
            the next frame from the source sequence
        */
    }
#endif
    if (queue_size && cur_frame_number%queue_size==0)
    {
        if (cur_frame_number==queue_size && queue_size)
        {
            RCDebugBuf((rc_debug_temp,"=========================================================================\n"));
            RCDebugBuf((rc_debug_temp,"frnums\tqstart\tqend\tqcbits\tqrbits\ticfrms\n"));
            RCDebugBuf((rc_debug_temp,"=========================================================================\n"));
        }
        else if(cur_frame_number>queue_size)
        {
            RCDebugBuf((rc_debug_temp,"%d-%d\t%I64d\t%I64d\t%I64d\t%I64d\t%d\n",
                cur_frame_number-queue_size,
                cur_frame_number,
                queue_start_bits,
                bits_encoded,
                queue_bits,
                bits_encoded-queue_start_bits,
                intra_coded_frames_in_queue));
        }
    }
    return bits_stuffed;
}

CH264ConstRateControl::CH264ConstRateControl(Ipp32u c_width,Ipp32u c_height,Ipp32u c_pitch,Ipp32u target_bps,Ipp32u _qp_min,Ipp32u _qp_max)
{
    model = new RDModel[4];
    model_mbI = new RDModel;
    model_mbP = new RDModel;
    pitch = c_pitch;
    width = c_width;
    height = c_height;
    width_mb = width/16;
    height_mb = height/16;
    mb_count = width_mb * height_mb;
    mbs = new RateMacroblock [mb_count];
    target_bits_per_second = target_bps;
    bpp = (Ipp64f)target_bits_per_second / 30.0 /
            height / width;
    qp_min=_qp_min;
    qp_max=_qp_max;
    intra_qp_max=(Ipp32u)(qp_max*INTRA_QP_WEIGHT);
    frames_coded[0]=frames_coded[1]=frames_coded[2]=frames_coded[3]=frames_coded[4]=0;
    last_intra_frame = 0;
}
void CH264ConstRateControl::SetRateControlOptions(H264AdvRate_Options *options)
{
    qp_min = options->min_qp;
    qp_max = options->max_qp;
    intra_qp_max = options->max_intra_qp;
    dqp_max = options->max_dqp;
    queue_size = options->queue_size;
    min_frs = options->min_fsize;
    max_frs = options->max_fsize;
    i_frames_mult = options->i_frames_mult;
    RCDebug((rc_debug_temp,"bps=%d qp_min=%d qp_max=%d,i_qp_max=%d min_frs=%.3lf max_frs=%.3lf\n",
        target_bits_per_second,qp_min,qp_max,intra_qp_max,
        min_frs,max_frs));
}

#define MB_SAD_THRESHOLD_MAX 512
#define MB_SAD_THRESHOLD_MID 256
#define MB_SAD_THRESHOLD_MIN 128
#ifdef COLLECT_MVS
#include<vm_debug.h>
#endif
Ipp32u CH264ConstRateControl::MacroblockRateControl(Ipp32s mb_number,
                                                    Ipp32s mb_type,
                                                    Ipp64s bits_encoded,
                                                    Ipp32u mb_sad)
{
    Ipp32s mb_bits=0;
    Ipp32s prev_mb_bits=0;
#ifndef COLLECT_MVS
    mbs[mb_number].type=mb_type;
#endif
    mbs[mb_number].mb_sad = mb_sad;
    /* mb-level */
    /*
    we assume here:
        complexity of every macroblock is known before decoding the first one.
    we need to do here:
        -- on first MB calc S = SUM(mb_weights[i]*mb_coplexity[i])
        -- if not first macroblock:
              - update statistics (don't forget skipped MBs):
                    S, rest bits for frame and etc.
              - if frame_quant was used, update the R-D model:
                    A1, or (A2, A3, A3_X11)
        -- target bits calculation
              target_mb_bits[i] = mb_weights[i]*mb_coplexity[i] / S
        - quantization parameter calculation
            - in case of high bitrate
              frame_quant = mb_complexity[i] * sqrt(A1/target_mb_bits[i])
            - in case of low bitrate
              need to solv: A2/SQR(frame_quant) + A3/frame_quant = target_mb_bits[i] / mb_coplexity[i]
              when there is no root, frame_quant = A3_X11 * mb_coplexity[i] / target_mb_bits[i];
    */

    if(mb_number == 0)
    {
        Ipp32u i, j, index;
        SI = SP=  0.0;
        for(i=0,index=0; i<height_mb; i++)
            for(j=0; j<width_mb; j++,index++)
            {
                    SI += mbs[index].mb_weight * MB_COMPLEXITY(index) ;
                    SP += mbs[index].mb_weight * MB_COMPLEXITY2(index) ;
            }
        last_mb_frame_quant = frame_quant_cur;
        last_mb_bit_pos =  bits_encoded;
    }
    else
    { // mb_number > 0
        int i;
        /* update counters */
        prev_mb_bits = (Ipp32s)(bits_encoded - last_mb_bit_pos);
        last_mb_bit_pos =  bits_encoded;
        frm_bits_rest -= prev_mb_bits;
        /* remove skipped MBs as well */
        if ((mbs[mb_number].type<=MBTYPE_PCM) &&(cur_frame_type!=INTRAPIC))
        {
            SI-=mbs[mb_number].mb_weight*MB_COMPLEXITY(mb_number);
            SI+=mbs[mb_number].mb_weight*UpdateMBComplexity(mb_number);
        }
        for(i=last_mb_number; i<mb_number; i++)
        {
            SI -= mbs[i].mb_weight * MB_COMPLEXITY(i);
            SP -= mbs[i].mb_weight * MB_COMPLEXITY2(i);
            frm_mbs_skipped++;
        }
        frm_mbs_skipped--;

        /*
            we assume as skipped MBs which haven't used frame_quant when being encoded
        */
        if( prev_mb_bits<2 || /* skipped after quantization */
            mbs[last_mb_number].type > MBTYPE_PCM &&
            mbs[last_mb_number].pattern==0
                /* MV values were ecoded only */
           )
        {
            frm_mbs_skipped++;
            mbs[last_mb_number].quant = 0;
        }
        else
        {
            // ordinary MB
            last_mb_frame_quant= frame_quant_cur;

            if(bpp > MB_MODEL_BITRATE_THRESHOLD)
            {
                /* high bit rate */
                Ipp64f last_A1I = (Ipp64f)prev_mb_bits * SQR(last_mb_frame_quant) /
                                  SQR(MB_COMPLEXITY(last_mb_number));
                /**/
                A1I = (A1I*(mb_number - frm_mbs_skipped - 1) + last_A1I) /
                          (mb_number - frm_mbs_skipped);

                Ipp64f last_A1P = (Ipp64f)prev_mb_bits * SQR(last_mb_frame_quant) /
                                  SQR(MB_COMPLEXITY2(last_mb_number));
                /**/
                A1P = (A1P*(mb_number - frm_mbs_skipped - 1) + last_A1P) /
                          (mb_number - frm_mbs_skipped);
                /**/
            }
            else
            {
                /* low bit rate */
                model_mbI->Q.q_push_force(last_mb_frame_quant);
                model_mbI->R.q_push_force(prev_mb_bits);
                model_mbI->E.q_push_force(MB_COMPLEXITY(last_mb_number));
                RD_update_mb(*model_mbI);
                model_mbP->Q.q_push_force(last_mb_frame_quant);
                model_mbP->R.q_push_force(prev_mb_bits);
                model_mbP->E.q_push_force(MB_COMPLEXITY2(last_mb_number));
                RD_update_mb(*model_mbP);
            }
            /* calc frame_quant */

            /*if ((mbs[mb_number].type<=MBTYPE_PCM) &&(cur_frame_type!=INTRAPIC))
            {
                frm_bits_rest+=(Ipp64f)frm_bits_rest * mbs[mb_number].mb_weight *
                          MB_COMPLEXITY(mb_number) / S;
                mb_bits = (Ipp64f)frm_bits_rest * mbs[mb_number].mb_weight * 2 *
                          MB_COMPLEXITY(mb_number) / S + .5;

            }
            else*/
            {
#ifdef COLLECT_MVS
                if (mbs[mb_number].type<=MBTYPE_PCM)
                {
                    mb_bits = (Ipp64f)frm_bits_rest * mbs[mb_number].mb_weight  *
                              MB_COMPLEXITY(mb_number) / SI + .5;
                }
                else
                {
                    mb_bits = (Ipp64f)frm_bits_rest * mbs[mb_number].mb_weight  *
                              MB_COMPLEXITY2(mb_number) / SP + .5;
                }
#else
                    mb_bits = (Ipp32s)((Ipp64f)frm_bits_rest * mbs[mb_number].mb_weight  *
                              MB_COMPLEXITY(mb_number) / SI + .5);
#endif

            }
            if(mb_bits <= 0)
            {
                frame_quant_cur = qp_max;
            }
            else
            {
                if(bpp > MB_MODEL_BITRATE_THRESHOLD)
                {
                    /* high bit rate model */
#ifndef COLLECT_MV
                        frame_quant_cur = (Ipp32u)(MB_COMPLEXITY(mb_number) * sqrt( A1I / mb_bits ));
#else
                    if (mbs[mb_number].type<=MBTYPE_PCM)
                    {
                        frame_quant_cur = MB_COMPLEXITY(mb_number) * sqrt( A1I / mb_bits );
                    }
                    else
                    {
                        frame_quant_cur = MB_COMPLEXITY2(mb_number) * sqrt( A1P / mb_bits );
                    }
#endif
                }
                else
                {
                    /* low bit rate model */
#ifndef COLLECT_MV
                    frame_quant_cur = solve_quant_equation( *model_mbI, mb_bits,
                                                              MB_COMPLEXITY(mb_number) );
#else
                    if (mbs[mb_number].type<=MBTYPE_PCM)
                    {
                        frame_quant_cur = solve_quant_equation( *model_mbI, mb_bits,
                                                                  MB_COMPLEXITY(mb_number) );
                    }
                    else
                    {
                        frame_quant_cur = solve_quant_equation( *model_mbP, mb_bits,
                                                                  MB_COMPLEXITY2(mb_number) );

                    }
#endif
                }
            }
        }
    }
    last_mb_number = mb_number;

        RCDebugMB((rc_debug_temp,"%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%.3lf\t%.3lf\t%.3lf\t%.3lf\n",
            cur_frame_number,
            mb_number,
            mb_bits,
            prev_mb_bits,
            MB_COMPLEXITY(mb_number),
            frame_quant_cur,
            mbs[mb_number].type,
            frm_bits_rest,A1I,A1P,SI,SP));
        /* clipping */
        frame_quant_cur = min(frame_quant_cur, qp_max);
        frame_quant_cur = max(frame_quant_cur, qp_min);
        /* additianal clipping to hold CQ */
        if (dqp_max)
        {
            frame_quant_cur  = max(frame_quant_cur , last_mb_frame_quant-dqp_max);
            frame_quant_cur  = min(frame_quant_cur , last_mb_frame_quant+dqp_max);
        }
        /*
        if (mb_type<=MBTYPE_PCM || mb_sad>MB_SAD_THRESHOLD_MIN)
        {
            frame_quant_cur = min(frame_quant_cur, (intra_qp_max+qp_max*2)/3);
        }

        if (mb_type<=MBTYPE_PCM || mb_sad>MB_SAD_THRESHOLD_MID)
        {
            frame_quant_cur = min(frame_quant_cur, (intra_qp_max+qp_max)/2);
        }

        if (mb_type<=MBTYPE_PCM || mb_sad>MB_SAD_THRESHOLD_MAX)
        {
            frame_quant_cur = min(frame_quant_cur, intra_qp_max);
        }*/
        if (mb_type<=MBTYPE_PCM)
        {
            frame_quant_cur = min(frame_quant_cur, intra_qp_max);
        }
        mbs[mb_number].quant=frame_quant_cur;
    return mbs[mb_number].quant;
}

Ipp32u CH264ConstRateControl::PostMacroblockRateControl(Ipp32s mb_number,
                                                        Ipp64s , // bits_encoded,
                                                        Ipp32u actual_quant,
                                                        Ipp32u cbp)
{
    RCDebugMBQ((rc_debug_temp, "%d %d %d\n", cur_frame_number, mb_number, actual_quant));
    mbs[mb_number].quant=actual_quant;
    mbs[mb_number].pattern=cbp;
    return 0;
}


} //namespace UMC