vp9_convolve.c 12.8 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
2
3
4
5
6
7
8
9
/*
 *  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
Christian Duvivier's avatar
Christian Duvivier committed
10
11
#include "vp9/common/vp9_convolve.h"

John Koleszar's avatar
John Koleszar committed
12
13
14
15
16
17
#include <assert.h>

#include "./vpx_config.h"
#include "./vp9_rtcd.h"
#include "vp9/common/vp9_common.h"
#include "vpx/vpx_integer.h"
Christian Duvivier's avatar
Christian Duvivier committed
18
#include "vpx_ports/mem.h"
John Koleszar's avatar
John Koleszar committed
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#define VP9_FILTER_WEIGHT 128
#define VP9_FILTER_SHIFT  7

/* Assume a bank of 16 filters to choose from. There are two implementations
 * for filter wrapping behavior, since we want to be able to pick which filter
 * to start with. We could either:
 *
 * 1) make filter_ a pointer to the base of the filter array, and then add an
 *    additional offset parameter, to choose the starting filter.
 * 2) use a pointer to 2 periods worth of filters, so that even if the original
 *    phase offset is at 15/16, we'll have valid data to read. The filter
 *    tables become [32][8], and the second half is duplicated.
 * 3) fix the alignment of the filter tables, so that we know the 0/16 is
 *    always 256 byte aligned.
 *
 * Implementations 2 and 3 are likely preferable, as they avoid an extra 2
36
37
 * parameters, and switching between them is trivial, with the
 * ALIGN_FILTERS_256 macro, below.
John Koleszar's avatar
John Koleszar committed
38
 */
39
40
 #define ALIGN_FILTERS_256 1

John Koleszar's avatar
John Koleszar committed
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
static void convolve_horiz_c(const uint8_t *src, int src_stride,
                             uint8_t *dst, int dst_stride,
                             const int16_t *filter_x0, int x_step_q4,
                             const int16_t *filter_y, int y_step_q4,
                             int w, int h, int taps) {
  int x, y, k, sum;
  const int16_t *filter_x_base = filter_x0;

#if ALIGN_FILTERS_256
  filter_x_base = (const int16_t *)(((intptr_t)filter_x0) & ~(intptr_t)0xff);
#endif

  /* Adjust base pointer address for this source line */
  src -= taps / 2 - 1;

  for (y = 0; y < h; ++y) {
    /* Pointer to filter to use */
    const int16_t *filter_x = filter_x0;

    /* Initial phase offset */
61
62
    int x0_q4 = (filter_x - filter_x_base) / taps;
    int x_q4 = x0_q4;
John Koleszar's avatar
John Koleszar committed
63
64
65

    for (x = 0; x < w; ++x) {
      /* Per-pixel src offset */
66
      int src_x = (x_q4 - x0_q4) >> 4;
John Koleszar's avatar
John Koleszar committed
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

      for (sum = 0, k = 0; k < taps; ++k) {
        sum += src[src_x + k] * filter_x[k];
      }
      sum += (VP9_FILTER_WEIGHT >> 1);
      dst[x] = clip_pixel(sum >> VP9_FILTER_SHIFT);

      /* Adjust source and filter to use for the next pixel */
      x_q4 += x_step_q4;
      filter_x = filter_x_base + (x_q4 & 0xf) * taps;
    }
    src += src_stride;
    dst += dst_stride;
  }
}

