OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2010 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 |
| 11 |
| 12 #include "vp9/common/vp9_blockd.h" |
| 13 |
| 14 typedef enum { |
| 15 PRED = 0, |
| 16 DEST = 1 |
| 17 } BLOCKSET; |
| 18 |
| 19 static void setup_block |
| 20 ( |
| 21 BLOCKD *b, |
| 22 int mv_stride, |
| 23 unsigned char **base, |
| 24 unsigned char **base2, |
| 25 int Stride, |
| 26 int offset, |
| 27 BLOCKSET bs |
| 28 ) { |
| 29 |
| 30 if (bs == DEST) { |
| 31 b->dst_stride = Stride; |
| 32 b->dst = offset; |
| 33 b->base_dst = base; |
| 34 } else { |
| 35 b->pre_stride = Stride; |
| 36 b->pre = offset; |
| 37 b->base_pre = base; |
| 38 b->base_second_pre = base2; |
| 39 } |
| 40 |
| 41 } |
| 42 |
| 43 |
| 44 static void setup_macroblock(MACROBLOCKD *xd, BLOCKSET bs) { |
| 45 int block; |
| 46 |
| 47 unsigned char **y, **u, **v; |
| 48 unsigned char **y2, **u2, **v2; |
| 49 BLOCKD *blockd = xd->block; |
| 50 int stride; |
| 51 |
| 52 if (bs == DEST) { |
| 53 y = &xd->dst.y_buffer; |
| 54 u = &xd->dst.u_buffer; |
| 55 v = &xd->dst.v_buffer; |
| 56 } else { |
| 57 y = &xd->pre.y_buffer; |
| 58 u = &xd->pre.u_buffer; |
| 59 v = &xd->pre.v_buffer; |
| 60 |
| 61 y2 = &xd->second_pre.y_buffer; |
| 62 u2 = &xd->second_pre.u_buffer; |
| 63 v2 = &xd->second_pre.v_buffer; |
| 64 } |
| 65 |
| 66 stride = xd->dst.y_stride; |
| 67 for (block = 0; block < 16; block++) { /* y blocks */ |
| 68 setup_block(&blockd[block], stride, y, y2, stride, |
| 69 (block >> 2) * 4 * stride + (block & 3) * 4, bs); |
| 70 } |
| 71 |
| 72 stride = xd->dst.uv_stride; |
| 73 for (block = 16; block < 20; block++) { /* U and V blocks */ |
| 74 setup_block(&blockd[block], stride, u, u2, stride, |
| 75 ((block - 16) >> 1) * 4 * stride + (block & 1) * 4, bs); |
| 76 |
| 77 setup_block(&blockd[block + 4], stride, v, v2, stride, |
| 78 ((block - 16) >> 1) * 4 * stride + (block & 1) * 4, bs); |
| 79 } |
| 80 } |
| 81 |
| 82 void vp9_setup_block_dptrs(MACROBLOCKD *xd) { |
| 83 int r, c; |
| 84 BLOCKD *blockd = xd->block; |
| 85 |
| 86 for (r = 0; r < 4; r++) { |
| 87 for (c = 0; c < 4; c++) { |
| 88 blockd[r * 4 + c].diff = &xd->diff[r * 4 * 16 + c * 4]; |
| 89 blockd[r * 4 + c].predictor = xd->predictor + r * 4 * 16 + c * 4; |
| 90 } |
| 91 } |
| 92 |
| 93 for (r = 0; r < 2; r++) { |
| 94 for (c = 0; c < 2; c++) { |
| 95 blockd[16 + r * 2 + c].diff = &xd->diff[256 + r * 4 * 8 + c * 4]; |
| 96 blockd[16 + r * 2 + c].predictor = |
| 97 xd->predictor + 256 + r * 4 * 8 + c * 4; |
| 98 |
| 99 } |
| 100 } |
| 101 |
| 102 for (r = 0; r < 2; r++) { |
| 103 for (c = 0; c < 2; c++) { |
| 104 blockd[20 + r * 2 + c].diff = &xd->diff[320 + r * 4 * 8 + c * 4]; |
| 105 blockd[20 + r * 2 + c].predictor = |
| 106 xd->predictor + 320 + r * 4 * 8 + c * 4; |
| 107 |
| 108 } |
| 109 } |
| 110 |
| 111 blockd[24].diff = &xd->diff[384]; |
| 112 |
| 113 for (r = 0; r < 25; r++) { |
| 114 blockd[r].qcoeff = xd->qcoeff + r * 16; |
| 115 blockd[r].dqcoeff = xd->dqcoeff + r * 16; |
| 116 } |
| 117 } |
| 118 |
| 119 void vp9_build_block_doffsets(MACROBLOCKD *xd) { |
| 120 |
| 121 /* handle the destination pitch features */ |
| 122 setup_macroblock(xd, DEST); |
| 123 setup_macroblock(xd, PRED); |
| 124 } |
OLD | NEW |