t264enc.c

经过开源的H.264压缩算法代码

                    memset(&dst[t->stride + EDGED_WIDTH + 2], src[t->stride - 1 + 3 + 2], EDGED_WIDTH - 2);
                    dst += t->edged_stride;
                    src += t->edged_stride;
                }
                // top
                dst = f->Y[3] - EDGED_HEIGHT * t->edged_stride - EDGED_WIDTH;
                src = f->Y[3] - EDGED_WIDTH;
                for(i = 0 ; i < EDGED_HEIGHT ; i ++)
                {
                    memcpy(dst, src, t->edged_stride);
                    dst += t->edged_stride;
                }
                // bottom
                src = f->Y[3] + (t->height - 1) * t->edged_stride - EDGED_WIDTH;
                dst = src + t->edged_stride;
                for(i = 0 ; i < EDGED_HEIGHT ; i ++)
                {
                    memcpy(dst, src, t->edged_stride);
                    dst += t->edged_stride;
                }
            }
        }
        else
        {
            src_offset = - 3 * t->edged_stride - 3;
            width      = t->width + 3 + 2;
            height     = t->height + 3 + 2;
            t->interpolate_halfpel_hv(f->Y[0] + src_offset, t->edged_stride, f->Y[3] + src_offset, t->edged_stride, width, height);
            // extend border
            {
                uint8_t* src, *dst;
                int32_t i;
                // left & right
                dst = f->Y[3] - 3 * t->edged_stride - EDGED_WIDTH;
                src = f->Y[3] - 3 * t->edged_stride - 3;
                for(i = 0 ; i < t->height + 3 + 2 ; i ++)
                {
                    // left
                    memset(dst, src[0], EDGED_WIDTH - 3);
                    // right
                    memset(&dst[t->stride + EDGED_WIDTH + 2], src[t->stride - 1 + 3 + 2], EDGED_WIDTH - 2);
                    dst += t->edged_stride;
                    src += t->edged_stride;
                }
                // top
                dst = f->Y[3] - EDGED_HEIGHT * t->edged_stride - EDGED_WIDTH;
                src = f->Y[3] - 3 * t->edged_stride - EDGED_WIDTH;
                for(i = 0 ; i < EDGED_HEIGHT - 3 ; i ++)
                {
                    memcpy(dst, src, t->edged_stride);
                    dst += t->edged_stride;
                }
                // bottom
                src = f->Y[3] + (t->height + 2 - 1) * t->edged_stride - EDGED_WIDTH;
                dst = src + t->edged_stride;
                for(i = 0 ; i < EDGED_HEIGHT - 2 ; i ++)
                {
                    memcpy(dst, src, t->edged_stride);
                    dst += t->edged_stride;
                }
            }
        }
    }
}