static void convolve_avg_horiz_c(const uint8_t *src, int src_stride,
                                 uint8_t *dst, int dst_stride,
                                 const int16_t *filter_x0, int x_step_q4,
                                 const int16_t *filter_y, int y_step_q4,
                                 int w, int h, int taps) {
  int x, y, k, sum;
  const int16_t *filter_x_base = filter_x0;

#if ALIGN_FILTERS_256
  filter_x_base = (const int16_t *)(((intptr_t)filter_x0) & ~(intptr_t)0xff);
#endif

  /* Adjust base pointer address for this source line */
  src -= taps / 2 - 1;

  for (y = 0; y < h; ++y) {
    /* Pointer to filter to use */
    const int16_t *filter_x = filter_x0;

    /* Initial phase offset */
103
104
    int x0_q4 = (filter_x - filter_x_base) / taps;
    int x_q4 = x0_q4;
John Koleszar's avatar
John Koleszar committed
105
106
107

    for (x = 0; x < w; ++x) {
      /* Per-pixel src offset */
108
      int src_x = (x_q4 - x0_q4) >> 4;
John Koleszar's avatar
John Koleszar committed
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

      for (sum = 0, k = 0; k < taps; ++k) {
        sum += src[src_x + k] * filter_x[k];
      }
      sum += (VP9_FILTER_WEIGHT >> 1);
      dst[x] = (dst[x] + clip_pixel(sum >> VP9_FILTER_SHIFT) + 1) >> 1;

      /* Adjust source and filter to use for the next pixel */
      x_q4 += x_step_q4;
      filter_x = filter_x_base + (x_q4 & 0xf) * taps;
    }
    src += src_stride;
    dst += dst_stride;
  }
}

static void convolve_vert_c(const uint8_t *src, int src_stride,
                            uint8_t *dst, int dst_stride,
                            const int16_t *filter_x, int x_step_q4,
                            const int16_t *filter_y0, int y_step_q4,
                            int w, int h, int taps) {
  int x, y, k, sum;

  const int16_t *filter_y_base = filter_y0;

#if ALIGN_FILTERS_256
  filter_y_base = (const int16_t *)(((intptr_t)filter_y0) & ~(intptr_t)0xff);
#endif

  /* Adjust base pointer address for this source column */
  src -= src_stride * (taps / 2 - 1);
  for (x = 0; x < w; ++x) {
    /* Pointer to filter to use */
    const int16_t *filter_y = filter_y0;

    /* Initial phase offset */
145
146
    int y0_q4 = (filter_y - filter_y_base) / taps;
    int y_q4 = y0_q4;
John Koleszar's avatar
John Koleszar committed
147
148
149

    for (y = 0; y < h; ++y) {
      /* Per-pixel src offset */
150
      int src_y = (y_q4 - y0_q4) >> 4;
John Koleszar's avatar
John Koleszar committed
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

      for (sum = 0, k = 0; k < taps; ++k) {
        sum += src[(src_y + k) * src_stride] * filter_y[k];
      }
      sum += (VP9_FILTER_WEIGHT >> 1);
      dst[y * dst_stride] = clip_pixel(sum >> VP9_FILTER_SHIFT);

      /* Adjust source and filter to use for the next pixel */
      y_q4 += y_step_q4;
      filter_y = filter_y_base + (y_q4 & 0xf) * taps;
    }
    ++src;
    ++dst;
  }
}

static void convolve_avg_vert_c(const uint8_t *src, int src_stride,
                                uint8_t *dst, int dst_stride,
                                const int16_t *filter_x, int x_step_q4,
                                const int16_t *filter_y0, int y_step_q4,
                                int w, int h, int taps) {
  int x, y, k, sum;

  const int16_t *filter_y_base = filter_y0;

#if ALIGN_FILTERS_256
  filter_y_base = (const int16_t *)(((intptr_t)filter_y0) & ~(intptr_t)0xff);
#endif

  /* Adjust base pointer address for this source column */
  src -= src_stride * (taps / 2 - 1);
  for (x = 0; x < w; ++x) {
    /* Pointer to filter to use */
    const int16_t *filter_y = filter_y0;

    /* Initial phase offset */
187
188
    int y0_q4 = (filter_y - filter_y_base) / taps;
    int y_q4 = y0_q4;
John Koleszar's avatar
John Koleszar committed
189
190
191

    for (y = 0; y < h; ++y) {
      /* Per-pixel src offset */
192
      int src_y = (y_q4 - y0_q4) >> 4;
John Koleszar's avatar
John Koleszar committed
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

      for (sum = 0, k = 0; k < taps; ++k) {
        sum += src[(src_y + k) * src_stride] * filter_y[k];
      }
      sum += (VP9_FILTER_WEIGHT >> 1);
      dst[y * dst_stride] =
          (dst[y * dst_stride] + clip_pixel(sum >> VP9_FILTER_SHIFT) + 1) >> 1;

      /* Adjust source and filter to use for the next pixel */
      y_q4 += y_step_q4;
      filter_y = filter_y_base + (y_q4 & 0xf) * taps;
    }
    ++src;
    ++dst;
  }
}

