mp4emblk.c

Linux下的基于intel的ipp库的MPEG4编码程序

            pred_type);
        if (ippStsNoErr != ret_code) {
            return ret_code;
        }

        refer_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;        
    }
   
    /* 3. computer the texture error of luminance and chrominance blocks */
    /* src reference block after motion compensation */
    refer_blk = enc_state->blk_ref_buf;
    /* dst texture residuals of current inter macro block */
    resid_blk = enc_state->resid_buf;
    sad[0] = sad[1] = sad[2] = sad[3] = sad[4] = sad[5] = 0;
    
    for (blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {
        
        switch (blk_indx) {
        case U_BLOCK:
            src_blk = vop_infor->cur_mb.cb_ptr;
            step = u_step;
            break;
        case V_BLOCK:
            src_blk = vop_infor->cur_mb.cr_ptr;
            step = v_step;
            break;
        default:
            src_blk = vop_infor->cur_mb.y_ptr + (blk_indx & 1) * 8
                + (blk_indx >> 1) * y_step * 8;
            step = y_step;
        }
        
        /* compute texture error residuals of the block */
        /* src_blk, refer_blk and resid_blk must be 8 byte aligned */
        ret_code = ippiComputeTextureErrorBlock_SAD_8u16s (
            src_blk,
            step,
            refer_blk,
            resid_blk,
            &(sad[blk_indx]));
        if (ippStsNoErr != ret_code) {
            return ret_code;
        }

        refer_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;
        resid_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE; 
    }
    
    if(Q_H263 == enc_state->quant_type) {
        for(blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {
            if(sad[blk_indx] < MPEG4_ENCODE_THRESHOLD_Q_H263 * vop_infor->cur_qp) {
                sad[blk_indx] = 0;
            }
        }		
    } else if(Q_MPEG4 == enc_state->quant_type) {
        for(blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {
            if(sad[blk_indx] < MPEG4_ENCODE_THRESHOLD_Q_MPEG * vop_infor->cur_qp) {
                sad[blk_indx] = 0;
            }
        }		
    }
    
    /* 4. begin the macro block encoding */
    /* src texture residuals to be encoded of current inter macro block */
    resid_blk	  = enc_state->resid_buf;
    /* dst quantized DCT coefficients */
    coeff_blk     = enc_state->blk_coef_buf;
    /* dst reconstructed texture residuals */
    rec_resid_blk = enc_state->rec_resid_buf;    
    
    for (blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {

        if(sad[blk_indx]) {

            ret_code = encode_block_inter_mpeg4(
                resid_blk,
                rec_resid_blk,
                coeff_blk,
                vop_infor->cur_qp,
                enc_state->qmatrix_inter);

            if (ippStsNoErr != ret_code) {
                return ret_code;
            }
        }

        resid_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;
        coeff_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;
        rec_resid_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;
    }
    
    /* 5. compute the associated head information */
    /* src quantized DCT coefficients */
    coeff_blk = enc_state->blk_coef_buf;
    
    /* determine mb_not_coded */
    vop_infor->mb_not_coded = 1;
    for (blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {
        
        if (Y_BLOCK4 >= blk_indx) {
            if (mv_cur_mb[blk_indx].dx || mv_cur_mb[blk_indx].dy) {
                vop_infor->mb_not_coded = 0;
            }
        }
        
        vop_infor->pattern_buf[blk_indx] = FALSE;
        if (sad[blk_indx]) {
            for (i = 0; i < SAMPLE_VIDEO_BLOCK_SQUARE_SIZE; i++) {
                if (coeff_blk[blk_indx * SAMPLE_VIDEO_BLOCK_SQUARE_SIZE + i]) {
                    vop_infor->pattern_buf[blk_indx] = TRUE;
                    vop_infor->mb_not_coded = 0;
                    break;
                }
            }
        }
    }

    /* determine cbpc */
    vop_infor->cbpc = vop_infor->pattern_buf[U_BLOCK] << 1 |
        vop_infor->pattern_buf[V_BLOCK];
    
    /* determine cbpy */
    /* For RECTANGULAR shape, each macroblock must have four opaque blocks */
    vop_infor->num_non_trans_blk = 4;
    vop_infor->cbpy = 0;
    for (blk_indx = Y_BLOCK1; blk_indx <= Y_BLOCK4; blk_indx++) {
        vop_infor->cbpy |= vop_infor->pattern_buf[blk_indx]
            << (vop_infor->num_non_trans_blk - 1 - blk_indx);
    }

    /* 6. Dump out MB level information */
    ret_code = create_mb_mpeg4(stream_buf, enc_state, vop_infor);
    if (SAMPLE_STATUS_NOERR != ret_code) {
        return ret_code;
    }
    
    if (!vop_infor->mb_not_coded) {

        /* 7. encode and motion vector and texture residuals */
        /* encode the motion vector */
        mv_left_mb  = mv_cur_mb - 4;
        mv_top_mb   = mv_cur_mb - (enc_state->mb_per_row + 2) * 4;
        mv_top_right_mb = mv_top_mb + 4;
        
        ret_code = ippiEncodeMV_MPEG4_8u16s(
            &stream_buf->bs_cur_byte,
            &stream_buf->bs_cur_bitoffset,
            mv_cur_mb,
            mv_left_mb,
            mv_top_mb,
            mv_top_right_mb,
            transp_cur_mb,
            vop_infor->tranp_buf,
            vop_infor->tranp_buf + 4,
            vop_infor->tranp_buf + 8,
            vop_infor->fcode_fwd,
            vop_infor->mb_type);
        if (ippStsNoErr != ret_code) {
            return ret_code;
        }
        
        /* zigzag scan and vlc encoding of the texture residuals */
        /* src quantized DCT coefficients */
        coeff_blk = enc_state->blk_coef_buf;
        
        for (blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {
            
            ret_code = ippiEncodeVLCZigzag_Inter_MPEG4_16s1u(
                &stream_buf->bs_cur_byte,
                &stream_buf->bs_cur_bitoffset,
                coeff_blk,
                vop_infor->pattern_buf[blk_indx]);
            if (ippStsNoErr != ret_code) {
                return ret_code;
            }
            coeff_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;
        }

        
        /* 8. reconstruct the texture and store into recon plane */
        /* src reference block after motion compensation */
        refer_blk     = enc_state->blk_ref_buf;
        /* src reconstructed texture residuals */
        rec_resid_blk = enc_state->rec_resid_buf;
        
        for (blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx ++) {

            switch (blk_indx) {
            case U_BLOCK:
                dst_blk = vop_infor->rec_mb.cb_ptr;
                step = u_step;
                break;
            case V_BLOCK:
                dst_blk = vop_infor->rec_mb.cr_ptr;
                step = v_step;
                break;
            default:
                dst_blk = vop_infor->rec_mb.y_ptr + (blk_indx & 1) * 8
                    + (blk_indx >> 1) * y_step * 8;
                step = y_step;
                break;
            }
            
            if(vop_infor->pattern_buf[blk_indx]) {
                /* refer_blk, rec_resid_blk, dst_blk must be 8 bytes aligned */
				for (j = 0; j < 8; j ++, refer_blk += 8, dst_blk += step, rec_resid_blk += 8) {
					for(k = 0; k < 8; k ++) {
						dst_blk[k] = CLIP_MP4_8U( ((int)refer_blk[k] + (int)rec_resid_blk[k]) );
					}
				}
            } else {
                /* refer_blk, dst_blk must be 8 bytes aligned */
				for (j = 0; j < 8; j ++, refer_blk += 8, dst_blk += step) {
					for(k = 0; k < 8; k ++) {
					   dst_blk[k] = refer_blk[k];
					}
				}
				rec_resid_blk += SAMPLE_VIDEO_BLOCK_SQUARE_SIZE;            
            }
        }
    
    } else {

        /* 8. reconstruct the texture and store into recon plane */
        /* src reference block after motion compensation */
        refer_blk = enc_state->blk_ref_buf;

        for(blk_indx = Y_BLOCK1; blk_indx <= V_BLOCK; blk_indx++) {
            switch (blk_indx) {
            case U_BLOCK:
                dst_blk = vop_infor->rec_mb.cb_ptr;
                step = u_step;
                break;
            case V_BLOCK:
                dst_blk = vop_infor->rec_mb.cr_ptr;
                step = v_step;
                break;
            default:
                dst_blk = vop_infor->rec_mb.y_ptr + (blk_indx & 1) * 8
                    + (blk_indx >> 1) * y_step * 8;
                step = y_step;
                break;
            }
            /* refer_blk, dst_blk must be 8 bytes aligned */
			for (j = 0; j < 8; j ++, refer_blk += 8, dst_blk += step) {
				for(k = 0; k < 8; k ++) {
				   dst_blk[k] = refer_blk[k];
				}
			}
        }
    }
    
    /* update dc/ac prediction coefficient row and column buffer
    // take y plane for example:
    // coef_buf_row[0] <- dc coefficient of block 3
    // coef_buf_row[8] <- dc coefficient of block 2
    // coef_buf_col[8] <- dc coefficient of block 4
    // the above three dc coefficient values should be set as -1 to imply
    // it's an INTER MB, besides that there're still two dc coefficients
    // which need to be updated
    // coef_buf_row[-8] <- coef_buf_col[8]
    // coef_buf_col[0]  <- coef_buf_row[8] */
    
    *(vop_infor->coef_buf_col.y_ptr) = *(vop_infor->coef_buf_row.y_ptr
            + SAMPLE_VIDEO_BLOCK_SIZE);
    *(vop_infor->coef_buf_row.y_ptr - SAMPLE_VIDEO_BLOCK_SIZE) =
        *(vop_infor->coef_buf_col.y_ptr + SAMPLE_VIDEO_BLOCK_SIZE);
    *(vop_infor->coef_buf_row.y_ptr) = -1;
    *(vop_infor->coef_buf_row.y_ptr + SAMPLE_VIDEO_BLOCK_SIZE) = -1;
    *(vop_infor->coef_buf_col.y_ptr + SAMPLE_VIDEO_BLOCK_SIZE) = -1;
    
    *(vop_infor->coef_buf_col.cb_ptr) = *(vop_infor->coef_buf_row.cb_ptr);
    *(vop_infor->coef_buf_row.cb_ptr) = -1;
    
    *(vop_infor->coef_buf_col.cr_ptr) = *(vop_infor->coef_buf_row.cr_ptr);
    *(vop_infor->coef_buf_row.cr_ptr) = -1;

     return SAMPLE_STATUS_NOERR;
}