void
T264_init_cpu(T264_t* t)
{

    t->pred16x16[Intra_16x16_TOP]    = T264_predict_16x16_mode_0_c;
    t->pred16x16[Intra_16x16_LEFT]   = T264_predict_16x16_mode_1_c;
    t->pred16x16[Intra_16x16_DC]     = T264_predict_16x16_mode_2_c;
    t->pred16x16[Intra_16x16_PLANE]  = T264_predict_16x16_mode_3_c;
    t->pred16x16[Intra_16x16_DCTOP]  = T264_predict_16x16_mode_20_c;
    t->pred16x16[Intra_16x16_DCLEFT] = T264_predict_16x16_mode_21_c;
    t->pred16x16[Intra_16x16_DC128]  = T264_predict_16x16_mode_22_c;
    
    t->pred8x8[Intra_8x8_TOP]    = T264_predict_8x8_mode_0_c;
    t->pred8x8[Intra_8x8_LEFT]   = T264_predict_8x8_mode_1_c;
    t->pred8x8[Intra_8x8_DC]     = T264_predict_8x8_mode_2_c;
    t->pred8x8[Intra_8x8_PLANE]  = T264_predict_8x8_mode_3_c;
    t->pred8x8[Intra_8x8_DCTOP]  = T264_predict_8x8_mode_20_c;
    t->pred8x8[Intra_8x8_DCLEFT] = T264_predict_8x8_mode_21_c;
    t->pred8x8[Intra_8x8_DC128]  = T264_predict_8x8_mode_22_c;

    t->pred4x4[Intra_4x4_TOP]    = T264_predict_4x4_mode_0_c;
    t->pred4x4[Intra_4x4_LEFT]   = T264_predict_4x4_mode_1_c;
    t->pred4x4[Intra_4x4_DC]     = T264_predict_4x4_mode_2_c;
    t->pred4x4[Intra_4x4_DCTOP]  = T264_predict_4x4_mode_20_c;
    t->pred4x4[Intra_4x4_DCLEFT] = T264_predict_4x4_mode_21_c;
    t->pred4x4[Intra_4x4_DC128]  = T264_predict_4x4_mode_22_c;

    t->pred4x4[Intra_4x4_DIAGONAL_DOWNLEFT]  = T264_predict_4x4_mode_3_c;
    t->pred4x4[Intra_4x4_DIAGONAL_DOWNRIGHT]  = T264_predict_4x4_mode_4_c;
    t->pred4x4[Intra_4x4_VERTICAL_RIGHT]  = T264_predict_4x4_mode_5_c;
    t->pred4x4[Intra_4x4_HORIZONTAL_DOWN]  = T264_predict_4x4_mode_6_c;
    t->pred4x4[Intra_4x4_VERTICAL_LEFT]  = T264_predict_4x4_mode_7_c;
    t->pred4x4[Intra_4x4_HORIZONTAL_UP]  = T264_predict_4x4_mode_8_c;

    if (t->flags & USE_SAD)
    {
        t->cmp[MB_16x16] = T264_sad_u_16x16_c;
        t->cmp[MB_16x8]  = T264_sad_u_16x8_c;
        t->cmp[MB_8x16]  = T264_sad_u_8x16_c;
        t->cmp[MB_8x8]   = T264_sad_u_8x8_c;
        t->cmp[MB_8x4]   = T264_sad_u_8x4_c;
        t->cmp[MB_4x8]   = T264_sad_u_4x8_c;
        t->cmp[MB_4x4]   = T264_sad_u_4x4_c;
    }
    else
    {
        t->cmp[MB_16x16] = T264_satd_u_16x16_c;
        t->cmp[MB_16x8]  = T264_satd_u_16x8_c;
        t->cmp[MB_8x16]  = T264_satd_u_8x16_c;
        t->cmp[MB_8x8]   = T264_satd_u_8x8_c;
        t->cmp[MB_8x4]   = T264_satd_u_8x4_c;
        t->cmp[MB_4x8]   = T264_satd_u_4x8_c;
        t->cmp[MB_4x4]   = T264_satd_u_4x4_c;
    }

    t->sad[MB_16x16] = T264_sad_u_16x16_c;
    t->sad[MB_16x8]  = T264_sad_u_16x8_c;
    t->sad[MB_8x16]  = T264_sad_u_8x16_c;
    t->sad[MB_8x8]   = T264_sad_u_8x8_c;
    t->sad[MB_8x4]   = T264_sad_u_8x4_c;
    t->sad[MB_4x8]   = T264_sad_u_4x8_c;
    t->sad[MB_4x4]   = T264_sad_u_4x4_c;
    t->fdct4x4   = dct4x4_c;
    t->fdct4x4dc = dct4x4dc_c;
    t->fdct2x2dc = dct2x2dc_c;
    t->idct4x4   = idct4x4_c;
    t->idct4x4dc = idct4x4dc_c;
    t->idct2x2dc = idct2x2dc_c;

    t->quant4x4    = quant4x4_c;
    t->quant4x4dc  = quant4x4dc_c;
    t->quant2x2dc  = quant2x2dc_c;
    t->iquant4x4   = iquant4x4_c;
    t->iquant4x4dc = iquant4x4dc_c;
    t->iquant2x2dc = iquant2x2dc_c;

    t->expand8to16   = expand8to16_c;
    t->contract16to8 = contract16to8_c;
    t->contract16to8add = contract16to8add_c;
    t->expand8to16sub   = expand8to16sub_c;
    t->memcpy_stride_u = memcpy_stride_u_c;
    t->eighth_pixel_mc_u = T264_eighth_pixel_mc_u_c;

    t->interpolate_halfpel_h = interpolate_halfpel_h_c;
    t->interpolate_halfpel_v = interpolate_halfpel_v_c;
    t->interpolate_halfpel_hv = interpolate_halfpel_hv_c;

    //t->pixel_avg = T264_pixel_avg_c;  //modify by wushangyun for pia optimization
    t->pia[MB_16x16] = T264_pia_u_16x16_c;
    t->pia[MB_16x8]  = T264_pia_u_16x8_c;
    t->pia[MB_8x16]  = T264_pia_u_8x16_c;
    t->pia[MB_8x8]   = T264_pia_u_8x8_c;
    t->pia[MB_8x4]   = T264_pia_u_8x4_c;
    t->pia[MB_4x8]   = T264_pia_u_4x8_c;
    t->pia[MB_4x4]   = T264_pia_u_4x4_c;
    t->pia[MB_2x2]   = T264_pia_u_2x2_c;

    t->T264_satd_16x16_u = T264_satd_i16x16_u_c;
    
    
    // flags relative
    if (t->flags & USE_FULLSEARCH)
        t->search = T264_spiral_search_full;
    else if (t->flags & USE_DIAMONDSEACH)
        t->search = T264_search;
    else
        t->search = T264_search_full; 
}

