vp9_reconinter.h 9.13 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  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.
John Koleszar's avatar
John Koleszar committed
9 10
 */

11 12
#ifndef VP9_COMMON_VP9_RECONINTER_H_
#define VP9_COMMON_VP9_RECONINTER_H_
John Koleszar's avatar
John Koleszar committed
13

14
#include "vpx/vpx_integer.h"
15
#include "vp9/common/vp9_onyxc_int.h"
16

17 18
struct subpix_fn_table;

19
void vp9_build_inter_predictors_sby(MACROBLOCKD *xd,
20 21 22 23
                                    int mb_row,
                                    int mb_col,
                                    BLOCK_SIZE_TYPE bsize);

24
void vp9_build_inter_predictors_sbuv(MACROBLOCKD *xd,
25 26 27
                                     int mb_row,
                                     int mb_col,
                                     BLOCK_SIZE_TYPE bsize);
28

29 30 31
void vp9_build_inter_predictors_sb(MACROBLOCKD *mb,
                                   int mb_row, int mb_col,
                                   BLOCK_SIZE_TYPE bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
32

33 34 35
void vp9_setup_interp_filters(MACROBLOCKD *xd,
                              INTERPOLATIONFILTERTYPE filter,
                              VP9_COMMON *cm);
John Koleszar's avatar
John Koleszar committed
36

37 38 39 40
void vp9_setup_scale_factors_for_frame(struct scale_factors *scale,
                                       YV12_BUFFER_CONFIG *other,
                                       int this_w, int this_h);

41 42 43 44 45 46 47 48 49
void vp9_build_inter_predictor(const uint8_t *src, int src_stride,
                               uint8_t *dst, int dst_stride,
                               const int_mv *mv_q3,
                               const struct scale_factors *scale,
                               int w, int h, int do_avg,
                               const struct subpix_fn_table *subpix);

void vp9_build_inter_predictor_q4(const uint8_t *src, int src_stride,
                                  uint8_t *dst, int dst_stride,
50
                                  const int_mv *mv_q4,
51 52 53
                                  const struct scale_factors *scale,
                                  int w, int h, int do_avg,
                                  const struct subpix_fn_table *subpix);
54

55 56
static int scale_value_x_with_scaling(int val,
                                      const struct scale_factors *scale) {
57 58 59
  return val * scale->x_num / scale->x_den;
}

60 61
static int scale_value_y_with_scaling(int val,
                                      const struct scale_factors *scale) {
62 63 64
  return val * scale->y_num / scale->y_den;
}

65 66 67 68 69
static int unscaled_value(int val, const struct scale_factors *scale) {
  (void) scale;
  return val;
}

70 71 72 73
static int scaled_buffer_offset(int x_offset,
                                int y_offset,
                                int stride,
                                const struct scale_factors *scale) {
74 75 76 77 78 79 80 81
  if (scale)
    return scale->scale_value_y(y_offset, scale) * stride +
        scale->scale_value_x(x_offset, scale);
  return y_offset * stride + x_offset;
}

static void setup_pred_plane(struct buf_2d *dst,
                             uint8_t *src, int stride,
82
                             int mi_row, int mi_col,
83 84
                             const struct scale_factors *scale,
                             int subsampling_x, int subsampling_y) {
85 86
  const int x = (MI_SIZE * mi_col) >> subsampling_x;
  const int y = (MI_SIZE * mi_row) >> subsampling_y;
87 88 89 90 91 92 93
  dst->buf = src + scaled_buffer_offset(x, y, stride, scale);
  dst->stride = stride;
}

// TODO(jkoleszar): audit all uses of this that don't set mb_row, mb_col
static void setup_dst_planes(MACROBLOCKD *xd,
                             const YV12_BUFFER_CONFIG *src,
94
                             int mi_row, int mi_col) {
95 96
  setup_pred_plane(&xd->plane[0].dst,
                   src->y_buffer, src->y_stride,
97
                   mi_row, mi_col, NULL,
98 99 100
                   xd->plane[0].subsampling_x, xd->plane[0].subsampling_y);
  setup_pred_plane(&xd->plane[1].dst,
                   src->u_buffer, src->uv_stride,
101
                   mi_row, mi_col, NULL,
102 103 104
                   xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
  setup_pred_plane(&xd->plane[2].dst,
                   src->v_buffer, src->uv_stride,
105
                   mi_row, mi_col, NULL,
106
                   xd->plane[2].subsampling_x, xd->plane[2].subsampling_y);
107 108
}

109 110 111
static void setup_pre_planes(MACROBLOCKD *xd,
                             const YV12_BUFFER_CONFIG *src0,
                             const YV12_BUFFER_CONFIG *src1,
112
                             int mi_row, int mi_col,
113 114 115 116 117 118 119 120 121 122 123 124
                             const struct scale_factors *scale,
                             const struct scale_factors *scale_uv) {
  int i;

  for (i = 0; i < 2; i++) {
    const YV12_BUFFER_CONFIG *src = i ? src1 : src0;

    if (!src)
      continue;

    setup_pred_plane(&xd->plane[0].pre[i],
                     src->y_buffer, src->y_stride,
125
                     mi_row, mi_col, scale ? scale + i : NULL,
126 127 128
                     xd->plane[0].subsampling_x, xd->plane[0].subsampling_y);
    setup_pred_plane(&xd->plane[1].pre[i],
                     src->u_buffer, src->uv_stride,
129
                     mi_row, mi_col, scale_uv ? scale_uv + i : NULL,
130 131 132
                     xd->plane[1].subsampling_x, xd->plane[1].subsampling_y);
    setup_pred_plane(&xd->plane[2].pre[i],
                     src->v_buffer, src->uv_stride,
133
                     mi_row, mi_col, scale_uv ? scale_uv + i : NULL,
134 135 136 137
                     xd->plane[2].subsampling_x, xd->plane[2].subsampling_y);
  }
}

138 139
static void setup_pred_block(YV12_BUFFER_CONFIG *dst,
                             const YV12_BUFFER_CONFIG *src,
140
                             int mi_row, int mi_col,
141 142 143 144 145 146 147 148
                             const struct scale_factors *scale,
                             const struct scale_factors *scale_uv) {
  const int recon_y_stride = src->y_stride;
  const int recon_uv_stride = src->uv_stride;
  int recon_yoffset;
  int recon_uvoffset;

  if (scale) {
149
    recon_yoffset = scaled_buffer_offset(MI_SIZE * mi_col, MI_SIZE * mi_row,
150
                                         recon_y_stride, scale);
151 152
    recon_uvoffset = scaled_buffer_offset(MI_UV_SIZE * mi_col,
                                          MI_UV_SIZE * mi_row,
153 154
                                          recon_uv_stride, scale_uv);
  } else {
155 156 157
    recon_yoffset = MI_SIZE * mi_row * recon_y_stride + MI_SIZE * mi_col;
    recon_uvoffset = MI_UV_SIZE * mi_row * recon_uv_stride +
                     MI_UV_SIZE * mi_col;
158
  }
159

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
  *dst = *src;
  dst->y_buffer += recon_yoffset;
  dst->u_buffer += recon_uvoffset;
  dst->v_buffer += recon_uvoffset;
}

static void set_scale_factors(MACROBLOCKD *xd,
    int ref0, int ref1,
    struct scale_factors scale_factor[MAX_REF_FRAMES]) {

  xd->scale_factor[0] = scale_factor[ref0 >= 0 ? ref0 : 0];
  xd->scale_factor[1] = scale_factor[ref1 >= 0 ? ref1 : 0];
  xd->scale_factor_uv[0] = xd->scale_factor[0];
  xd->scale_factor_uv[1] = xd->scale_factor[1];
}

176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
static void set_offsets_with_scaling(struct scale_factors *scale,
                                     int row, int col) {
  const int x_q4 = 16 * col;
  const int y_q4 = 16 * row;

  scale->x_offset_q4 = (x_q4 * scale->x_num / scale->x_den) & 0xf;
  scale->y_offset_q4 = (y_q4 * scale->y_num / scale->y_den) & 0xf;
}

static void set_offsets_without_scaling(struct scale_factors *scale,
                                        int row, int col) {
  scale->x_offset_q4 = 0;
  scale->y_offset_q4 = 0;
}

static int_mv32 motion_vector_q3_to_q4_with_scaling(
    const int_mv *src_mv,
    const struct scale_factors *scale) {
  // returns mv * scale + offset
  int_mv32 result;
  const int32_t mv_row_q4 = src_mv->as_mv.row << 1;
  const int32_t mv_col_q4 = src_mv->as_mv.col << 1;

  /* TODO(jkoleszar): make fixed point, or as a second multiply? */
  result.as_mv.row =  mv_row_q4 * scale->y_num / scale->y_den
                      + scale->y_offset_q4;
  result.as_mv.col =  mv_col_q4 * scale->x_num / scale->x_den
                      + scale->x_offset_q4;
  return result;
}

static int_mv32 motion_vector_q3_to_q4_without_scaling(
    const int_mv *src_mv,
    const struct scale_factors *scale) {
  // returns mv * scale + offset
  int_mv32 result;

  result.as_mv.row = src_mv->as_mv.row << 1;
  result.as_mv.col = src_mv->as_mv.col << 1;
  return result;
}

static int32_t motion_vector_component_q4_with_scaling(int mv_q4,
                                                       int num,
                                                       int den,
                                                       int offset_q4) {
  // returns the scaled and offset value of the mv component.

  /* TODO(jkoleszar): make fixed point, or as a second multiply? */
  return mv_q4 * num / den + offset_q4;
}

static int32_t motion_vector_component_q4_without_scaling(int mv_q4,
                                                          int num,
                                                          int den,
                                                          int offset_q4) {
  // returns the scaled and offset value of the mv component.
  (void)num;
  (void)den;
  (void)offset_q4;
  return mv_q4;
}
238
#endif  // VP9_COMMON_VP9_RECONINTER_H_