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