static uint32_t
write_dst(uint8_t* src, int32_t nal_pos[4], int32_t nal_num, uint8_t* dst, int32_t dst_size)
{
    int32_t i, j, n;
    int32_t count;
    int32_t nal_len;

    n = 0;
    for(i = 0 ; i < nal_num - 1; i ++)
    {
        nal_len = nal_pos[i + 1] - nal_pos[i];
        
        // start code 00 00 00 01
        dst[n ++] = src[0];
        dst[n ++] = src[1];
        dst[n ++] = src[2];
        dst[n ++] = src[3];
        count = 0;
        for(j = 4 ; j < nal_len - 1; j ++)
        {
            if (src[j] == 0)
            {
                count ++;
                if (count >= 2 && src[j + 1] <= 3)
                {
                    dst[n ++] = 0;
                    dst[n ++] = 3;
                    count = 0;
                    continue;
                }
            }
            else
            {
                count = 0;
            }
            dst[n ++] = src[j];
        }
        dst[n ++] = src[j];
        src += nal_len;
    }

    return n;
}

///////////////////////////////////////////////////////////
// interface
T264_t*
T264_open(T264_param_t* para)
{
    T264_t* t;
    int32_t i;

    //
    // TODO: here check the input param if it is valid
    //
    if (para->flags & USE_FORCEBLOCKSIZE)
        para->flags |= USE_SUBBLOCK;
    if (para->flags & USE_QUARTPEL)
        para->flags |= USE_HALFPEL;

    t = T264_malloc(sizeof(T264_t), CACHE_SIZE);
    memset(t, 0, sizeof(T264_t));

    t->mb_width  = para->width >> 4;
    t->mb_height = para->height >> 4;
    t->mb_stride = t->mb_width;
    t->width  = t->mb_width << 4;
    t->height = t->mb_height << 4;
    t->edged_width = t->width + 2 * EDGED_WIDTH;
    t->edged_height = t->height + 2 * EDGED_HEIGHT;
    t->qp_y   = para->qp;
    t->flags  = para->flags;

    t->stride    = t->width;
    t->stride_uv = t->width >> 1;
    t->edged_stride = t->edged_width;
    t->edged_stride_uv = t->edged_width >> 1;

    t->bs = T264_malloc(sizeof(bs_t), CACHE_SIZE);
    t->bs_buf = T264_malloc(t->width * t->height << 1, CACHE_SIZE);
    para->direct_flag = 1;  /* force direct mode */
    if (para->b_num)
        para->ref_num ++;

    for(i = 0 ; i < para->ref_num + 1 ; i ++)
    {
        uint8_t* p = T264_malloc(t->edged_width * t->edged_height + (t->edged_width * t->edged_height >> 1), CACHE_SIZE);
        t->refn[i].Y[0] = p + EDGED_HEIGHT * t->edged_width + EDGED_WIDTH;
        t->refn[i].U = p + t->edged_width * t->edged_height + (t->edged_width * EDGED_HEIGHT >> 2) + (EDGED_WIDTH >> 1);
        t->refn[i].V = p + t->edged_width * t->edged_height + (t->edged_width * t->edged_height >> 2) + (t->edged_width * EDGED_HEIGHT >> 2) + (EDGED_WIDTH >> 1);
        t->refn[i].mb = T264_malloc(t->mb_height * t->mb_width * sizeof(T264_mb_context_t), CACHE_SIZE);
        p = T264_malloc(t->edged_width * t->edged_height * 3, CACHE_SIZE);
        t->refn[i].Y[1] = p + EDGED_HEIGHT * t->edged_width + EDGED_WIDTH;
        t->refn[i].Y[2] = t->refn[i].Y[1] + t->edged_width * t->edged_height;
        t->refn[i].Y[3] = t->refn[i].Y[2] + t->edged_width * t->edged_height;
    }
    for(i = 0 ; i < para->b_num ; i ++)
    {
        t->pending_bframes[i].Y[0] = T264_malloc(t->width * t->height + (t->width * t->height >> 1), CACHE_SIZE);
    }

    t->param = *para;
    t->idr_pic_id = -1;
    t->frame_id = 0;
    t->last_i_frame_id = 0;

    T264_init_cpu(t);    
    
    if (t->flags & USE_EXTRASUBPELSEARCH)
        t->subpel_pts = 8;
    else
        t->subpel_pts = 4;

    return t;
}

void
T264_close(T264_t* t)
{
    int32_t i;

    for(i = 0 ; i < t->param.ref_num + 1 ; i ++)
    {
        T264_free(t->refn[i].Y[0] - (EDGED_HEIGHT * t->edged_width + EDGED_WIDTH));
        T264_free(t->refn[i].mb);
        T264_free(t->refn[i].Y[1] - (EDGED_HEIGHT * t->edged_width + EDGED_WIDTH));
    }

    for(i = 0 ; i < t->plug_num ; i ++)
    {
        t->plugins[i].close(t, &t->plugins[i]);
    }

    for(i = 0 ; i < t->param.b_num ; i ++)
    {
        T264_free(t->pending_bframes[i].Y[0]);
    }
    T264_free(t->bs_buf);
    T264_free(t->bs);

    T264_free(t);	
}