1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
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
103
104
105
106
107
108
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
145
146
147
148
149
150
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
|
/*
* Copyright (C) 2007-2008 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/**
*
* File Name: armVCM4P2_BlockMatch_Integer.c
* OpenMAX DL: v1.0.2
* Revision: 9641
* Date: Thursday, February 7, 2008
*
*
*
*
* Description:
* Contains modules for Block matching, a full search algorithm
* is implemented
*
*/
#include "omxtypes.h"
#include "armOMX.h"
#include "omxVC.h"
#include "armVC.h"
#include "armCOMM.h"
/**
* Function: armVCM4P2_BlockMatch_Integer
*
* Description:
* Performs a 16x16 block search; estimates motion vector and associated minimum SAD.
* Both the input and output motion vectors are represented using half-pixel units, and
* therefore a shift left or right by 1 bit may be required, respectively, to match the
* input or output MVs with other functions that either generate output MVs or expect
* input MVs represented using integer pixel units.
*
* Remarks:
*
* Parameters:
* [in] pSrcRefBuf pointer to the reference Y plane; points to the reference MB that
* corresponds to the location of the current macroblock in the current
* plane.
* [in] refWidth width of the reference plane
* [in] pRefRect pointer to the valid rectangular in reference plane. Relative to image origin.
* It's not limited to the image boundary, but depended on the padding. For example,
* if you pad 4 pixels outside the image border, then the value for left border
* can be -4
* [in] pSrcCurrBuf pointer to the current macroblock extracted from original plane (linear array,
* 256 entries); must be aligned on an 8-byte boundary.
* [in] pCurrPointPos position of the current macroblock in the current plane
* [in] pSrcPreMV pointer to predicted motion vector; NULL indicates no predicted MV
* [in] pSrcPreSAD pointer to SAD associated with the predicted MV (referenced by pSrcPreMV)
* [in] searchRange search range for 16X16 integer block,the units of it is full pixel,the search range
* is the same in all directions.It is in inclusive of the boundary and specified in
* terms of integer pixel units.
* [in] pMESpec vendor-specific motion estimation specification structure; must have been allocated
* and then initialized using omxVCM4P2_MEInit prior to calling the block matching
* function.
* [out] pDstMV pointer to estimated MV
* [out] pDstSAD pointer to minimum SAD
*
* Return Value:
* OMX_Sts_NoErr ¨C no error.
* OMX_Sts_BadArgErr ¨C bad arguments
*
*/
OMXResult armVCM4P2_BlockMatch_Integer(
const OMX_U8 *pSrcRefBuf,
OMX_INT refWidth,
const OMXRect *pRefRect,
const OMX_U8 *pSrcCurrBuf,
const OMXVCM4P2Coordinate *pCurrPointPos,
const OMXVCMotionVector *pSrcPreMV,
const OMX_INT *pSrcPreSAD,
void *pMESpec,
OMXVCMotionVector *pDstMV,
OMX_INT *pDstSAD,
OMX_U8 BlockSize
)
{
/* Definitions and Initializations*/
OMX_INT outer, inner, count,index;
OMX_INT candSAD;
/*(256*256 +1) this is to make the SAD max initially*/
OMX_INT minSAD = 0x10001, fromX, toX, fromY, toY;
/* Offset to the reference at the begining of the bounding box */
const OMX_U8 *pTempSrcRefBuf;
OMX_S16 x, y;
OMX_INT searchRange;
/* Argument error checks */
armRetArgErrIf(pSrcRefBuf == NULL, OMX_Sts_BadArgErr);
armRetArgErrIf(pRefRect == NULL, OMX_Sts_BadArgErr);
armRetArgErrIf(pSrcCurrBuf == NULL, OMX_Sts_BadArgErr);
armRetArgErrIf(pCurrPointPos == NULL, OMX_Sts_BadArgErr);
armRetArgErrIf(pMESpec == NULL, OMX_Sts_BadArgErr);
armRetArgErrIf(pDstMV == NULL, OMX_Sts_BadArgErr);
armRetArgErrIf(pDstSAD == NULL, OMX_Sts_BadArgErr);
searchRange = ((OMXVCM4P2MEParams *)pMESpec)->searchRange;
/* Check for valid region */
fromX = searchRange;
toX = searchRange;
fromY = searchRange;
toY = searchRange;
if ((pCurrPointPos->x - searchRange) < pRefRect->x)
{
fromX = pCurrPointPos->x - pRefRect->x;
}
if ((pCurrPointPos->x + BlockSize + searchRange) > (pRefRect->x + pRefRect->width))
{
toX = pRefRect->width - (pCurrPointPos->x - pRefRect->x) - BlockSize;
}
if ((pCurrPointPos->y - searchRange) < pRefRect->y)
{
fromY = pCurrPointPos->y - pRefRect->y;
}
if ((pCurrPointPos->y + BlockSize + searchRange) > (pRefRect->y + pRefRect->height))
{
toY = pRefRect->width - (pCurrPointPos->y - pRefRect->y) - BlockSize;
}
pDstMV->dx = -fromX;
pDstMV->dy = -fromY;
/* Looping on y- axis */
for (y = -fromY; y <= toY; y++)
{
/* Looping on x- axis */
for (x = -fromX; x <= toX; x++)
{
/* Positioning the pointer */
pTempSrcRefBuf = pSrcRefBuf + (refWidth * y) + x;
/* Calculate the SAD */
for (outer = 0, count = 0, index = 0, candSAD = 0;
outer < BlockSize;
outer++, index += refWidth - BlockSize)
{
for (inner = 0; inner < BlockSize; inner++, count++, index++)
{
candSAD += armAbs (pTempSrcRefBuf[index] - pSrcCurrBuf[count]);
}
}
/* Result calculations */
if (armVCM4P2_CompareMV (x, y, candSAD, pDstMV->dx/2, pDstMV->dy/2, minSAD))
{
*pDstSAD = candSAD;
minSAD = candSAD;
pDstMV->dx = x*2;
pDstMV->dy = y*2;
}
} /* End of x- axis */
} /* End of y-axis */
return OMX_Sts_NoErr;
}
/* End of file */
|
