1/*
2 *  Copyright (c) 2014 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#include "./vp9_rtcd.h"
11#include "vp9/common/vp9_common.h"
12#include "vpx_ports/mem.h"
13
14unsigned int vp9_avg_8x8_c(const uint8_t *s, int p) {
15  int i, j;
16  int sum = 0;
17  for (i = 0; i < 8; ++i, s+=p)
18    for (j = 0; j < 8; sum += s[j], ++j) {}
19
20  return (sum + 32) >> 6;
21}
22
23unsigned int vp9_avg_4x4_c(const uint8_t *s, int p) {
24  int i, j;
25  int sum = 0;
26  for (i = 0; i < 4; ++i, s+=p)
27    for (j = 0; j < 4; sum += s[j], ++j) {}
28
29  return (sum + 8) >> 4;
30}
31
32// src_diff: first pass, 9 bit, dynamic range [-255, 255]
33//           second pass, 12 bit, dynamic range [-2040, 2040]
34static void hadamard_col8(const int16_t *src_diff, int src_stride,
35                          int16_t *coeff) {
36  int16_t b0 = src_diff[0 * src_stride] + src_diff[1 * src_stride];
37  int16_t b1 = src_diff[0 * src_stride] - src_diff[1 * src_stride];
38  int16_t b2 = src_diff[2 * src_stride] + src_diff[3 * src_stride];
39  int16_t b3 = src_diff[2 * src_stride] - src_diff[3 * src_stride];
40  int16_t b4 = src_diff[4 * src_stride] + src_diff[5 * src_stride];
41  int16_t b5 = src_diff[4 * src_stride] - src_diff[5 * src_stride];
42  int16_t b6 = src_diff[6 * src_stride] + src_diff[7 * src_stride];
43  int16_t b7 = src_diff[6 * src_stride] - src_diff[7 * src_stride];
44
45  int16_t c0 = b0 + b2;
46  int16_t c1 = b1 + b3;
47  int16_t c2 = b0 - b2;
48  int16_t c3 = b1 - b3;
49  int16_t c4 = b4 + b6;
50  int16_t c5 = b5 + b7;
51  int16_t c6 = b4 - b6;
52  int16_t c7 = b5 - b7;
53
54  coeff[0] = c0 + c4;
55  coeff[7] = c1 + c5;
56  coeff[3] = c2 + c6;
57  coeff[4] = c3 + c7;
58  coeff[2] = c0 - c4;
59  coeff[6] = c1 - c5;
60  coeff[1] = c2 - c6;
61  coeff[5] = c3 - c7;
62}
63
64void vp9_hadamard_8x8_c(int16_t const *src_diff, int src_stride,
65                        int16_t *coeff) {
66  int idx;
67  int16_t buffer[64];
68  int16_t *tmp_buf = &buffer[0];
69  for (idx = 0; idx < 8; ++idx) {
70    hadamard_col8(src_diff, src_stride, tmp_buf);  // src_diff: 9 bit
71                                                   // dynamic range [-255, 255]
72    tmp_buf += 8;
73    ++src_diff;
74  }
75
76  tmp_buf = &buffer[0];
77  for (idx = 0; idx < 8; ++idx) {
78    hadamard_col8(tmp_buf, 8, coeff);  // tmp_buf: 12 bit
79                                       // dynamic range [-2040, 2040]
80    coeff += 8;  // coeff: 15 bit
81                 // dynamic range [-16320, 16320]
82    ++tmp_buf;
83  }
84}
85
86// In place 16x16 2D Hadamard transform
87void vp9_hadamard_16x16_c(int16_t const *src_diff, int src_stride,
88                          int16_t *coeff) {
89  int idx;
90  for (idx = 0; idx < 4; ++idx) {
91    // src_diff: 9 bit, dynamic range [-255, 255]
92    int16_t const *src_ptr = src_diff + (idx >> 1) * 8 * src_stride
93                                + (idx & 0x01) * 8;
94    vp9_hadamard_8x8_c(src_ptr, src_stride, coeff + idx * 64);
95  }
96
97  // coeff: 15 bit, dynamic range [-16320, 16320]
98  for (idx = 0; idx < 64; ++idx) {
99    int16_t a0 = coeff[0];
100    int16_t a1 = coeff[64];
101    int16_t a2 = coeff[128];
102    int16_t a3 = coeff[192];
103
104    int16_t b0 = (a0 + a1) >> 1;  // (a0 + a1): 16 bit, [-32640, 32640]
105    int16_t b1 = (a0 - a1) >> 1;  // b0-b3: 15 bit, dynamic range
106    int16_t b2 = (a2 + a3) >> 1;  // [-16320, 16320]
107    int16_t b3 = (a2 - a3) >> 1;
108
109    coeff[0]   = b0 + b2;  // 16 bit, [-32640, 32640]
110    coeff[64]  = b1 + b3;
111    coeff[128] = b0 - b2;
112    coeff[192] = b1 - b3;
113
114    ++coeff;
115  }
116}
117
118// coeff: 16 bits, dynamic range [-32640, 32640].
119// length: value range {16, 64, 256, 1024}.
120int16_t vp9_satd_c(const int16_t *coeff, int length) {
121  int i;
122  int satd = 0;
123  for (i = 0; i < length; ++i)
124    satd += abs(coeff[i]);
125
126  // satd: 26 bits, dynamic range [-32640 * 1024, 32640 * 1024]
127  return (int16_t)satd;
128}
129
130// Integer projection onto row vectors.
131// height: value range {16, 32, 64}.
132void vp9_int_pro_row_c(int16_t hbuf[16], uint8_t const *ref,
133                       const int ref_stride, const int height) {
134  int idx;
135  const int norm_factor = height >> 1;
136  for (idx = 0; idx < 16; ++idx) {
137    int i;
138    hbuf[idx] = 0;
139    // hbuf[idx]: 14 bit, dynamic range [0, 16320].
140    for (i = 0; i < height; ++i)
141      hbuf[idx] += ref[i * ref_stride];
142    // hbuf[idx]: 9 bit, dynamic range [0, 510].
143    hbuf[idx] /= norm_factor;
144    ++ref;
145  }
146}
147
148// width: value range {16, 32, 64}.
149int16_t vp9_int_pro_col_c(uint8_t const *ref, const int width) {
150  int idx;
151  int16_t sum = 0;
152  // sum: 14 bit, dynamic range [0, 16320]
153  for (idx = 0; idx < width; ++idx)
154    sum += ref[idx];
155  return sum;
156}
157
158// ref: [0 - 510]
159// src: [0 - 510]
160// bwl: {2, 3, 4}
161int vp9_vector_var_c(int16_t const *ref, int16_t const *src,
162                     const int bwl) {
163  int i;
164  int width = 4 << bwl;
165  int sse = 0, mean = 0, var;
166
167  for (i = 0; i < width; ++i) {
168    int diff = ref[i] - src[i];  // diff: dynamic range [-510, 510], 10 bits.
169    mean += diff;                // mean: dynamic range 16 bits.
170    sse += diff * diff;          // sse:  dynamic range 26 bits.
171  }
172
173  // (mean * mean): dynamic range 31 bits.
174  var = sse - ((mean * mean) >> (bwl + 2));
175  return var;
176}
177
178void vp9_minmax_8x8_c(const uint8_t *s, int p, const uint8_t *d, int dp,
179                      int *min, int *max) {
180  int i, j;
181  *min = 255;
182  *max = 0;
183  for (i = 0; i < 8; ++i, s += p, d += dp) {
184    for (j = 0; j < 8; ++j) {
185      int diff = abs(s[j]-d[j]);
186      *min = diff < *min ? diff : *min;
187      *max = diff > *max ? diff : *max;
188    }
189  }
190}
191
192#if CONFIG_VP9_HIGHBITDEPTH
193unsigned int vp9_highbd_avg_8x8_c(const uint8_t *s8, int p) {
194  int i, j;
195  int sum = 0;
196  const uint16_t* s = CONVERT_TO_SHORTPTR(s8);
197  for (i = 0; i < 8; ++i, s+=p)
198    for (j = 0; j < 8; sum += s[j], ++j) {}
199
200  return (sum + 32) >> 6;
201}
202
203unsigned int vp9_highbd_avg_4x4_c(const uint8_t *s8, int p) {
204  int i, j;
205  int sum = 0;
206  const uint16_t* s = CONVERT_TO_SHORTPTR(s8);
207  for (i = 0; i < 4; ++i, s+=p)
208    for (j = 0; j < 4; sum += s[j], ++j) {}
209
210  return (sum + 8) >> 4;
211}
212
213void vp9_highbd_minmax_8x8_c(const uint8_t *s8, int p, const uint8_t *d8,
214                             int dp, int *min, int *max) {
215  int i, j;
216  const uint16_t* s = CONVERT_TO_SHORTPTR(s8);
217  const uint16_t* d = CONVERT_TO_SHORTPTR(d8);
218  *min = 255;
219  *max = 0;
220  for (i = 0; i < 8; ++i, s += p, d += dp) {
221    for (j = 0; j < 8; ++j) {
222      int diff = abs(s[j]-d[j]);
223      *min = diff < *min ? diff : *min;
224      *max = diff > *max ? diff : *max;
225    }
226  }
227}
228#endif  // CONFIG_VP9_HIGHBITDEPTH
229
230
231