OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. | 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 | 11 |
12 #include "vp9/encoder/vp9_onyx_int.h" | 12 #include "vp9/encoder/vp9_onyx_int.h" |
13 #include "vp9/encoder/vp9_mcomp.h" | 13 #include "vp9/encoder/vp9_mcomp.h" |
14 #include "vpx_mem/vpx_mem.h" | 14 #include "vpx_mem/vpx_mem.h" |
15 #include "vpx_ports/config.h" | 15 #include "./vpx_config.h" |
16 #include <stdio.h> | 16 #include <stdio.h> |
17 #include <limits.h> | 17 #include <limits.h> |
18 #include <math.h> | 18 #include <math.h> |
19 #include "vp9/common/vp9_findnearmv.h" | 19 #include "vp9/common/vp9_findnearmv.h" |
| 20 #include "vp9/common/vp9_common.h" |
20 | 21 |
21 #ifdef ENTROPY_STATS | 22 #ifdef ENTROPY_STATS |
22 static int mv_ref_ct [31] [4] [2]; | 23 static int mv_ref_ct [31] [4] [2]; |
23 static int mv_mode_cts [4] [2]; | 24 static int mv_mode_cts [4] [2]; |
24 #endif | 25 #endif |
25 | 26 |
26 void vp9_clamp_mv_min_max(MACROBLOCK *x, int_mv *ref_mv) { | 27 void vp9_clamp_mv_min_max(MACROBLOCK *x, int_mv *ref_mv) { |
27 int col_min = (ref_mv->as_mv.col >> 3) - MAX_FULL_PEL_VAL + | 28 int col_min = (ref_mv->as_mv.col >> 3) - MAX_FULL_PEL_VAL + |
28 ((ref_mv->as_mv.col & 7) ? 1 : 0); | 29 ((ref_mv->as_mv.col & 7) ? 1 : 0); |
29 int row_min = (ref_mv->as_mv.row >> 3) - MAX_FULL_PEL_VAL + | 30 int row_min = (ref_mv->as_mv.row >> 3) - MAX_FULL_PEL_VAL + |
(...skipping 204 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
234 if ((v = MVC(r, c) + thismse) < besterr) { \ | 235 if ((v = MVC(r, c) + thismse) < besterr) { \ |
235 besterr = v; \ | 236 besterr = v; \ |
236 br = r; \ | 237 br = r; \ |
237 bc = c; \ | 238 bc = c; \ |
238 *distortion = thismse; \ | 239 *distortion = thismse; \ |
239 *sse1 = sse; \ | 240 *sse1 = sse; \ |
240 } \ | 241 } \ |
241 }, \ | 242 }, \ |
242 v = INT_MAX;) | 243 v = INT_MAX;) |
243 | 244 |
244 #define MIN(x,y) (((x)<(y))?(x):(y)) | |
245 #define MAX(x,y) (((x)>(y))?(x):(y)) | |
246 | |
247 int vp9_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d, | 245 int vp9_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d, |
248 int_mv *bestmv, int_mv *ref_mv, | 246 int_mv *bestmv, int_mv *ref_mv, |
249 int error_per_bit, | 247 int error_per_bit, |
250 const vp9_variance_fn_ptr_t *vfp, | 248 const vp9_variance_fn_ptr_t *vfp, |
251 int *mvjcost, int *mvcost[2], | 249 int *mvjcost, int *mvcost[2], |
252 int *distortion, | 250 int *distortion, |
253 unsigned int *sse1) { | 251 unsigned int *sse1) { |
254 unsigned char *z = (*(b->base_src) + b->src); | 252 uint8_t *z = (*(b->base_src) + b->src); |
255 MACROBLOCKD *xd = &x->e_mbd; | 253 MACROBLOCKD *xd = &x->e_mbd; |
256 | 254 |
257 int rr, rc, br, bc, hstep; | 255 int rr, rc, br, bc, hstep; |
258 int tr, tc; | 256 int tr, tc; |
259 unsigned int besterr = INT_MAX; | 257 unsigned int besterr = INT_MAX; |
260 unsigned int left, right, up, down, diag; | 258 unsigned int left, right, up, down, diag; |
261 unsigned int sse; | 259 unsigned int sse; |
262 unsigned int whichdir; | 260 unsigned int whichdir; |
263 unsigned int halfiters = 4; | 261 unsigned int halfiters = 4; |
264 unsigned int quarteriters = 4; | 262 unsigned int quarteriters = 4; |
265 unsigned int eighthiters = 4; | 263 unsigned int eighthiters = 4; |
266 int thismse; | 264 int thismse; |
267 int maxc, minc, maxr, minr; | 265 int maxc, minc, maxr, minr; |
268 int y_stride; | 266 int y_stride; |
269 int offset; | 267 int offset; |
270 int usehp = xd->allow_high_precision_mv; | 268 int usehp = xd->allow_high_precision_mv; |
271 | 269 |
272 #if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64) | 270 uint8_t *y = *(d->base_pre) + d->pre + |
273 unsigned char *y0 = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_str
ide + bestmv->as_mv.col; | 271 (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col; |
274 unsigned char *y; | |
275 int buf_r1, buf_r2, buf_c1, buf_c2; | |
276 | |
277 // Clamping to avoid out-of-range data access | |
278 buf_r1 = ((bestmv->as_mv.row - VP9_INTERP_EXTEND) < x->mv_row_min) ? | |
279 (bestmv->as_mv.row - x->mv_row_min) : VP9_INTERP_EXTEND - 1; | |
280 buf_r2 = ((bestmv->as_mv.row + VP9_INTERP_EXTEND) > x->mv_row_max) ? | |
281 (x->mv_row_max - bestmv->as_mv.row) : VP9_INTERP_EXTEND - 1; | |
282 buf_c1 = ((bestmv->as_mv.col - VP9_INTERP_EXTEND) < x->mv_col_min) ? | |
283 (bestmv->as_mv.col - x->mv_col_min) : VP9_INTERP_EXTEND - 1; | |
284 buf_c2 = ((bestmv->as_mv.col + VP9_INTERP_EXTEND) > x->mv_col_max) ? | |
285 (x->mv_col_max - bestmv->as_mv.col) : VP9_INTERP_EXTEND - 1; | |
286 y_stride = 32; | |
287 | |
288 /* Copy to intermediate buffer before searching. */ | |
289 vfp->copymem(y0 - buf_c1 - d->pre_stride * buf_r1, d->pre_stride, xd->y_buf, y
_stride, 16 + buf_r1 + buf_r2); | |
290 y = xd->y_buf + y_stride * buf_r1 + buf_c1; | |
291 #else | |
292 unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stri
de + bestmv->as_mv.col; | |
293 y_stride = d->pre_stride; | 272 y_stride = d->pre_stride; |
294 #endif | |
295 | 273 |
296 rr = ref_mv->as_mv.row; | 274 rr = ref_mv->as_mv.row; |
297 rc = ref_mv->as_mv.col; | 275 rc = ref_mv->as_mv.col; |
298 br = bestmv->as_mv.row << 3; | 276 br = bestmv->as_mv.row << 3; |
299 bc = bestmv->as_mv.col << 3; | 277 bc = bestmv->as_mv.col << 3; |
300 hstep = 4; | 278 hstep = 4; |
301 minc = MAX(x->mv_col_min << 3, (ref_mv->as_mv.col) - ((1 << MV_MAX_BITS) - 1))
; | 279 minc = MAX(x->mv_col_min << 3, (ref_mv->as_mv.col) - ((1 << MV_MAX_BITS) - 1))
; |
302 maxc = MIN(x->mv_col_max << 3, (ref_mv->as_mv.col) + ((1 << MV_MAX_BITS) - 1))
; | 280 maxc = MIN(x->mv_col_max << 3, (ref_mv->as_mv.col) + ((1 << MV_MAX_BITS) - 1))
; |
303 minr = MAX(x->mv_row_min << 3, (ref_mv->as_mv.row) - ((1 << MV_MAX_BITS) - 1))
; | 281 minr = MAX(x->mv_row_min << 3, (ref_mv->as_mv.row) - ((1 << MV_MAX_BITS) - 1))
; |
304 maxr = MIN(x->mv_row_max << 3, (ref_mv->as_mv.row) + ((1 << MV_MAX_BITS) - 1))
; | 282 maxr = MIN(x->mv_row_max << 3, (ref_mv->as_mv.row) + ((1 << MV_MAX_BITS) - 1))
; |
(...skipping 142 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
447 int_mv *bestmv, int_mv *ref_mv, | 425 int_mv *bestmv, int_mv *ref_mv, |
448 int error_per_bit, | 426 int error_per_bit, |
449 const vp9_variance_fn_ptr_t *vfp, | 427 const vp9_variance_fn_ptr_t *vfp, |
450 int *mvjcost, int *mvcost[2], int *distortion, | 428 int *mvjcost, int *mvcost[2], int *distortion, |
451 unsigned int *sse1) { | 429 unsigned int *sse1) { |
452 int bestmse = INT_MAX; | 430 int bestmse = INT_MAX; |
453 int_mv startmv; | 431 int_mv startmv; |
454 int_mv this_mv; | 432 int_mv this_mv; |
455 int_mv orig_mv; | 433 int_mv orig_mv; |
456 int yrow_movedback = 0, ycol_movedback = 0; | 434 int yrow_movedback = 0, ycol_movedback = 0; |
457 unsigned char *z = (*(b->base_src) + b->src); | 435 uint8_t *z = (*(b->base_src) + b->src); |
458 int left, right, up, down, diag; | 436 int left, right, up, down, diag; |
459 unsigned int sse; | 437 unsigned int sse; |
460 int whichdir; | 438 int whichdir; |
461 int thismse; | 439 int thismse; |
462 int y_stride; | 440 int y_stride; |
463 MACROBLOCKD *xd = &x->e_mbd; | 441 MACROBLOCKD *xd = &x->e_mbd; |
464 int usehp = xd->allow_high_precision_mv; | 442 int usehp = xd->allow_high_precision_mv; |
465 | 443 |
466 #if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64) | 444 uint8_t *y = *(d->base_pre) + d->pre + |
467 unsigned char *y0 = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_str
ide + bestmv->as_mv.col; | 445 (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col; |
468 unsigned char *y; | |
469 | |
470 y_stride = 32; | |
471 /* Copy 18 rows x 32 cols area to intermediate buffer before searching. */ | |
472 vfp->copymem(y0 - 1 - d->pre_stride, d->pre_stride, xd->y_buf, y_stride, 18); | |
473 y = xd->y_buf + y_stride + 1; | |
474 #else | |
475 unsigned char *y = *(d->base_pre) + d->pre + (bestmv->as_mv.row) * d->pre_stri
de + bestmv->as_mv.col; | |
476 y_stride = d->pre_stride; | 446 y_stride = d->pre_stride; |
477 #endif | |
478 | 447 |
479 // central mv | 448 // central mv |
480 bestmv->as_mv.row <<= 3; | 449 bestmv->as_mv.row <<= 3; |
481 bestmv->as_mv.col <<= 3; | 450 bestmv->as_mv.col <<= 3; |
482 startmv = *bestmv; | 451 startmv = *bestmv; |
483 orig_mv = *bestmv; | 452 orig_mv = *bestmv; |
484 | 453 |
485 // calculate central point error | 454 // calculate central point error |
486 bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1); | 455 bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1); |
487 *distortion = bestmse; | 456 *distortion = bestmse; |
(...skipping 438 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
926 int vp9_find_best_half_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, | 895 int vp9_find_best_half_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d, |
927 int_mv *bestmv, int_mv *ref_mv, | 896 int_mv *bestmv, int_mv *ref_mv, |
928 int error_per_bit, | 897 int error_per_bit, |
929 const vp9_variance_fn_ptr_t *vfp, | 898 const vp9_variance_fn_ptr_t *vfp, |
930 int *mvjcost, int *mvcost[2], | 899 int *mvjcost, int *mvcost[2], |
931 int *distortion, | 900 int *distortion, |
932 unsigned int *sse1) { | 901 unsigned int *sse1) { |
933 int bestmse = INT_MAX; | 902 int bestmse = INT_MAX; |
934 int_mv startmv; | 903 int_mv startmv; |
935 int_mv this_mv; | 904 int_mv this_mv; |
936 unsigned char *z = (*(b->base_src) + b->src); | 905 uint8_t *z = (*(b->base_src) + b->src); |
937 int left, right, up, down, diag; | 906 int left, right, up, down, diag; |
938 unsigned int sse; | 907 unsigned int sse; |
939 int whichdir; | 908 int whichdir; |
940 int thismse; | 909 int thismse; |
941 int y_stride; | 910 int y_stride; |
942 MACROBLOCKD *xd = &x->e_mbd; | 911 MACROBLOCKD *xd = &x->e_mbd; |
943 | 912 |
944 #if !CONFIG_SUPERBLOCKS && (ARCH_X86 || ARCH_X86_64) | 913 uint8_t *y = *(d->base_pre) + d->pre + |
945 unsigned char *y0 = *(d->base_pre) + d->pre + | |
946 (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col; | |
947 unsigned char *y; | |
948 | |
949 y_stride = 32; | |
950 /* Copy 18 rows x 32 cols area to intermediate buffer before searching. */ | |
951 vfp->copymem(y0 - 1 - d->pre_stride, d->pre_stride, xd->y_buf, y_stride, 18); | |
952 y = xd->y_buf + y_stride + 1; | |
953 #else | |
954 unsigned char *y = *(d->base_pre) + d->pre + | |
955 (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col; | 914 (bestmv->as_mv.row) * d->pre_stride + bestmv->as_mv.col; |
956 y_stride = d->pre_stride; | 915 y_stride = d->pre_stride; |
957 #endif | |
958 | 916 |
959 // central mv | 917 // central mv |
960 bestmv->as_mv.row <<= 3; | 918 bestmv->as_mv.row <<= 3; |
961 bestmv->as_mv.col <<= 3; | 919 bestmv->as_mv.col <<= 3; |
962 startmv = *bestmv; | 920 startmv = *bestmv; |
963 | 921 |
964 // calculate central point error | 922 // calculate central point error |
965 bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1); | 923 bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1); |
966 *distortion = bestmse; | 924 *distortion = bestmse; |
967 bestmse += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit, | 925 bestmse += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit, |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1111 int sad_per_bit, | 1069 int sad_per_bit, |
1112 const vp9_variance_fn_ptr_t *vfp, | 1070 const vp9_variance_fn_ptr_t *vfp, |
1113 int *mvjsadcost, int *mvsadcost[2], | 1071 int *mvjsadcost, int *mvsadcost[2], |
1114 int *mvjcost, int *mvcost[2], | 1072 int *mvjcost, int *mvcost[2], |
1115 int_mv *center_mv | 1073 int_mv *center_mv |
1116 ) { | 1074 ) { |
1117 MV hex[6] = { { -1, -2}, {1, -2}, {2, 0}, {1, 2}, { -1, 2}, { -2, 0} }; | 1075 MV hex[6] = { { -1, -2}, {1, -2}, {2, 0}, {1, 2}, { -1, 2}, { -2, 0} }; |
1118 MV neighbors[4] = {{0, -1}, { -1, 0}, {1, 0}, {0, 1}}; | 1076 MV neighbors[4] = {{0, -1}, { -1, 0}, {1, 0}, {0, 1}}; |
1119 int i, j; | 1077 int i, j; |
1120 | 1078 |
1121 unsigned char *what = (*(b->base_src) + b->src); | 1079 uint8_t *what = (*(b->base_src) + b->src); |
1122 int what_stride = b->src_stride; | 1080 int what_stride = b->src_stride; |
1123 int in_what_stride = d->pre_stride; | 1081 int in_what_stride = d->pre_stride; |
1124 int br, bc; | 1082 int br, bc; |
1125 int_mv this_mv; | 1083 int_mv this_mv; |
1126 unsigned int bestsad = 0x7fffffff; | 1084 unsigned int bestsad = 0x7fffffff; |
1127 unsigned int thissad; | 1085 unsigned int thissad; |
1128 unsigned char *base_offset; | 1086 uint8_t *base_offset; |
1129 unsigned char *this_offset; | 1087 uint8_t *this_offset; |
1130 int k = -1; | 1088 int k = -1; |
1131 int all_in; | 1089 int all_in; |
1132 int best_site = -1; | 1090 int best_site = -1; |
1133 | 1091 |
1134 int_mv fcenter_mv; | 1092 int_mv fcenter_mv; |
1135 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; | 1093 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; |
1136 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; | 1094 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; |
1137 | 1095 |
1138 // adjust ref_mv to make sure it is within MV range | 1096 // adjust ref_mv to make sure it is within MV range |
1139 clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max); | 1097 clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max); |
1140 br = ref_mv->as_mv.row; | 1098 br = ref_mv->as_mv.row; |
1141 bc = ref_mv->as_mv.col; | 1099 bc = ref_mv->as_mv.col; |
1142 | 1100 |
1143 // Work out the start point for the search | 1101 // Work out the start point for the search |
1144 base_offset = (unsigned char *)(*(d->base_pre) + d->pre); | 1102 base_offset = (uint8_t *)(*(d->base_pre) + d->pre); |
1145 this_offset = base_offset + (br * (d->pre_stride)) + bc; | 1103 this_offset = base_offset + (br * (d->pre_stride)) + bc; |
1146 this_mv.as_mv.row = br; | 1104 this_mv.as_mv.row = br; |
1147 this_mv.as_mv.col = bc; | 1105 this_mv.as_mv.col = bc; |
1148 bestsad = vfp->sdf(what, what_stride, this_offset, | 1106 bestsad = vfp->sdf(what, what_stride, this_offset, |
1149 in_what_stride, 0x7fffffff) | 1107 in_what_stride, 0x7fffffff) |
1150 + mvsad_err_cost(&this_mv, &fcenter_mv, mvjsadcost, mvsadcost, | 1108 + mvsad_err_cost(&this_mv, &fcenter_mv, mvjsadcost, mvsadcost, |
1151 sad_per_bit); | 1109 sad_per_bit); |
1152 | 1110 |
1153 // hex search | 1111 // hex search |
1154 // j=0 | 1112 // j=0 |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1257 #undef CHECK_POINT | 1215 #undef CHECK_POINT |
1258 #undef CHECK_BETTER | 1216 #undef CHECK_BETTER |
1259 | 1217 |
1260 int vp9_diamond_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, | 1218 int vp9_diamond_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, |
1261 int_mv *ref_mv, int_mv *best_mv, | 1219 int_mv *ref_mv, int_mv *best_mv, |
1262 int search_param, int sad_per_bit, int *num00, | 1220 int search_param, int sad_per_bit, int *num00, |
1263 vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost, | 1221 vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost, |
1264 int *mvcost[2], int_mv *center_mv) { | 1222 int *mvcost[2], int_mv *center_mv) { |
1265 int i, j, step; | 1223 int i, j, step; |
1266 | 1224 |
1267 unsigned char *what = (*(b->base_src) + b->src); | 1225 uint8_t *what = (*(b->base_src) + b->src); |
1268 int what_stride = b->src_stride; | 1226 int what_stride = b->src_stride; |
1269 unsigned char *in_what; | 1227 uint8_t *in_what; |
1270 int in_what_stride = d->pre_stride; | 1228 int in_what_stride = d->pre_stride; |
1271 unsigned char *best_address; | 1229 uint8_t *best_address; |
1272 | 1230 |
1273 int tot_steps; | 1231 int tot_steps; |
1274 int_mv this_mv; | 1232 int_mv this_mv; |
1275 | 1233 |
1276 int bestsad = INT_MAX; | 1234 int bestsad = INT_MAX; |
1277 int best_site = 0; | 1235 int best_site = 0; |
1278 int last_site = 0; | 1236 int last_site = 0; |
1279 | 1237 |
1280 int ref_row, ref_col; | 1238 int ref_row, ref_col; |
1281 int this_row_offset, this_col_offset; | 1239 int this_row_offset, this_col_offset; |
1282 search_site *ss; | 1240 search_site *ss; |
1283 | 1241 |
1284 unsigned char *check_here; | 1242 uint8_t *check_here; |
1285 int thissad; | 1243 int thissad; |
1286 MACROBLOCKD *xd = &x->e_mbd; | 1244 MACROBLOCKD *xd = &x->e_mbd; |
1287 int_mv fcenter_mv; | 1245 int_mv fcenter_mv; |
1288 | 1246 |
1289 int *mvjsadcost = x->nmvjointsadcost; | 1247 int *mvjsadcost = x->nmvjointsadcost; |
1290 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; | 1248 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; |
1291 | 1249 |
1292 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; | 1250 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; |
1293 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; | 1251 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; |
1294 | 1252 |
1295 clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max); | 1253 clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max); |
1296 ref_row = ref_mv->as_mv.row; | 1254 ref_row = ref_mv->as_mv.row; |
1297 ref_col = ref_mv->as_mv.col; | 1255 ref_col = ref_mv->as_mv.col; |
1298 *num00 = 0; | 1256 *num00 = 0; |
1299 best_mv->as_mv.row = ref_row; | 1257 best_mv->as_mv.row = ref_row; |
1300 best_mv->as_mv.col = ref_col; | 1258 best_mv->as_mv.col = ref_col; |
1301 | 1259 |
1302 // Work out the start point for the search | 1260 // Work out the start point for the search |
1303 in_what = (unsigned char *)(*(d->base_pre) + d->pre + (ref_row * (d->pre_strid
e)) + ref_col); | 1261 in_what = (uint8_t *)(*(d->base_pre) + d->pre + |
| 1262 (ref_row * (d->pre_stride)) + ref_col); |
1304 best_address = in_what; | 1263 best_address = in_what; |
1305 | 1264 |
1306 // Check the starting position | 1265 // Check the starting position |
1307 bestsad = fn_ptr->sdf(what, what_stride, in_what, | 1266 bestsad = fn_ptr->sdf(what, what_stride, in_what, |
1308 in_what_stride, 0x7fffffff) | 1267 in_what_stride, 0x7fffffff) |
1309 + mvsad_err_cost(best_mv, &fcenter_mv, mvjsadcost, mvsadcost, | 1268 + mvsad_err_cost(best_mv, &fcenter_mv, mvjsadcost, mvsadcost, |
1310 sad_per_bit); | 1269 sad_per_bit); |
1311 | 1270 |
1312 // search_param determines the length of the initial step and hence the number
of iterations | 1271 // search_param determines the length of the initial step and hence the number
of iterations |
1313 // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 = (MA
X_FIRST_STEP/4) pel... etc. | 1272 // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 = (MA
X_FIRST_STEP/4) pel... etc. |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1367 xd->allow_high_precision_mv); | 1326 xd->allow_high_precision_mv); |
1368 } | 1327 } |
1369 | 1328 |
1370 int vp9_diamond_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, | 1329 int vp9_diamond_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, |
1371 int_mv *ref_mv, int_mv *best_mv, int search_param, | 1330 int_mv *ref_mv, int_mv *best_mv, int search_param, |
1372 int sad_per_bit, int *num00, | 1331 int sad_per_bit, int *num00, |
1373 vp9_variance_fn_ptr_t *fn_ptr, | 1332 vp9_variance_fn_ptr_t *fn_ptr, |
1374 int *mvjcost, int *mvcost[2], int_mv *center_mv) { | 1333 int *mvjcost, int *mvcost[2], int_mv *center_mv) { |
1375 int i, j, step; | 1334 int i, j, step; |
1376 | 1335 |
1377 unsigned char *what = (*(b->base_src) + b->src); | 1336 uint8_t *what = (*(b->base_src) + b->src); |
1378 int what_stride = b->src_stride; | 1337 int what_stride = b->src_stride; |
1379 unsigned char *in_what; | 1338 uint8_t *in_what; |
1380 int in_what_stride = d->pre_stride; | 1339 int in_what_stride = d->pre_stride; |
1381 unsigned char *best_address; | 1340 uint8_t *best_address; |
1382 | 1341 |
1383 int tot_steps; | 1342 int tot_steps; |
1384 int_mv this_mv; | 1343 int_mv this_mv; |
1385 | 1344 |
1386 unsigned int bestsad = INT_MAX; | 1345 unsigned int bestsad = INT_MAX; |
1387 int best_site = 0; | 1346 int best_site = 0; |
1388 int last_site = 0; | 1347 int last_site = 0; |
1389 | 1348 |
1390 int ref_row; | 1349 int ref_row; |
1391 int ref_col; | 1350 int ref_col; |
1392 int this_row_offset; | 1351 int this_row_offset; |
1393 int this_col_offset; | 1352 int this_col_offset; |
1394 search_site *ss; | 1353 search_site *ss; |
1395 | 1354 |
1396 unsigned char *check_here; | 1355 uint8_t *check_here; |
1397 unsigned int thissad; | 1356 unsigned int thissad; |
1398 MACROBLOCKD *xd = &x->e_mbd; | 1357 MACROBLOCKD *xd = &x->e_mbd; |
1399 int_mv fcenter_mv; | 1358 int_mv fcenter_mv; |
1400 | 1359 |
1401 int *mvjsadcost = x->nmvjointsadcost; | 1360 int *mvjsadcost = x->nmvjointsadcost; |
1402 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; | 1361 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; |
1403 | 1362 |
1404 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; | 1363 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; |
1405 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; | 1364 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; |
1406 | 1365 |
1407 clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max); | 1366 clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max); |
1408 ref_row = ref_mv->as_mv.row; | 1367 ref_row = ref_mv->as_mv.row; |
1409 ref_col = ref_mv->as_mv.col; | 1368 ref_col = ref_mv->as_mv.col; |
1410 *num00 = 0; | 1369 *num00 = 0; |
1411 best_mv->as_mv.row = ref_row; | 1370 best_mv->as_mv.row = ref_row; |
1412 best_mv->as_mv.col = ref_col; | 1371 best_mv->as_mv.col = ref_col; |
1413 | 1372 |
1414 // Work out the start point for the search | 1373 // Work out the start point for the search |
1415 in_what = (unsigned char *)(*(d->base_pre) + d->pre + (ref_row * (d->pre_strid
e)) + ref_col); | 1374 in_what = (uint8_t *)(*(d->base_pre) + d->pre + |
| 1375 (ref_row * (d->pre_stride)) + ref_col); |
1416 best_address = in_what; | 1376 best_address = in_what; |
1417 | 1377 |
1418 // Check the starting position | 1378 // Check the starting position |
1419 bestsad = fn_ptr->sdf(what, what_stride, | 1379 bestsad = fn_ptr->sdf(what, what_stride, |
1420 in_what, in_what_stride, 0x7fffffff) | 1380 in_what, in_what_stride, 0x7fffffff) |
1421 + mvsad_err_cost(best_mv, &fcenter_mv, mvjsadcost, mvsadcost, | 1381 + mvsad_err_cost(best_mv, &fcenter_mv, mvjsadcost, mvsadcost, |
1422 sad_per_bit); | 1382 sad_per_bit); |
1423 | 1383 |
1424 // search_param determines the length of the initial step and hence the number
of iterations | 1384 // search_param determines the length of the initial step and hence the number
of iterations |
1425 // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 = (MA
X_FIRST_STEP/4) pel... etc. | 1385 // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 = (MA
X_FIRST_STEP/4) pel... etc. |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1573 } | 1533 } |
1574 } | 1534 } |
1575 return bestsme; | 1535 return bestsme; |
1576 } | 1536 } |
1577 | 1537 |
1578 int vp9_full_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv, | 1538 int vp9_full_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv, |
1579 int sad_per_bit, int distance, | 1539 int sad_per_bit, int distance, |
1580 vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost, | 1540 vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost, |
1581 int *mvcost[2], | 1541 int *mvcost[2], |
1582 int_mv *center_mv) { | 1542 int_mv *center_mv) { |
1583 unsigned char *what = (*(b->base_src) + b->src); | 1543 uint8_t *what = (*(b->base_src) + b->src); |
1584 int what_stride = b->src_stride; | 1544 int what_stride = b->src_stride; |
1585 unsigned char *in_what; | 1545 uint8_t *in_what; |
1586 int in_what_stride = d->pre_stride; | 1546 int in_what_stride = d->pre_stride; |
1587 int mv_stride = d->pre_stride; | 1547 int mv_stride = d->pre_stride; |
1588 unsigned char *bestaddress; | 1548 uint8_t *bestaddress; |
1589 int_mv *best_mv = &d->bmi.as_mv.first; | 1549 int_mv *best_mv = &d->bmi.as_mv.first; |
1590 int_mv this_mv; | 1550 int_mv this_mv; |
1591 int bestsad = INT_MAX; | 1551 int bestsad = INT_MAX; |
1592 int r, c; | 1552 int r, c; |
1593 | 1553 |
1594 unsigned char *check_here; | 1554 uint8_t *check_here; |
1595 int thissad; | 1555 int thissad; |
1596 MACROBLOCKD *xd = &x->e_mbd; | 1556 MACROBLOCKD *xd = &x->e_mbd; |
1597 | 1557 |
1598 int ref_row = ref_mv->as_mv.row; | 1558 int ref_row = ref_mv->as_mv.row; |
1599 int ref_col = ref_mv->as_mv.col; | 1559 int ref_col = ref_mv->as_mv.col; |
1600 | 1560 |
1601 int row_min = ref_row - distance; | 1561 int row_min = ref_row - distance; |
1602 int row_max = ref_row + distance; | 1562 int row_max = ref_row + distance; |
1603 int col_min = ref_col - distance; | 1563 int col_min = ref_col - distance; |
1604 int col_max = ref_col + distance; | 1564 int col_max = ref_col + distance; |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1668 mv_err_cost(&this_mv, center_mv, mvjcost, mvcost, x->errorperbit, | 1628 mv_err_cost(&this_mv, center_mv, mvjcost, mvcost, x->errorperbit, |
1669 xd->allow_high_precision_mv); | 1629 xd->allow_high_precision_mv); |
1670 else | 1630 else |
1671 return INT_MAX; | 1631 return INT_MAX; |
1672 } | 1632 } |
1673 | 1633 |
1674 int vp9_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv, | 1634 int vp9_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv, |
1675 int sad_per_bit, int distance, | 1635 int sad_per_bit, int distance, |
1676 vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost, | 1636 vp9_variance_fn_ptr_t *fn_ptr, int *mvjcost, |
1677 int *mvcost[2], int_mv *center_mv) { | 1637 int *mvcost[2], int_mv *center_mv) { |
1678 unsigned char *what = (*(b->base_src) + b->src); | 1638 uint8_t *what = (*(b->base_src) + b->src); |
1679 int what_stride = b->src_stride; | 1639 int what_stride = b->src_stride; |
1680 unsigned char *in_what; | 1640 uint8_t *in_what; |
1681 int in_what_stride = d->pre_stride; | 1641 int in_what_stride = d->pre_stride; |
1682 int mv_stride = d->pre_stride; | 1642 int mv_stride = d->pre_stride; |
1683 unsigned char *bestaddress; | 1643 uint8_t *bestaddress; |
1684 int_mv *best_mv = &d->bmi.as_mv.first; | 1644 int_mv *best_mv = &d->bmi.as_mv.first; |
1685 int_mv this_mv; | 1645 int_mv this_mv; |
1686 unsigned int bestsad = INT_MAX; | 1646 unsigned int bestsad = INT_MAX; |
1687 int r, c; | 1647 int r, c; |
1688 | 1648 |
1689 unsigned char *check_here; | 1649 uint8_t *check_here; |
1690 unsigned int thissad; | 1650 unsigned int thissad; |
1691 MACROBLOCKD *xd = &x->e_mbd; | 1651 MACROBLOCKD *xd = &x->e_mbd; |
1692 | 1652 |
1693 int ref_row = ref_mv->as_mv.row; | 1653 int ref_row = ref_mv->as_mv.row; |
1694 int ref_col = ref_mv->as_mv.col; | 1654 int ref_col = ref_mv->as_mv.col; |
1695 | 1655 |
1696 int row_min = ref_row - distance; | 1656 int row_min = ref_row - distance; |
1697 int row_max = ref_row + distance; | 1657 int row_max = ref_row + distance; |
1698 int col_min = ref_col - distance; | 1658 int col_min = ref_col - distance; |
1699 int col_max = ref_col + distance; | 1659 int col_max = ref_col + distance; |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1797 xd->allow_high_precision_mv); | 1757 xd->allow_high_precision_mv); |
1798 else | 1758 else |
1799 return INT_MAX; | 1759 return INT_MAX; |
1800 } | 1760 } |
1801 | 1761 |
1802 int vp9_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv, | 1762 int vp9_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv, |
1803 int sad_per_bit, int distance, | 1763 int sad_per_bit, int distance, |
1804 vp9_variance_fn_ptr_t *fn_ptr, | 1764 vp9_variance_fn_ptr_t *fn_ptr, |
1805 int *mvjcost, int *mvcost[2], | 1765 int *mvjcost, int *mvcost[2], |
1806 int_mv *center_mv) { | 1766 int_mv *center_mv) { |
1807 unsigned char *what = (*(b->base_src) + b->src); | 1767 uint8_t *what = (*(b->base_src) + b->src); |
1808 int what_stride = b->src_stride; | 1768 int what_stride = b->src_stride; |
1809 unsigned char *in_what; | 1769 uint8_t *in_what; |
1810 int in_what_stride = d->pre_stride; | 1770 int in_what_stride = d->pre_stride; |
1811 int mv_stride = d->pre_stride; | 1771 int mv_stride = d->pre_stride; |
1812 unsigned char *bestaddress; | 1772 uint8_t *bestaddress; |
1813 int_mv *best_mv = &d->bmi.as_mv.first; | 1773 int_mv *best_mv = &d->bmi.as_mv.first; |
1814 int_mv this_mv; | 1774 int_mv this_mv; |
1815 unsigned int bestsad = INT_MAX; | 1775 unsigned int bestsad = INT_MAX; |
1816 int r, c; | 1776 int r, c; |
1817 | 1777 |
1818 unsigned char *check_here; | 1778 uint8_t *check_here; |
1819 unsigned int thissad; | 1779 unsigned int thissad; |
1820 MACROBLOCKD *xd = &x->e_mbd; | 1780 MACROBLOCKD *xd = &x->e_mbd; |
1821 | 1781 |
1822 int ref_row = ref_mv->as_mv.row; | 1782 int ref_row = ref_mv->as_mv.row; |
1823 int ref_col = ref_mv->as_mv.col; | 1783 int ref_col = ref_mv->as_mv.col; |
1824 | 1784 |
1825 int row_min = ref_row - distance; | 1785 int row_min = ref_row - distance; |
1826 int row_max = ref_row + distance; | 1786 int row_max = ref_row + distance; |
1827 int col_min = ref_col - distance; | 1787 int col_min = ref_col - distance; |
1828 int col_max = ref_col + distance; | 1788 int col_max = ref_col + distance; |
1829 | 1789 |
1830 DECLARE_ALIGNED_ARRAY(16, unsigned short, sad_array8, 8); | 1790 DECLARE_ALIGNED_ARRAY(16, uint16_t, sad_array8, 8); |
1831 unsigned int sad_array[3]; | 1791 unsigned int sad_array[3]; |
1832 int_mv fcenter_mv; | 1792 int_mv fcenter_mv; |
1833 | 1793 |
1834 int *mvjsadcost = x->nmvjointsadcost; | 1794 int *mvjsadcost = x->nmvjointsadcost; |
1835 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; | 1795 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; |
1836 | 1796 |
1837 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; | 1797 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; |
1838 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; | 1798 fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3; |
1839 | 1799 |
1840 // Work out the mid point for the search | 1800 // Work out the mid point for the search |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1952 xd->allow_high_precision_mv); | 1912 xd->allow_high_precision_mv); |
1953 else | 1913 else |
1954 return INT_MAX; | 1914 return INT_MAX; |
1955 } | 1915 } |
1956 int vp9_refining_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, | 1916 int vp9_refining_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, |
1957 int_mv *ref_mv, int error_per_bit, | 1917 int_mv *ref_mv, int error_per_bit, |
1958 int search_range, vp9_variance_fn_ptr_t *fn_ptr, | 1918 int search_range, vp9_variance_fn_ptr_t *fn_ptr, |
1959 int *mvjcost, int *mvcost[2], int_mv *center_mv) { | 1919 int *mvjcost, int *mvcost[2], int_mv *center_mv) { |
1960 MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}}; | 1920 MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}}; |
1961 int i, j; | 1921 int i, j; |
1962 short this_row_offset, this_col_offset; | 1922 int this_row_offset, this_col_offset; |
1963 | 1923 |
1964 int what_stride = b->src_stride; | 1924 int what_stride = b->src_stride; |
1965 int in_what_stride = d->pre_stride; | 1925 int in_what_stride = d->pre_stride; |
1966 unsigned char *what = (*(b->base_src) + b->src); | 1926 uint8_t *what = (*(b->base_src) + b->src); |
1967 unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre + | 1927 uint8_t *best_address = (uint8_t *)(*(d->base_pre) + d->pre + |
1968 (ref_mv->as_mv.row * (d->pre_s
tride)) + ref_mv->as_mv.col); | 1928 (ref_mv->as_mv.row * (d->pre_stride)) + |
1969 unsigned char *check_here; | 1929 ref_mv->as_mv.col); |
| 1930 uint8_t *check_here; |
1970 unsigned int thissad; | 1931 unsigned int thissad; |
1971 int_mv this_mv; | 1932 int_mv this_mv; |
1972 unsigned int bestsad = INT_MAX; | 1933 unsigned int bestsad = INT_MAX; |
1973 MACROBLOCKD *xd = &x->e_mbd; | 1934 MACROBLOCKD *xd = &x->e_mbd; |
1974 int_mv fcenter_mv; | 1935 int_mv fcenter_mv; |
1975 | 1936 |
1976 int *mvjsadcost = x->nmvjointsadcost; | 1937 int *mvjsadcost = x->nmvjointsadcost; |
1977 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; | 1938 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; |
1978 | 1939 |
1979 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; | 1940 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2029 else | 1990 else |
2030 return INT_MAX; | 1991 return INT_MAX; |
2031 } | 1992 } |
2032 | 1993 |
2033 int vp9_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, | 1994 int vp9_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d, |
2034 int_mv *ref_mv, int error_per_bit, | 1995 int_mv *ref_mv, int error_per_bit, |
2035 int search_range, vp9_variance_fn_ptr_t *fn_ptr, | 1996 int search_range, vp9_variance_fn_ptr_t *fn_ptr, |
2036 int *mvjcost, int *mvcost[2], int_mv *center_mv) { | 1997 int *mvjcost, int *mvcost[2], int_mv *center_mv) { |
2037 MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}}; | 1998 MV neighbors[4] = {{ -1, 0}, {0, -1}, {0, 1}, {1, 0}}; |
2038 int i, j; | 1999 int i, j; |
2039 short this_row_offset, this_col_offset; | 2000 int this_row_offset, this_col_offset; |
2040 | 2001 |
2041 int what_stride = b->src_stride; | 2002 int what_stride = b->src_stride; |
2042 int in_what_stride = d->pre_stride; | 2003 int in_what_stride = d->pre_stride; |
2043 unsigned char *what = (*(b->base_src) + b->src); | 2004 uint8_t *what = (*(b->base_src) + b->src); |
2044 unsigned char *best_address = (unsigned char *)(*(d->base_pre) + d->pre + | 2005 uint8_t *best_address = (uint8_t *)(*(d->base_pre) + d->pre + |
2045 (ref_mv->as_mv.row * (d->pre_s
tride)) + ref_mv->as_mv.col); | 2006 (ref_mv->as_mv.row * (d->pre_stride)) + |
2046 unsigned char *check_here; | 2007 ref_mv->as_mv.col); |
| 2008 uint8_t *check_here; |
2047 unsigned int thissad; | 2009 unsigned int thissad; |
2048 int_mv this_mv; | 2010 int_mv this_mv; |
2049 unsigned int bestsad = INT_MAX; | 2011 unsigned int bestsad = INT_MAX; |
2050 MACROBLOCKD *xd = &x->e_mbd; | 2012 MACROBLOCKD *xd = &x->e_mbd; |
2051 int_mv fcenter_mv; | 2013 int_mv fcenter_mv; |
2052 | 2014 |
2053 int *mvjsadcost = x->nmvjointsadcost; | 2015 int *mvjsadcost = x->nmvjointsadcost; |
2054 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; | 2016 int *mvsadcost[2] = {x->nmvsadcost[0], x->nmvsadcost[1]}; |
2055 | 2017 |
2056 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; | 2018 fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3; |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2146 int i, j; | 2108 int i, j; |
2147 | 2109 |
2148 fprintf(f, "#include \"vp9_entropy.h\"\n"); | 2110 fprintf(f, "#include \"vp9_entropy.h\"\n"); |
2149 fprintf(f, "const int vp9_mode_contexts[6][4] ="); | 2111 fprintf(f, "const int vp9_mode_contexts[6][4] ="); |
2150 fprintf(f, "{\n"); | 2112 fprintf(f, "{\n"); |
2151 for (j = 0; j < 6; j++) { | 2113 for (j = 0; j < 6; j++) { |
2152 fprintf(f, " {/* %d */ ", j); | 2114 fprintf(f, " {/* %d */ ", j); |
2153 fprintf(f, " "); | 2115 fprintf(f, " "); |
2154 for (i = 0; i < 4; i++) { | 2116 for (i = 0; i < 4; i++) { |
2155 int this_prob; | 2117 int this_prob; |
2156 int count; | |
2157 | 2118 |
2158 // context probs | 2119 // context probs |
2159 count = mv_ref_ct[j][i][0] + mv_ref_ct[j][i][1]; | 2120 this_prob = get_binary_prob(mv_ref_ct[j][i][0], mv_ref_ct[j][i][1]); |
2160 if (count) | |
2161 this_prob = 256 * mv_ref_ct[j][i][0] / count; | |
2162 else | |
2163 this_prob = 128; | |
2164 | 2121 |
2165 if (this_prob == 0) | |
2166 this_prob = 1; | |
2167 fprintf(f, "%5d, ", this_prob); | 2122 fprintf(f, "%5d, ", this_prob); |
2168 } | 2123 } |
2169 fprintf(f, " },\n"); | 2124 fprintf(f, " },\n"); |
2170 } | 2125 } |
2171 | 2126 |
2172 fprintf(f, "};\n"); | 2127 fprintf(f, "};\n"); |
2173 fclose(f); | 2128 fclose(f); |
2174 } | 2129 } |
2175 | 2130 |
2176 /* MV ref count ENTROPY_STATS stats code */ | 2131 /* MV ref count ENTROPY_STATS stats code */ |
(...skipping 30 matching lines...) Expand all Loading... |
2207 } else { | 2162 } else { |
2208 ++mv_ref_ct [ct[3]] [3] [1]; | 2163 ++mv_ref_ct [ct[3]] [3] [1]; |
2209 ++mv_mode_cts[3][1]; | 2164 ++mv_mode_cts[3][1]; |
2210 } | 2165 } |
2211 } | 2166 } |
2212 } | 2167 } |
2213 } | 2168 } |
2214 } | 2169 } |
2215 | 2170 |
2216 #endif/* END MV ref count ENTROPY_STATS stats code */ | 2171 #endif/* END MV ref count ENTROPY_STATS stats code */ |
OLD | NEW |