Home | History | Annotate | Download | only in encoder
      1 /*
      2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 
     12 #include "vpx_config.h"
     13 #include "vp8_rtcd.h"
     14 #include "quantize.h"
     15 #include "vp8/common/reconintra4x4.h"
     16 #include "encodemb.h"
     17 #include "vp8/common/invtrans.h"
     18 #include "encodeintra.h"
     19 
     20 
     21 int vp8_encode_intra(VP8_COMP *cpi, MACROBLOCK *x, int use_dc_pred)
     22 {
     23 
     24     int i;
     25     int intra_pred_var = 0;
     26     (void) cpi;
     27 
     28     if (use_dc_pred)
     29     {
     30         x->e_mbd.mode_info_context->mbmi.mode = DC_PRED;
     31         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
     32         x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
     33 
     34         vp8_encode_intra16x16mby(x);
     35 
     36         vp8_inverse_transform_mby(&x->e_mbd);
     37     }
     38     else
     39     {
     40         for (i = 0; i < 16; i++)
     41         {
     42             x->e_mbd.block[i].bmi.as_mode = B_DC_PRED;
     43             vp8_encode_intra4x4block(x, i);
     44         }
     45     }
     46 
     47     intra_pred_var = vp8_get_mb_ss(x->src_diff);
     48 
     49     return intra_pred_var;
     50 }
     51 
     52 void vp8_encode_intra4x4block(MACROBLOCK *x, int ib)
     53 {
     54     BLOCKD *b = &x->e_mbd.block[ib];
     55     BLOCK *be = &x->block[ib];
     56     int dst_stride = x->e_mbd.dst.y_stride;
     57     unsigned char *dst = x->e_mbd.dst.y_buffer + b->offset;
     58     unsigned char *Above = dst - dst_stride;
     59     unsigned char *yleft = dst - 1;
     60     unsigned char top_left = Above[-1];
     61 
     62     vp8_intra4x4_predict(Above, yleft, dst_stride, b->bmi.as_mode,
     63                          b->predictor, 16, top_left);
     64 
     65     vp8_subtract_b(be, b, 16);
     66 
     67     x->short_fdct4x4(be->src_diff, be->coeff, 32);
     68 
     69     x->quantize_b(be, b);
     70 
     71     if (*b->eob > 1)
     72     {
     73       vp8_short_idct4x4llm(b->dqcoeff, b->predictor, 16, dst, dst_stride);
     74     }
     75     else
     76     {
     77       vp8_dc_only_idct_add(b->dqcoeff[0], b->predictor, 16, dst, dst_stride);
     78     }
     79 }
     80 
     81 void vp8_encode_intra4x4mby(MACROBLOCK *mb)
     82 {
     83     int i;
     84 
     85     MACROBLOCKD *xd = &mb->e_mbd;
     86     intra_prediction_down_copy(xd, xd->dst.y_buffer - xd->dst.y_stride + 16);
     87 
     88     for (i = 0; i < 16; i++)
     89         vp8_encode_intra4x4block(mb, i);
     90     return;
     91 }
     92 
     93 void vp8_encode_intra16x16mby(MACROBLOCK *x)
     94 {
     95     BLOCK *b = &x->block[0];
     96     MACROBLOCKD *xd = &x->e_mbd;
     97 
     98     vp8_build_intra_predictors_mby_s(xd,
     99                                          xd->dst.y_buffer - xd->dst.y_stride,
    100                                          xd->dst.y_buffer - 1,
    101                                          xd->dst.y_stride,
    102                                          xd->dst.y_buffer,
    103                                          xd->dst.y_stride);
    104 
    105     vp8_subtract_mby(x->src_diff, *(b->base_src),
    106         b->src_stride, xd->dst.y_buffer, xd->dst.y_stride);
    107 
    108     vp8_transform_intra_mby(x);
    109 
    110     vp8_quantize_mby(x);
    111 
    112     if (x->optimize)
    113         vp8_optimize_mby(x);
    114 }
    115 
    116 void vp8_encode_intra16x16mbuv(MACROBLOCK *x)
    117 {
    118     MACROBLOCKD *xd = &x->e_mbd;
    119 
    120     vp8_build_intra_predictors_mbuv_s(xd, xd->dst.u_buffer - xd->dst.uv_stride,
    121                                       xd->dst.v_buffer - xd->dst.uv_stride,
    122                                       xd->dst.u_buffer - 1,
    123                                       xd->dst.v_buffer - 1,
    124                                       xd->dst.uv_stride,
    125                                       xd->dst.u_buffer, xd->dst.v_buffer,
    126                                       xd->dst.uv_stride);
    127 
    128     vp8_subtract_mbuv(x->src_diff, x->src.u_buffer,
    129         x->src.v_buffer, x->src.uv_stride, xd->dst.u_buffer,
    130         xd->dst.v_buffer, xd->dst.uv_stride);
    131 
    132     vp8_transform_mbuv(x);
    133 
    134     vp8_quantize_mbuv(x);
    135 
    136     if (x->optimize)
    137         vp8_optimize_mbuv(x);
    138 }
    139