static void convolve_c(const uint8_t *src, int src_stride,
                       uint8_t *dst, int dst_stride,
                       const int16_t *filter_x, int x_step_q4,
                       const int16_t *filter_y, int y_step_q4,
                       int w, int h, int taps) {
215
216
217
218
219
220
221
  /* Fixed size intermediate buffer places limits on parameters.
   * Maximum intermediate_height is 39, for y_step_q4 == 32,
   * h == 16, taps == 8.
   */
  uint8_t temp[16 * 39];
  int intermediate_height = ((h * y_step_q4) >> 4) + taps - 1;

John Koleszar's avatar
John Koleszar committed
222
223
224
  assert(w <= 16);
  assert(h <= 16);
  assert(taps <= 8);
225
226
227
228
  assert(y_step_q4 <= 32);

  if (intermediate_height < h)
    intermediate_height = h;
John Koleszar's avatar
John Koleszar committed
229
230
231
232

  convolve_horiz_c(src - src_stride * (taps / 2 - 1), src_stride,
                   temp, 16,
                   filter_x, x_step_q4, filter_y, y_step_q4,
233
                   w, intermediate_height, taps);
John Koleszar's avatar
John Koleszar committed
234
235
236
237
238
239
240
241
242
243
  convolve_vert_c(temp + 16 * (taps / 2 - 1), 16, dst, dst_stride,
                  filter_x, x_step_q4, filter_y, y_step_q4,
                  w, h, taps);
}

static void convolve_avg_c(const uint8_t *src, int src_stride,
                           uint8_t *dst, int dst_stride,
                           const int16_t *filter_x, int x_step_q4,
                           const int16_t *filter_y, int y_step_q4,
                           int w, int h, int taps) {
244
245
246
247
248
249
250
  /* Fixed size intermediate buffer places limits on parameters.
   * Maximum intermediate_height is 39, for y_step_q4 == 32,
   * h == 16, taps == 8.
   */
  uint8_t temp[16 * 39];
  int intermediate_height = ((h * y_step_q4) >> 4) + taps - 1;

John Koleszar's avatar
John Koleszar committed
251
252
253
  assert(w <= 16);
  assert(h <= 16);
  assert(taps <= 8);
254
255
256
257
  assert(y_step_q4 <= 32);

  if (intermediate_height < h)
    intermediate_height = h;
John Koleszar's avatar
John Koleszar committed
258
259
260
261

  convolve_horiz_c(src - src_stride * (taps / 2 - 1), src_stride,
                   temp, 16,
                   filter_x, x_step_q4, filter_y, y_step_q4,
262
                   w, intermediate_height, taps);
John Koleszar's avatar
John Koleszar committed
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
  convolve_avg_vert_c(temp + 16 * (taps / 2 - 1), 16, dst, dst_stride,
                      filter_x, x_step_q4, filter_y, y_step_q4,
                      w, h, taps);
}

void vp9_convolve8_horiz_c(const uint8_t *src, int src_stride,
                           uint8_t *dst, int dst_stride,
                           const int16_t *filter_x, int x_step_q4,
                           const int16_t *filter_y, int y_step_q4,
                           int w, int h) {
  convolve_horiz_c(src, src_stride, dst, dst_stride,
                   filter_x, x_step_q4, filter_y, y_step_q4,
                   w, h, 8);
}

void vp9_convolve8_avg_horiz_c(const uint8_t *src, int src_stride,
                               uint8_t *dst, int dst_stride,
                               const int16_t *filter_x, int x_step_q4,
                               const int16_t *filter_y, int y_step_q4,
                               int w, int h) {
  convolve_avg_horiz_c(src, src_stride, dst, dst_stride,
                       filter_x, x_step_q4, filter_y, y_step_q4,
                       w, h, 8);
}

void vp9_convolve8_vert_c(const uint8_t *src, int src_stride,
                          uint8_t *dst, int dst_stride,
                          const int16_t *filter_x, int x_step_q4,
                          const int16_t *filter_y, int y_step_q4,
                          int w, int h) {
  convolve_vert_c(src, src_stride, dst, dst_stride,
                  filter_x, x_step_q4, filter_y, y_step_q4,
                  w, h, 8);
}

void vp9_convolve8_avg_vert_c(const uint8_t *src, int src_stride,
                              uint8_t *dst, int dst_stride,
                              const int16_t *filter_x, int x_step_q4,
                              const int16_t *filter_y, int y_step_q4,
                              int w, int h) {
  convolve_avg_vert_c(src, src_stride, dst, dst_stride,
                      filter_x, x_step_q4, filter_y, y_step_q4,
                      w, h, 8);
}

void vp9_convolve8_c(const uint8_t *src, int src_stride,
                     uint8_t *dst, int dst_stride,
                     const int16_t *filter_x, int x_step_q4,
                     const int16_t *filter_y, int y_step_q4,
                     int w, int h) {
  convolve_c(src, src_stride, dst, dst_stride,
             filter_x, x_step_q4, filter_y, y_step_q4,
             w, h, 8);
}

void vp9_convolve8_avg_c(const uint8_t *src, int src_stride,
                         uint8_t *dst, int dst_stride,
                         const int16_t *filter_x, int x_step_q4,
                         const int16_t *filter_y, int y_step_q4,
                         int w, int h) {
Christian Duvivier's avatar
Christian Duvivier committed
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
  /* Fixed size intermediate buffer places limits on parameters. */
  DECLARE_ALIGNED_ARRAY(16, uint8_t, temp, 16 * 16);
  assert(w <= 16);
  assert(h <= 16);

  vp9_convolve8(src, src_stride,
                temp, 16,
                filter_x, x_step_q4,
                filter_y, y_step_q4,
                w, h);
  vp9_convolve_avg(temp, 16,
                   dst, dst_stride,
                   NULL, 0, /* These unused parameter should be removed! */
                   NULL, 0, /* These unused parameter should be removed! */
                   w, h);
John Koleszar's avatar
John Koleszar committed
338
}
339
340
341
342
343
344

void vp9_convolve_copy(const uint8_t *src, int src_stride,
                       uint8_t *dst, int dst_stride,
                       const int16_t *filter_x, int filter_x_stride,
                       const int16_t *filter_y, int filter_y_stride,
                       int w, int h) {
345
  if (w == 16 && h == 16) {
346
    vp9_copy_mem16x16(src, src_stride, dst, dst_stride);
347
  } else if (w == 8 && h == 8) {
348
    vp9_copy_mem8x8(src, src_stride, dst, dst_stride);
349
  } else if (w == 8 && h == 4) {
350
351
352
353
    vp9_copy_mem8x4(src, src_stride, dst, dst_stride);
  } else {
    int r;

354
355
    for (r = h; r > 0; --r) {
      memcpy(dst, src, w);
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
      src += src_stride;
      dst += dst_stride;
    }
  }
}

void vp9_convolve_avg(const uint8_t *src, int src_stride,
                      uint8_t *dst, int dst_stride,
                      const int16_t *filter_x, int filter_x_stride,
                      const int16_t *filter_y, int filter_y_stride,
                      int w, int h) {
  int x, y;

  for (y = 0; y < h; ++y) {
    for (x = 0; x < w; ++x) {
      dst[x] = (dst[x] + src[x] + 1) >> 1;
    }
    src += src_stride;
    dst += dst_stride;
  }
}