Parent Directory | Revision Log
Revision 1.25 - (view) (download)
1 : | edgomez | 1.2 | /***************************************************************************** |
2 : | * | ||
3 : | * XVID MPEG-4 VIDEO CODEC | ||
4 : | * - Motion Estimation for P- and S- VOPs - | ||
5 : | * | ||
6 : | * Copyright(C) 2002 Christoph Lampert <gruel@web.de> | ||
7 : | Isibaar | 1.23 | * 2002-2010 Michael Militzer <michael@xvid.org> |
8 : | edgomez | 1.2 | * 2002-2003 Radoslaw Czyz <xvid@syskin.cjb.net> |
9 : | * | ||
10 : | * This program is free software ; you can redistribute it and/or modify | ||
11 : | * it under the terms of the GNU General Public License as published by | ||
12 : | * the Free Software Foundation ; either version 2 of the License, or | ||
13 : | * (at your option) any later version. | ||
14 : | * | ||
15 : | * This program is distributed in the hope that it will be useful, | ||
16 : | * but WITHOUT ANY WARRANTY ; without even the implied warranty of | ||
17 : | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 : | * GNU General Public License for more details. | ||
19 : | * | ||
20 : | * You should have received a copy of the GNU General Public License | ||
21 : | * along with this program ; if not, write to the Free Software | ||
22 : | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
23 : | * | ||
24 : | Isibaar | 1.25 | * $Id: estimation_pvop.c,v 1.24 2010/12/18 16:02:00 Isibaar Exp $ |
25 : | edgomez | 1.2 | * |
26 : | ****************************************************************************/ | ||
27 : | |||
28 : | #include <assert.h> | ||
29 : | #include <stdio.h> | ||
30 : | #include <stdlib.h> | ||
31 : | #include <string.h> /* memcpy */ | ||
32 : | |||
33 : | #include "../encoder.h" | ||
34 : | #include "../prediction/mbprediction.h" | ||
35 : | #include "../global.h" | ||
36 : | #include "../utils/timer.h" | ||
37 : | #include "../image/interpolate8x8.h" | ||
38 : | #include "estimation.h" | ||
39 : | #include "motion.h" | ||
40 : | #include "sad.h" | ||
41 : | #include "motion_inlines.h" | ||
42 : | syskin | 1.19 | #include "motion_smp.h" |
43 : | |||
44 : | edgomez | 1.2 | |
45 : | static const int xvid_me_lambda_vec8[32] = | ||
46 : | Isibaar | 1.16 | { 0 ,(int)(1.0 * NEIGH_TEND_8X8 + 0.5), |
47 : | (int)(2.0*NEIGH_TEND_8X8 + 0.5), (int)(3.0*NEIGH_TEND_8X8 + 0.5), | ||
48 : | (int)(4.0*NEIGH_TEND_8X8 + 0.5), (int)(5.0*NEIGH_TEND_8X8 + 0.5), | ||
49 : | (int)(6.0*NEIGH_TEND_8X8 + 0.5), (int)(7.0*NEIGH_TEND_8X8 + 0.5), | ||
50 : | (int)(8.0*NEIGH_TEND_8X8 + 0.5), (int)(9.0*NEIGH_TEND_8X8 + 0.5), | ||
51 : | (int)(10.0*NEIGH_TEND_8X8 + 0.5), (int)(11.0*NEIGH_TEND_8X8 + 0.5), | ||
52 : | (int)(12.0*NEIGH_TEND_8X8 + 0.5), (int)(13.0*NEIGH_TEND_8X8 + 0.5), | ||
53 : | (int)(14.0*NEIGH_TEND_8X8 + 0.5), (int)(15.0*NEIGH_TEND_8X8 + 0.5), | ||
54 : | (int)(16.0*NEIGH_TEND_8X8 + 0.5), (int)(17.0*NEIGH_TEND_8X8 + 0.5), | ||
55 : | (int)(18.0*NEIGH_TEND_8X8 + 0.5), (int)(19.0*NEIGH_TEND_8X8 + 0.5), | ||
56 : | (int)(20.0*NEIGH_TEND_8X8 + 0.5), (int)(21.0*NEIGH_TEND_8X8 + 0.5), | ||
57 : | (int)(22.0*NEIGH_TEND_8X8 + 0.5), (int)(23.0*NEIGH_TEND_8X8 + 0.5), | ||
58 : | (int)(24.0*NEIGH_TEND_8X8 + 0.5), (int)(25.0*NEIGH_TEND_8X8 + 0.5), | ||
59 : | (int)(26.0*NEIGH_TEND_8X8 + 0.5), (int)(27.0*NEIGH_TEND_8X8 + 0.5), | ||
60 : | (int)(28.0*NEIGH_TEND_8X8 + 0.5), (int)(29.0*NEIGH_TEND_8X8 + 0.5), | ||
61 : | (int)(30.0*NEIGH_TEND_8X8 + 0.5), (int)(31.0*NEIGH_TEND_8X8 + 0.5) | ||
62 : | edgomez | 1.2 | }; |
63 : | |||
64 : | static void | ||
65 : | CheckCandidate16(const int x, const int y, SearchData * const data, const unsigned int Direction) | ||
66 : | { | ||
67 : | const uint8_t * Reference; | ||
68 : | syskin | 1.4 | int32_t sad, xc, yc; uint32_t t; |
69 : | VECTOR * current; | ||
70 : | edgomez | 1.2 | |
71 : | if ( (x > data->max_dx) || (x < data->min_dx) | ||
72 : | || (y > data->max_dy) || (y < data->min_dy) ) return; | ||
73 : | |||
74 : | syskin | 1.4 | if (data->qpel_precision) { /* x and y are in 1/4 precision */ |
75 : | Reference = xvid_me_interpolate16x16qpel(x, y, 0, data); | ||
76 : | current = data->currentQMV; | ||
77 : | xc = x/2; yc = y/2; | ||
78 : | } else { | ||
79 : | Reference = GetReference(x, y, data); | ||
80 : | current = data->currentMV; | ||
81 : | xc = x; yc = y; | ||
82 : | } | ||
83 : | edgomez | 1.2 | |
84 : | sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp); | ||
85 : | syskin | 1.9 | t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision); |
86 : | edgomez | 1.2 | |
87 : | Isibaar | 1.16 | sad += (data->lambda16 * t); |
88 : | data->temp[0] += (data->lambda8 * t); | ||
89 : | edgomez | 1.2 | |
90 : | if (data->chroma) { | ||
91 : | if (sad >= data->iMinSAD[0]) goto no16; | ||
92 : | syskin | 1.4 | sad += xvid_me_ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3], |
93 : | (yc >> 1) + roundtab_79[yc & 0x3], data); | ||
94 : | edgomez | 1.2 | } |
95 : | |||
96 : | if (sad < data->iMinSAD[0]) { | ||
97 : | data->iMinSAD[0] = sad; | ||
98 : | syskin | 1.4 | current[0].x = x; current[0].y = y; |
99 : | edgomez | 1.2 | data->dir = Direction; |
100 : | } | ||
101 : | |||
102 : | no16: | ||
103 : | if (data->temp[0] < data->iMinSAD[1]) { | ||
104 : | syskin | 1.4 | data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; } |
105 : | edgomez | 1.2 | if (data->temp[1] < data->iMinSAD[2]) { |
106 : | syskin | 1.4 | data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; } |
107 : | edgomez | 1.2 | if (data->temp[2] < data->iMinSAD[3]) { |
108 : | syskin | 1.4 | data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; } |
109 : | edgomez | 1.2 | if (data->temp[3] < data->iMinSAD[4]) { |
110 : | syskin | 1.4 | data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; } |
111 : | edgomez | 1.2 | } |
112 : | |||
113 : | static void | ||
114 : | CheckCandidate8(const int x, const int y, SearchData * const data, const unsigned int Direction) | ||
115 : | { | ||
116 : | int32_t sad; uint32_t t; | ||
117 : | const uint8_t * Reference; | ||
118 : | VECTOR * current; | ||
119 : | |||
120 : | if ( (x > data->max_dx) || (x < data->min_dx) | ||
121 : | || (y > data->max_dy) || (y < data->min_dy) ) return; | ||
122 : | |||
123 : | if (!data->qpel_precision) { | ||
124 : | Reference = GetReference(x, y, data); | ||
125 : | current = data->currentMV; | ||
126 : | } else { /* x and y are in 1/4 precision */ | ||
127 : | Reference = xvid_me_interpolate8x8qpel(x, y, 0, 0, data); | ||
128 : | current = data->currentQMV; | ||
129 : | } | ||
130 : | |||
131 : | sad = sad8(data->Cur, Reference, data->iEdgedWidth); | ||
132 : | syskin | 1.9 | t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision); |
133 : | edgomez | 1.2 | |
134 : | Isibaar | 1.16 | sad += (data->lambda8 * t); |
135 : | edgomez | 1.2 | |
136 : | if (sad < *(data->iMinSAD)) { | ||
137 : | *(data->iMinSAD) = sad; | ||
138 : | current->x = x; current->y = y; | ||
139 : | data->dir = Direction; | ||
140 : | } | ||
141 : | } | ||
142 : | |||
143 : | int | ||
144 : | xvid_me_SkipDecisionP(const IMAGE * current, const IMAGE * reference, | ||
145 : | const int x, const int y, | ||
146 : | syskin | 1.9 | const uint32_t stride, const uint32_t iQuant) |
147 : | edgomez | 1.2 | { |
148 : | int offset = (x + y*stride)*8; | ||
149 : | syskin | 1.9 | uint32_t sadC = sad8(current->u + offset, |
150 : | reference->u + offset, stride); | ||
151 : | if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; | ||
152 : | sadC += sad8(current->v + offset, | ||
153 : | reference->v + offset, stride); | ||
154 : | if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0; | ||
155 : | return 1; | ||
156 : | edgomez | 1.2 | } |
157 : | |||
158 : | /* | ||
159 : | * pmv are filled with: | ||
160 : | * [0]: Median (or whatever is correct in a special case) | ||
161 : | * [1]: left neighbour | ||
162 : | * [2]: top neighbour | ||
163 : | * [3]: topright neighbour | ||
164 : | * psad are filled with: | ||
165 : | * [0]: minimum of [1] to [3] | ||
166 : | * [1]: left neighbour's SAD (NB:[1] to [3] are actually not needed) | ||
167 : | * [2]: top neighbour's SAD | ||
168 : | * [3]: topright neighbour's SAD | ||
169 : | */ | ||
170 : | |||
171 : | static __inline void | ||
172 : | get_pmvdata2(const MACROBLOCK * const mbs, | ||
173 : | const int mb_width, | ||
174 : | const int bound, | ||
175 : | const int x, | ||
176 : | const int y, | ||
177 : | VECTOR * const pmv, | ||
178 : | int32_t * const psad) | ||
179 : | { | ||
180 : | int lx, ly, lz; /* left */ | ||
181 : | int tx, ty, tz; /* top */ | ||
182 : | int rx, ry, rz; /* top-right */ | ||
183 : | int lpos, tpos, rpos; | ||
184 : | int num_cand = 0, last_cand = 1; | ||
185 : | |||
186 : | lx = x - 1; ly = y; lz = 1; | ||
187 : | tx = x; ty = y - 1; tz = 2; | ||
188 : | rx = x + 1; ry = y - 1; rz = 2; | ||
189 : | |||
190 : | lpos = lx + ly * mb_width; | ||
191 : | rpos = rx + ry * mb_width; | ||
192 : | tpos = tx + ty * mb_width; | ||
193 : | |||
194 : | if (lpos >= bound && lx >= 0) { | ||
195 : | num_cand++; | ||
196 : | last_cand = 1; | ||
197 : | pmv[1] = mbs[lpos].mvs[lz]; | ||
198 : | psad[1] = mbs[lpos].sad8[lz]; | ||
199 : | } else { | ||
200 : | pmv[1] = zeroMV; | ||
201 : | psad[1] = MV_MAX_ERROR; | ||
202 : | } | ||
203 : | |||
204 : | if (tpos >= bound) { | ||
205 : | num_cand++; | ||
206 : | last_cand = 2; | ||
207 : | pmv[2]= mbs[tpos].mvs[tz]; | ||
208 : | psad[2] = mbs[tpos].sad8[tz]; | ||
209 : | } else { | ||
210 : | pmv[2] = zeroMV; | ||
211 : | psad[2] = MV_MAX_ERROR; | ||
212 : | } | ||
213 : | |||
214 : | if (rpos >= bound && rx < mb_width) { | ||
215 : | num_cand++; | ||
216 : | last_cand = 3; | ||
217 : | pmv[3] = mbs[rpos].mvs[rz]; | ||
218 : | psad[3] = mbs[rpos].sad8[rz]; | ||
219 : | } else { | ||
220 : | pmv[3] = zeroMV; | ||
221 : | psad[3] = MV_MAX_ERROR; | ||
222 : | } | ||
223 : | |||
224 : | /* original pmvdata() compatibility hack */ | ||
225 : | if (x == 0 && y == 0) { | ||
226 : | pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV; | ||
227 : | psad[0] = 0; | ||
228 : | psad[1] = psad[2] = psad[3] = MV_MAX_ERROR; | ||
229 : | return; | ||
230 : | } | ||
231 : | |||
232 : | /* if only one valid candidate preictor, the invalid candiates are set to the canidate */ | ||
233 : | if (num_cand == 1) { | ||
234 : | pmv[0] = pmv[last_cand]; | ||
235 : | psad[0] = psad[last_cand]; | ||
236 : | return; | ||
237 : | } | ||
238 : | |||
239 : | if ((MVequal(pmv[1], pmv[2])) && (MVequal(pmv[1], pmv[3]))) { | ||
240 : | pmv[0] = pmv[1]; | ||
241 : | psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]); | ||
242 : | return; | ||
243 : | } | ||
244 : | |||
245 : | /* set median, minimum */ | ||
246 : | |||
247 : | pmv[0].x = | ||
248 : | MIN(MAX(pmv[1].x, pmv[2].x), | ||
249 : | MIN(MAX(pmv[2].x, pmv[3].x), MAX(pmv[1].x, pmv[3].x))); | ||
250 : | pmv[0].y = | ||
251 : | MIN(MAX(pmv[1].y, pmv[2].y), | ||
252 : | MIN(MAX(pmv[2].y, pmv[3].y), MAX(pmv[1].y, pmv[3].y))); | ||
253 : | |||
254 : | psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]); | ||
255 : | |||
256 : | } | ||
257 : | |||
258 : | |||
259 : | static void | ||
260 : | ModeDecision_SAD(SearchData * const Data, | ||
261 : | MACROBLOCK * const pMB, | ||
262 : | const MACROBLOCK * const pMBs, | ||
263 : | const int x, const int y, | ||
264 : | const MBParam * const pParam, | ||
265 : | const uint32_t MotionFlags, | ||
266 : | const uint32_t VopFlags, | ||
267 : | const uint32_t VolFlags, | ||
268 : | const IMAGE * const pCurrent, | ||
269 : | const IMAGE * const pRef, | ||
270 : | const IMAGE * const vGMC, | ||
271 : | syskin | 1.5 | const int coding_type, |
272 : | const int skip_sad) | ||
273 : | edgomez | 1.2 | { |
274 : | int mode = MODE_INTER; | ||
275 : | int mcsel = 0; | ||
276 : | int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0); | ||
277 : | const uint32_t iQuant = pMB->quant; | ||
278 : | |||
279 : | const int skip_possible = (coding_type == P_VOP) && (pMB->dquant == 0); | ||
280 : | |||
281 : | int sad; | ||
282 : | int InterBias = MV16_INTER_BIAS; | ||
283 : | |||
284 : | pMB->mcsel = 0; | ||
285 : | |||
286 : | if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] + | ||
287 : | Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) { | ||
288 : | mode = MODE_INTER; | ||
289 : | sad = Data->iMinSAD[0]; | ||
290 : | } else { | ||
291 : | mode = MODE_INTER4V; | ||
292 : | sad = Data->iMinSAD[1] + Data->iMinSAD[2] + | ||
293 : | Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant; | ||
294 : | Data->iMinSAD[0] = sad; | ||
295 : | } | ||
296 : | |||
297 : | /* final skip decision, a.k.a. "the vector you found, really that good?" */ | ||
298 : | syskin | 1.5 | if (skip_possible && (skip_sad < (int)iQuant * MAX_SAD00_FOR_SKIP)) |
299 : | syskin | 1.22 | if ( (100*skip_sad)/(pMB->sad16+1) < FINAL_SKIP_THRESH) |
300 : | syskin | 1.9 | if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant)) { |
301 : | edgomez | 1.2 | mode = MODE_NOT_CODED; |
302 : | sad = 0; | ||
303 : | } | ||
304 : | |||
305 : | /* mcsel */ | ||
306 : | if (coding_type == S_VOP) { | ||
307 : | |||
308 : | int32_t iSAD = sad16(Data->Cur, | ||
309 : | vGMC->y + 16*y*Data->iEdgedWidth + 16*x, Data->iEdgedWidth, 65536); | ||
310 : | |||
311 : | if (Data->chroma) { | ||
312 : | iSAD += sad8(Data->CurU, vGMC->u + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2); | ||
313 : | iSAD += sad8(Data->CurV, vGMC->v + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2); | ||
314 : | } | ||
315 : | |||
316 : | if (iSAD <= sad) { /* mode decision GMC */ | ||
317 : | mode = MODE_INTER; | ||
318 : | mcsel = 1; | ||
319 : | sad = iSAD; | ||
320 : | } | ||
321 : | } | ||
322 : | |||
323 : | /* intra decision */ | ||
324 : | |||
325 : | if (iQuant > 10) InterBias += 60 * (iQuant - 10); /* to make high quants work */ | ||
326 : | if (y != 0) | ||
327 : | if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80; | ||
328 : | if (x != 0) | ||
329 : | if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80; | ||
330 : | |||
331 : | if (Data->chroma) InterBias += 50; /* dev8(chroma) ??? <-- yes, we need dev8 (no big difference though) */ | ||
332 : | |||
333 : | if (InterBias < sad) { | ||
334 : | syskin | 1.9 | int32_t deviation = dev16(Data->Cur, Data->iEdgedWidth); |
335 : | edgomez | 1.2 | if (deviation < (sad - InterBias)) mode = MODE_INTRA; |
336 : | } | ||
337 : | |||
338 : | pMB->cbp = 63; | ||
339 : | pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad; | ||
340 : | |||
341 : | if (mode == MODE_INTER && mcsel == 0) { | ||
342 : | pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0]; | ||
343 : | |||
344 : | if(Data->qpel) { | ||
345 : | pMB->qmvs[0] = pMB->qmvs[1] | ||
346 : | = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0]; | ||
347 : | pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x; | ||
348 : | pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y; | ||
349 : | } else { | ||
350 : | pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x; | ||
351 : | pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y; | ||
352 : | } | ||
353 : | |||
354 : | } else if (mode == MODE_INTER ) { /* but mcsel == 1 */ | ||
355 : | |||
356 : | pMB->mcsel = 1; | ||
357 : | if (Data->qpel) { | ||
358 : | pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv; | ||
359 : | pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2; | ||
360 : | pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2; | ||
361 : | } else | ||
362 : | pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv; | ||
363 : | |||
364 : | } else | ||
365 : | if (mode == MODE_INTER4V) ; /* anything here? */ | ||
366 : | else /* INTRA, NOT_CODED */ | ||
367 : | ZeroMacroblockP(pMB, 0); | ||
368 : | |||
369 : | pMB->mode = mode; | ||
370 : | } | ||
371 : | |||
372 : | static __inline void | ||
373 : | PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount, | ||
374 : | syskin | 1.9 | int iHcount, const MACROBLOCK * const prevMB) |
375 : | edgomez | 1.2 | { |
376 : | |||
377 : | if ( (y != 0) && (x < (iWcount-1)) ) { /* [5] top-right neighbour */ | ||
378 : | pmv[5].x = EVEN(pmv[3].x); | ||
379 : | pmv[5].y = EVEN(pmv[3].y); | ||
380 : | } else pmv[5].x = pmv[5].y = 0; | ||
381 : | |||
382 : | if (x != 0) { pmv[3].x = EVEN(pmv[1].x); pmv[3].y = EVEN(pmv[1].y); }/* pmv[3] is left neighbour */ | ||
383 : | else pmv[3].x = pmv[3].y = 0; | ||
384 : | |||
385 : | if (y != 0) { pmv[4].x = EVEN(pmv[2].x); pmv[4].y = EVEN(pmv[2].y); }/* [4] top neighbour */ | ||
386 : | else pmv[4].x = pmv[4].y = 0; | ||
387 : | |||
388 : | /* [1] median prediction */ | ||
389 : | pmv[1].x = EVEN(pmv[0].x); pmv[1].y = EVEN(pmv[0].y); | ||
390 : | |||
391 : | pmv[0].x = pmv[0].y = 0; /* [0] is zero; not used in the loop (checked before) but needed here for make_mask */ | ||
392 : | |||
393 : | pmv[2].x = EVEN(prevMB->mvs[0].x); /* [2] is last frame */ | ||
394 : | pmv[2].y = EVEN(prevMB->mvs[0].y); | ||
395 : | |||
396 : | if ((x < iWcount-1) && (y < iHcount-1)) { | ||
397 : | pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); /* [6] right-down neighbour in last frame */ | ||
398 : | pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y); | ||
399 : | } else pmv[6].x = pmv[6].y = 0; | ||
400 : | } | ||
401 : | |||
402 : | static void | ||
403 : | Search8(SearchData * const OldData, | ||
404 : | const int x, const int y, | ||
405 : | const uint32_t MotionFlags, | ||
406 : | const MBParam * const pParam, | ||
407 : | MACROBLOCK * const pMB, | ||
408 : | const MACROBLOCK * const pMBs, | ||
409 : | const int block, | ||
410 : | Isibaar | 1.24 | SearchData * const Data, |
411 : | const int bound) | ||
412 : | edgomez | 1.2 | { |
413 : | int i = 0; | ||
414 : | syskin | 1.4 | VECTOR vbest_q; int32_t sbest_q; |
415 : | edgomez | 1.2 | *Data->iMinSAD = *(OldData->iMinSAD + 1 + block); |
416 : | *Data->currentMV = *(OldData->currentMV + 1 + block); | ||
417 : | *Data->currentQMV = *(OldData->currentQMV + 1 + block); | ||
418 : | |||
419 : | if(Data->qpel) { | ||
420 : | Isibaar | 1.24 | Data->predMV = get_qpmv2(pMBs, pParam->mb_width, bound, x/2, y/2, block); |
421 : | edgomez | 1.2 | if (block != 0) i = d_mv_bits( Data->currentQMV->x, Data->currentQMV->y, |
422 : | syskin | 1.9 | Data->predMV, Data->iFcode, 0); |
423 : | edgomez | 1.2 | } else { |
424 : | Isibaar | 1.24 | Data->predMV = get_pmv2(pMBs, pParam->mb_width, bound, x/2, y/2, block); |
425 : | edgomez | 1.2 | if (block != 0) i = d_mv_bits( Data->currentMV->x, Data->currentMV->y, |
426 : | syskin | 1.9 | Data->predMV, Data->iFcode, 0); |
427 : | edgomez | 1.2 | } |
428 : | |||
429 : | Isibaar | 1.16 | *(Data->iMinSAD) += (Data->lambda8 * i); |
430 : | edgomez | 1.2 | |
431 : | if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) { | ||
432 : | |||
433 : | syskin | 1.4 | vbest_q = Data->currentQMV[0]; |
434 : | sbest_q = Data->iMinSAD[0]; | ||
435 : | |||
436 : | edgomez | 1.2 | |
437 : | syskin | 1.9 | Data->RefP[0] = OldData->RefP[0] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); |
438 : | Data->RefP[1] = OldData->RefP[1] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); | ||
439 : | Data->RefP[2] = OldData->RefP[2] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); | ||
440 : | Data->RefP[3] = OldData->RefP[3] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); | ||
441 : | edgomez | 1.2 | |
442 : | syskin | 1.9 | Data->Cur = OldData->Cur + 8 * ((block&1) + Data->iEdgedWidth*(block>>1)); |
443 : | edgomez | 1.2 | Data->qpel_precision = 0; |
444 : | |||
445 : | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, | ||
446 : | syskin | 1.9 | pParam->width, pParam->height, Data->iFcode - Data->qpel, 1); |
447 : | edgomez | 1.2 | |
448 : | if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_RD))) { | ||
449 : | |||
450 : | MainSearchFunc *MainSearchPtr; | ||
451 : | if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = xvid_me_SquareSearch; | ||
452 : | else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = xvid_me_AdvDiamondSearch; | ||
453 : | else MainSearchPtr = xvid_me_DiamondSearch; | ||
454 : | |||
455 : | syskin | 1.9 | MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate8); |
456 : | edgomez | 1.2 | } |
457 : | |||
458 : | syskin | 1.4 | if(!Data->qpel) { |
459 : | /* halfpel mode */ | ||
460 : | if (MotionFlags & XVID_ME_HALFPELREFINE8) | ||
461 : | syskin | 1.8 | /* perform halfpel refine of current best vector */ |
462 : | syskin | 1.9 | xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate8, 0); |
463 : | syskin | 1.4 | } else { |
464 : | /* qpel mode */ | ||
465 : | Data->currentQMV->x = 2*Data->currentMV->x; | ||
466 : | Data->currentQMV->y = 2*Data->currentMV->y; | ||
467 : | |||
468 : | if(MotionFlags & XVID_ME_FASTREFINE8) { | ||
469 : | /* fast */ | ||
470 : | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, | ||
471 : | syskin | 1.9 | pParam->width, pParam->height, Data->iFcode, 2); |
472 : | syskin | 1.4 | FullRefine_Fast(Data, CheckCandidate8, 0); |
473 : | } else if(MotionFlags & XVID_ME_QUARTERPELREFINE8) { | ||
474 : | /* full */ | ||
475 : | if (MotionFlags & XVID_ME_HALFPELREFINE8) { | ||
476 : | syskin | 1.8 | xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate8, 0); /* hpel part */ |
477 : | syskin | 1.4 | Data->currentQMV->x = 2*Data->currentMV->x; |
478 : | Data->currentQMV->y = 2*Data->currentMV->y; | ||
479 : | } | ||
480 : | edgomez | 1.2 | |
481 : | syskin | 1.4 | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3, |
482 : | syskin | 1.9 | pParam->width, pParam->height, Data->iFcode, 2); |
483 : | syskin | 1.4 | Data->qpel_precision = 1; |
484 : | edgomez | 1.2 | |
485 : | syskin | 1.8 | xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate8, 0); /* qpel part */ |
486 : | edgomez | 1.2 | } |
487 : | } | ||
488 : | |||
489 : | syskin | 1.4 | if (sbest_q <= Data->iMinSAD[0]) /* we have not found a better match */ |
490 : | Data->currentQMV[0] = vbest_q; | ||
491 : | edgomez | 1.2 | |
492 : | } | ||
493 : | |||
494 : | syskin | 1.9 | if(Data->qpel) { |
495 : | edgomez | 1.2 | pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x; |
496 : | pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y; | ||
497 : | pMB->qmvs[block] = *Data->currentQMV; | ||
498 : | } else { | ||
499 : | pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x; | ||
500 : | pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y; | ||
501 : | } | ||
502 : | |||
503 : | *(OldData->iMinSAD + 1 + block) = *Data->iMinSAD; | ||
504 : | *(OldData->currentMV + 1 + block) = *Data->currentMV; | ||
505 : | *(OldData->currentQMV + 1 + block) = *Data->currentQMV; | ||
506 : | |||
507 : | pMB->mvs[block] = *Data->currentMV; | ||
508 : | pMB->sad8[block] = 4 * *Data->iMinSAD; | ||
509 : | } | ||
510 : | |||
511 : | |||
512 : | |||
513 : | static void | ||
514 : | SearchP(const IMAGE * const pRef, | ||
515 : | const uint8_t * const pRefH, | ||
516 : | const uint8_t * const pRefV, | ||
517 : | const uint8_t * const pRefHV, | ||
518 : | const IMAGE * const pCur, | ||
519 : | const int x, | ||
520 : | const int y, | ||
521 : | const uint32_t MotionFlags, | ||
522 : | const uint32_t VopFlags, | ||
523 : | SearchData * const Data, | ||
524 : | const MBParam * const pParam, | ||
525 : | const MACROBLOCK * const pMBs, | ||
526 : | const MACROBLOCK * const prevMBs, | ||
527 : | Isibaar | 1.24 | MACROBLOCK * const pMB, |
528 : | const int bound) | ||
529 : | edgomez | 1.2 | { |
530 : | |||
531 : | int i, threshA; | ||
532 : | VECTOR pmv[7]; | ||
533 : | int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0); | ||
534 : | CheckFunc * CheckCandidate; | ||
535 : | |||
536 : | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, | ||
537 : | syskin | 1.9 | pParam->width, pParam->height, Data->iFcode - Data->qpel, 1); |
538 : | edgomez | 1.2 | |
539 : | Isibaar | 1.24 | get_pmvdata2(pMBs, pParam->mb_width, bound, x, y, pmv, Data->temp); |
540 : | edgomez | 1.2 | |
541 : | Data->chromaX = Data->chromaY = 0; /* chroma-sad cache */ | ||
542 : | syskin | 1.9 | Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16; |
543 : | Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8; | ||
544 : | Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8; | ||
545 : | |||
546 : | Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16; | ||
547 : | Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16; | ||
548 : | Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16; | ||
549 : | Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16; | ||
550 : | Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8; | ||
551 : | Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8; | ||
552 : | edgomez | 1.2 | |
553 : | Data->lambda16 = xvid_me_lambda_vec16[pMB->quant]; | ||
554 : | Data->lambda8 = xvid_me_lambda_vec8[pMB->quant]; | ||
555 : | Data->qpel_precision = 0; | ||
556 : | Data->dir = 0; | ||
557 : | |||
558 : | memset(Data->currentMV, 0, 5*sizeof(VECTOR)); | ||
559 : | |||
560 : | Isibaar | 1.24 | if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, bound, x, y, 0); |
561 : | edgomez | 1.2 | else Data->predMV = pmv[0]; |
562 : | |||
563 : | syskin | 1.9 | i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0); |
564 : | Isibaar | 1.16 | Data->iMinSAD[0] = pMB->sad16 + (Data->lambda16 * i); |
565 : | Data->iMinSAD[1] = pMB->sad8[0] + (Data->lambda8 * i); | ||
566 : | edgomez | 1.2 | Data->iMinSAD[2] = pMB->sad8[1]; |
567 : | Data->iMinSAD[3] = pMB->sad8[2]; | ||
568 : | Data->iMinSAD[4] = pMB->sad8[3]; | ||
569 : | |||
570 : | if ((!(VopFlags & XVID_VOP_MODEDECISION_RD)) && (x | y)) { | ||
571 : | threshA = Data->temp[0]; /* that's where we keep this SAD atm */ | ||
572 : | if (threshA < 512) threshA = 512; | ||
573 : | else if (threshA > 1024) threshA = 1024; | ||
574 : | } else | ||
575 : | threshA = 512; | ||
576 : | |||
577 : | PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height, | ||
578 : | syskin | 1.9 | prevMBs + x + y * pParam->mb_width); |
579 : | edgomez | 1.2 | |
580 : | syskin | 1.9 | if (inter4v) CheckCandidate = CheckCandidate16; |
581 : | else CheckCandidate = CheckCandidate16no4v; /* for extra speed */ | ||
582 : | edgomez | 1.2 | |
583 : | /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/ | ||
584 : | |||
585 : | for (i = 1; i < 7; i++) | ||
586 : | if (!vector_repeats(pmv, i)) { | ||
587 : | CheckCandidate(pmv[i].x, pmv[i].y, Data, i); | ||
588 : | if (Data->iMinSAD[0] <= threshA) { i++; break; } | ||
589 : | } | ||
590 : | |||
591 : | if ((Data->iMinSAD[0] <= threshA) || | ||
592 : | (MVequal(Data->currentMV[0], (prevMBs+x+y*pParam->mb_width)->mvs[0]) && | ||
593 : | (Data->iMinSAD[0] < (prevMBs+x+y*pParam->mb_width)->sad16))) | ||
594 : | inter4v = 0; | ||
595 : | else { | ||
596 : | |||
597 : | MainSearchFunc * MainSearchPtr; | ||
598 : | int mask = make_mask(pmv, i, Data->dir); /* all vectors pmv[0..i-1] have been checked */ | ||
599 : | |||
600 : | if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = xvid_me_SquareSearch; | ||
601 : | else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = xvid_me_AdvDiamondSearch; | ||
602 : | else MainSearchPtr = xvid_me_DiamondSearch; | ||
603 : | |||
604 : | MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate); | ||
605 : | |||
606 : | /* extended search, diamond starting in 0,0 and in prediction. | ||
607 : | note that this search is/might be done in halfpel positions, | ||
608 : | which makes it more different than the diamond above */ | ||
609 : | |||
610 : | if (MotionFlags & XVID_ME_EXTSEARCH16) { | ||
611 : | int32_t bSAD; | ||
612 : | VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0]; | ||
613 : | if (Data->qpel) { | ||
614 : | startMV.x /= 2; | ||
615 : | startMV.y /= 2; | ||
616 : | } | ||
617 : | if (!(MVequal(startMV, backupMV))) { | ||
618 : | bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR; | ||
619 : | |||
620 : | CheckCandidate(startMV.x, startMV.y, Data, 255); | ||
621 : | xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate); | ||
622 : | if (bSAD < Data->iMinSAD[0]) { | ||
623 : | Data->currentMV[0] = backupMV; | ||
624 : | syskin | 1.9 | Data->iMinSAD[0] = bSAD; |
625 : | } | ||
626 : | edgomez | 1.2 | } |
627 : | |||
628 : | backupMV = Data->currentMV[0]; | ||
629 : | startMV.x = startMV.y = 1; | ||
630 : | if (!(MVequal(startMV, backupMV))) { | ||
631 : | bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR; | ||
632 : | |||
633 : | CheckCandidate(startMV.x, startMV.y, Data, 255); | ||
634 : | xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate); | ||
635 : | if (bSAD < Data->iMinSAD[0]) { | ||
636 : | Data->currentMV[0] = backupMV; | ||
637 : | Data->iMinSAD[0] = bSAD; | ||
638 : | } | ||
639 : | } | ||
640 : | } | ||
641 : | } | ||
642 : | |||
643 : | |||
644 : | syskin | 1.4 | if(!Data->qpel) { |
645 : | /* halfpel mode */ | ||
646 : | if (MotionFlags & XVID_ME_HALFPELREFINE16) | ||
647 : | syskin | 1.8 | xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate, 0); |
648 : | syskin | 1.4 | } else { |
649 : | /* qpel mode */ | ||
650 : | |||
651 : | for(i = 0; i < 5; i++) { | ||
652 : | Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* initialize qpel vectors */ | ||
653 : | Data->currentQMV[i].y = 2 * Data->currentMV[i].y; | ||
654 : | } | ||
655 : | if(MotionFlags & XVID_ME_FASTREFINE16 && MotionFlags & XVID_ME_QUARTERPELREFINE16) { | ||
656 : | /* fast */ | ||
657 : | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, | ||
658 : | syskin | 1.9 | pParam->width, pParam->height, Data->iFcode, 2); |
659 : | syskin | 1.4 | FullRefine_Fast(Data, CheckCandidate, 0); |
660 : | } else { | ||
661 : | if(MotionFlags & (XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE16_RD)) { | ||
662 : | /* full */ | ||
663 : | if (MotionFlags & XVID_ME_HALFPELREFINE16) { | ||
664 : | syskin | 1.8 | xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate, 0); /* hpel part */ |
665 : | syskin | 1.4 | for(i = 0; i < 5; i++) { |
666 : | Data->currentQMV[i].x = 2 * Data->currentMV[i].x; | ||
667 : | Data->currentQMV[i].y = 2 * Data->currentMV[i].y; | ||
668 : | } | ||
669 : | } | ||
670 : | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, | ||
671 : | syskin | 1.9 | pParam->width, pParam->height, Data->iFcode, 2); |
672 : | syskin | 1.4 | Data->qpel_precision = 1; |
673 : | if(MotionFlags & XVID_ME_QUARTERPELREFINE16) | ||
674 : | syskin | 1.8 | xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate, 0); /* qpel part */ |
675 : | syskin | 1.4 | } |
676 : | edgomez | 1.2 | } |
677 : | } | ||
678 : | |||
679 : | syskin | 1.9 | if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30 * ((MotionFlags & XVID_ME_FASTREFINE16) ? 8 : 1)) |
680 : | edgomez | 1.2 | inter4v = 0; |
681 : | |||
682 : | if (inter4v) { | ||
683 : | SearchData Data8; | ||
684 : | memcpy(&Data8, Data, sizeof(SearchData)); /* quick copy of common data */ | ||
685 : | |||
686 : | Isibaar | 1.24 | Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8, bound); |
687 : | Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8, bound); | ||
688 : | Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8, bound); | ||
689 : | Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8, bound); | ||
690 : | edgomez | 1.2 | |
691 : | if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) { | ||
692 : | syskin | 1.4 | /* chroma is only used for comparison to INTER. if the comparison will be done in RD domain, it will not be used */ |
693 : | edgomez | 1.2 | int sumx = 0, sumy = 0; |
694 : | |||
695 : | if (Data->qpel) | ||
696 : | for (i = 1; i < 5; i++) { | ||
697 : | sumx += Data->currentQMV[i].x/2; | ||
698 : | sumy += Data->currentQMV[i].y/2; | ||
699 : | } | ||
700 : | else | ||
701 : | for (i = 1; i < 5; i++) { | ||
702 : | sumx += Data->currentMV[i].x; | ||
703 : | sumy += Data->currentMV[i].y; | ||
704 : | } | ||
705 : | |||
706 : | Data->iMinSAD[1] += xvid_me_ChromaSAD((sumx >> 3) + roundtab_76[sumx & 0xf], | ||
707 : | (sumy >> 3) + roundtab_76[sumy & 0xf], Data); | ||
708 : | } | ||
709 : | } else Data->iMinSAD[1] = 4096*256; | ||
710 : | } | ||
711 : | |||
712 : | syskin | 1.18 | static int |
713 : | InitialSkipDecisionP(int sad00, | ||
714 : | const MBParam * pParam, | ||
715 : | const FRAMEINFO * current, | ||
716 : | MACROBLOCK * pMB, | ||
717 : | const MACROBLOCK * prevMB, | ||
718 : | int x, int y, | ||
719 : | const SearchData * Data, | ||
720 : | const IMAGE * const pGMC, | ||
721 : | const IMAGE * const pCurrent, | ||
722 : | const IMAGE * const pRef, | ||
723 : | Isibaar | 1.24 | const uint32_t MotionFlags, |
724 : | const int bound) | ||
725 : | syskin | 1.18 | { |
726 : | const unsigned int iEdgedWidth = pParam->edged_width; | ||
727 : | |||
728 : | int skip_thresh = INITIAL_SKIP_THRESH * \ | ||
729 : | (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1); | ||
730 : | int stat_thresh = 0; | ||
731 : | |||
732 : | /* initial skip decision */ | ||
733 : | if (current->coding_type != S_VOP) { /* no fast SKIP for S(GMC)-VOPs */ | ||
734 : | if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh) | ||
735 : | if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant)) { | ||
736 : | ZeroMacroblockP(pMB, sad00); | ||
737 : | pMB->mode = MODE_NOT_CODED; | ||
738 : | return 1; | ||
739 : | } | ||
740 : | } | ||
741 : | |||
742 : | if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) { | ||
743 : | VECTOR *cmpMV; | ||
744 : | VECTOR staticMV = { 0, 0 }; | ||
745 : | const MACROBLOCK * pMBs = current->mbs; | ||
746 : | |||
747 : | if (current->coding_type == S_VOP) | ||
748 : | cmpMV = &pMB->amv; | ||
749 : | else | ||
750 : | cmpMV = &staticMV; | ||
751 : | |||
752 : | Isibaar | 1.24 | if(x > 0 && y > 0 && x < (int) pParam->mb_width) { |
753 : | syskin | 1.18 | if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], *cmpMV) && |
754 : | MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) && | ||
755 : | MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) && | ||
756 : | MVequal(prevMB->mvs[0], *cmpMV)) { | ||
757 : | stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16, | ||
758 : | MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16, | ||
759 : | MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16, | ||
760 : | prevMB->sad16))); | ||
761 : | } else { | ||
762 : | stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16, | ||
763 : | MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16, | ||
764 : | MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16, | ||
765 : | prevMB->sad16))); | ||
766 : | } | ||
767 : | } | ||
768 : | } | ||
769 : | |||
770 : | /* favorize (0,0) or global vector for cartoons */ | ||
771 : | if (current->vop_flags & XVID_VOP_CARTOON) { | ||
772 : | if (current->coding_type == S_VOP) { | ||
773 : | int32_t iSAD = sad16(pCurrent->y + (x + y * iEdgedWidth) * 16, | ||
774 : | pGMC->y + 16*y*iEdgedWidth + 16*x, iEdgedWidth, 65536); | ||
775 : | |||
776 : | if (Data->chroma) { | ||
777 : | iSAD += sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, pGMC->u + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2); | ||
778 : | iSAD += sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, pGMC->v + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2); | ||
779 : | } | ||
780 : | |||
781 : | if (iSAD <= stat_thresh) { /* mode decision GMC */ | ||
782 : | pMB->mode = MODE_INTER; | ||
783 : | pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = iSAD; | ||
784 : | pMB->mcsel = 1; | ||
785 : | if (Data->qpel) { | ||
786 : | pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv; | ||
787 : | pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2; | ||
788 : | pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2; | ||
789 : | } else | ||
790 : | pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv; | ||
791 : | |||
792 : | return 1; | ||
793 : | } | ||
794 : | } | ||
795 : | else if (sad00 < stat_thresh) { | ||
796 : | VECTOR predMV; | ||
797 : | if (Data->qpel) | ||
798 : | Isibaar | 1.24 | predMV = get_qpmv2(current->mbs, pParam->mb_width, bound, x, y, 0); |
799 : | syskin | 1.18 | else |
800 : | Isibaar | 1.24 | predMV = get_pmv2(current->mbs, pParam->mb_width, bound, x, y, 0); |
801 : | syskin | 1.18 | |
802 : | ZeroMacroblockP(pMB, sad00); | ||
803 : | pMB->cbp = 0x3f; | ||
804 : | pMB->pmvs[0].x = - predMV.x; | ||
805 : | pMB->pmvs[0].y = - predMV.y; | ||
806 : | return 1; | ||
807 : | } | ||
808 : | } | ||
809 : | |||
810 : | return 0; | ||
811 : | } | ||
812 : | |||
813 : | edgomez | 1.2 | static __inline uint32_t |
814 : | MakeGoodMotionFlags(const uint32_t MotionFlags, const uint32_t VopFlags, const uint32_t VolFlags) | ||
815 : | { | ||
816 : | uint32_t Flags = MotionFlags; | ||
817 : | |||
818 : | if (!(VopFlags & XVID_VOP_MODEDECISION_RD)) | ||
819 : | Flags &= ~(XVID_ME_QUARTERPELREFINE16_RD+XVID_ME_QUARTERPELREFINE8_RD+XVID_ME_HALFPELREFINE16_RD+XVID_ME_HALFPELREFINE8_RD+XVID_ME_EXTSEARCH_RD); | ||
820 : | |||
821 : | if (Flags & XVID_ME_EXTSEARCH_RD) | ||
822 : | Flags |= XVID_ME_HALFPELREFINE16_RD; | ||
823 : | |||
824 : | if (Flags & XVID_ME_EXTSEARCH_RD && MotionFlags & XVID_ME_EXTSEARCH8) | ||
825 : | Flags |= XVID_ME_HALFPELREFINE8_RD; | ||
826 : | |||
827 : | if (Flags & XVID_ME_HALFPELREFINE16_RD) | ||
828 : | Flags |= XVID_ME_QUARTERPELREFINE16_RD; | ||
829 : | |||
830 : | if (Flags & XVID_ME_HALFPELREFINE8_RD) { | ||
831 : | Flags |= XVID_ME_QUARTERPELREFINE8_RD; | ||
832 : | Flags &= ~XVID_ME_HALFPELREFINE8; | ||
833 : | } | ||
834 : | |||
835 : | if (Flags & XVID_ME_QUARTERPELREFINE8_RD) | ||
836 : | Flags &= ~XVID_ME_QUARTERPELREFINE8; | ||
837 : | |||
838 : | edgomez | 1.3 | if (Flags & XVID_ME_QUARTERPELREFINE16_RD) |
839 : | Flags &= ~XVID_ME_QUARTERPELREFINE16; | ||
840 : | |||
841 : | edgomez | 1.2 | if (!(VolFlags & XVID_VOL_QUARTERPEL)) |
842 : | Flags &= ~(XVID_ME_QUARTERPELREFINE16+XVID_ME_QUARTERPELREFINE8+XVID_ME_QUARTERPELREFINE16_RD+XVID_ME_QUARTERPELREFINE8_RD); | ||
843 : | |||
844 : | if (!(VopFlags & XVID_VOP_HALFPEL)) | ||
845 : | Flags &= ~(XVID_ME_EXTSEARCH16+XVID_ME_HALFPELREFINE16+XVID_ME_HALFPELREFINE8+XVID_ME_HALFPELREFINE16_RD+XVID_ME_HALFPELREFINE8_RD); | ||
846 : | |||
847 : | syskin | 1.9 | if (VopFlags & XVID_VOP_GREYSCALE) |
848 : | edgomez | 1.2 | Flags &= ~(XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP); |
849 : | |||
850 : | syskin | 1.4 | if (Flags & XVID_ME_FASTREFINE8) |
851 : | Flags &= ~XVID_ME_HALFPELREFINE8_RD; | ||
852 : | |||
853 : | if (Flags & XVID_ME_FASTREFINE16) | ||
854 : | Flags &= ~XVID_ME_HALFPELREFINE16_RD; | ||
855 : | |||
856 : | edgomez | 1.2 | return Flags; |
857 : | } | ||
858 : | |||
859 : | syskin | 1.10 | static __inline void |
860 : | motionStatsPVOP(int * const MVmax, int * const mvCount, int * const mvSum, | ||
861 : | const MACROBLOCK * const pMB, const int qpel) | ||
862 : | { | ||
863 : | const VECTOR * const mv = qpel ? pMB->qmvs : pMB->mvs; | ||
864 : | int i; | ||
865 : | int max = *MVmax; | ||
866 : | |||
867 : | switch (pMB->mode) { | ||
868 : | case MODE_INTER4V: | ||
869 : | *mvCount += 3; | ||
870 : | for(i = 3; i; i--) { | ||
871 : | if (mv[i].x > max) max = mv[i].x; | ||
872 : | else if (-mv[i].x - 1 > max) max = -mv[i].x - 1; | ||
873 : | *mvSum += mv[i].x * mv[i].x; | ||
874 : | if (mv[i].y > max) max = mv[i].y; | ||
875 : | else if (-mv[i].y - 1 > max) max = -mv[i].y - 1; | ||
876 : | *mvSum += mv[i].y * mv[i].y; | ||
877 : | } | ||
878 : | case MODE_INTER: | ||
879 : | syskin | 1.12 | (*mvCount)++; |
880 : | syskin | 1.10 | *mvSum += mv[0].x * mv[0].x; |
881 : | *mvSum += mv[0].y * mv[0].y; | ||
882 : | syskin | 1.12 | if (mv[0].x > max) max = mv[0].x; |
883 : | else if (-mv[0].x - 1 > max) max = -mv[0].x - 1; | ||
884 : | if (mv[0].y > max) max = mv[0].y; | ||
885 : | else if (-mv[0].y - 1 > max) max = -mv[0].y - 1; | ||
886 : | *MVmax = max; | ||
887 : | syskin | 1.10 | default: |
888 : | break; | ||
889 : | } | ||
890 : | } | ||
891 : | |||
892 : | syskin | 1.18 | void |
893 : | edgomez | 1.2 | MotionEstimation(MBParam * const pParam, |
894 : | FRAMEINFO * const current, | ||
895 : | FRAMEINFO * const reference, | ||
896 : | const IMAGE * const pRefH, | ||
897 : | const IMAGE * const pRefV, | ||
898 : | const IMAGE * const pRefHV, | ||
899 : | syskin | 1.18 | const IMAGE * const pGMC, |
900 : | Isibaar | 1.24 | const uint32_t iLimit, |
901 : | const int num_slices) | ||
902 : | edgomez | 1.2 | { |
903 : | MACROBLOCK *const pMBs = current->mbs; | ||
904 : | const IMAGE *const pCurrent = ¤t->image; | ||
905 : | const IMAGE *const pRef = &reference->image; | ||
906 : | |||
907 : | syskin | 1.9 | const uint32_t mb_width = pParam->mb_width; |
908 : | const uint32_t mb_height = pParam->mb_height; | ||
909 : | edgomez | 1.2 | const uint32_t iEdgedWidth = pParam->edged_width; |
910 : | const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags); | ||
911 : | Isibaar | 1.24 | int bound = 0; |
912 : | syskin | 1.10 | int MVmax = 0, mvSum = 0, mvCount = 0; |
913 : | edgomez | 1.2 | |
914 : | uint32_t x, y; | ||
915 : | syskin | 1.18 | int sad00; |
916 : | int block = 0; | ||
917 : | edgomez | 1.2 | |
918 : | /* some pre-initialized thingies for SearchP */ | ||
919 : | DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE); | ||
920 : | SearchData Data; | ||
921 : | memset(&Data, 0, sizeof(SearchData)); | ||
922 : | Data.iEdgedWidth = iEdgedWidth; | ||
923 : | Data.iFcode = current->fcode; | ||
924 : | Data.rounding = pParam->m_rounding_type; | ||
925 : | Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0); | ||
926 : | Data.chroma = MotionFlags & XVID_ME_CHROMA_PVOP; | ||
927 : | Data.dctSpace = dct_space; | ||
928 : | Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT); | ||
929 : | Data.mpeg_quant_matrices = pParam->mpeg_quant_matrices; | ||
930 : | |||
931 : | Data.RefQ = pRefV->u; /* a good place, also used in MC (for similar purpose) */ | ||
932 : | if (sadInit) (*sadInit) (); | ||
933 : | |||
934 : | for (y = 0; y < mb_height; y++) { | ||
935 : | Isibaar | 1.24 | |
936 : | bound = mb_width * ((((y*num_slices) / mb_height) * mb_height + (num_slices-1)) / num_slices); | ||
937 : | |||
938 : | edgomez | 1.2 | for (x = 0; x < mb_width; x++) { |
939 : | syskin | 1.18 | MACROBLOCK *pMB = &pMBs[block]; |
940 : | MACROBLOCK *prevMB = &reference->mbs[block]; | ||
941 : | int skip; | ||
942 : | block++; | ||
943 : | edgomez | 1.2 | |
944 : | syskin | 1.9 | pMB->sad16 = |
945 : | edgomez | 1.2 | sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16, |
946 : | pRef->y + (x + y * iEdgedWidth) * 16, | ||
947 : | syskin | 1.9 | pParam->edged_width, pMB->sad8); |
948 : | syskin | 1.18 | |
949 : | syskin | 1.5 | sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3])); |
950 : | edgomez | 1.2 | |
951 : | if (Data.chroma) { | ||
952 : | Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, | ||
953 : | pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2) | ||
954 : | + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, | ||
955 : | pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2); | ||
956 : | pMB->sad16 += Data.chromaSAD; | ||
957 : | syskin | 1.5 | sad00 += Data.chromaSAD; |
958 : | edgomez | 1.2 | } |
959 : | |||
960 : | syskin | 1.18 | skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC, |
961 : | Isibaar | 1.24 | pCurrent, pRef, MotionFlags, bound); |
962 : | syskin | 1.18 | if (skip) continue; |
963 : | edgomez | 1.2 | |
964 : | SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x, | ||
965 : | y, MotionFlags, current->vop_flags, | ||
966 : | Isibaar | 1.24 | &Data, pParam, pMBs, reference->mbs, pMB, bound); |
967 : | edgomez | 1.2 | |
968 : | if (current->vop_flags & XVID_VOP_MODEDECISION_RD) | ||
969 : | xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam, | ||
970 : | MotionFlags, current->vop_flags, current->vol_flags, | ||
971 : | Isibaar | 1.24 | pCurrent, pRef, pGMC, current->coding_type, bound); |
972 : | edgomez | 1.2 | |
973 : | else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD) | ||
974 : | xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam, | ||
975 : | MotionFlags, current->vop_flags, current->vol_flags, | ||
976 : | Isibaar | 1.24 | pCurrent, pRef, pGMC, current->coding_type, bound); |
977 : | edgomez | 1.2 | else |
978 : | ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam, | ||
979 : | MotionFlags, current->vop_flags, current->vol_flags, | ||
980 : | syskin | 1.5 | pCurrent, pRef, pGMC, current->coding_type, sad00); |
981 : | edgomez | 1.2 | |
982 : | |||
983 : | syskin | 1.10 | motionStatsPVOP(&MVmax, &mvCount, &mvSum, pMB, Data.qpel); |
984 : | edgomez | 1.2 | } |
985 : | } | ||
986 : | |||
987 : | syskin | 1.10 | current->fcode = getMinFcode(MVmax); |
988 : | current->sStat.iMvSum = mvSum; | ||
989 : | current->sStat.iMvCount = mvCount; | ||
990 : | edgomez | 1.11 | } |
991 : | syskin | 1.19 | |
992 : | void | ||
993 : | Isibaar | 1.24 | MotionEstimateSMP(SMPData * h) |
994 : | syskin | 1.19 | { |
995 : | Isibaar | 1.24 | Encoder *pEnc = (Encoder *) h->pEnc; |
996 : | |||
997 : | const MBParam * const pParam = &pEnc->mbParam; | ||
998 : | const FRAMEINFO * const current = pEnc->current; | ||
999 : | const FRAMEINFO * const reference = pEnc->reference; | ||
1000 : | const IMAGE * const pRefH = &pEnc->vInterH; | ||
1001 : | const IMAGE * const pRefV = &pEnc->vInterV; | ||
1002 : | const IMAGE * const pRefHV = &pEnc->vInterHV; | ||
1003 : | const IMAGE * const pGMC = &pEnc->vGMC; | ||
1004 : | syskin | 1.19 | uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, |
1005 : | current->vop_flags, | ||
1006 : | current->vol_flags); | ||
1007 : | |||
1008 : | MACROBLOCK *const pMBs = current->mbs; | ||
1009 : | const IMAGE *const pCurrent = ¤t->image; | ||
1010 : | const IMAGE *const pRef = &reference->image; | ||
1011 : | |||
1012 : | Isibaar | 1.24 | const int mb_width = pParam->mb_width; |
1013 : | const int mb_height = pParam->mb_height; | ||
1014 : | syskin | 1.19 | const uint32_t iEdgedWidth = pParam->edged_width; |
1015 : | Isibaar | 1.24 | int bound = 0; |
1016 : | int num_slices = pEnc->num_slices; | ||
1017 : | syskin | 1.19 | int y_step = h->y_step; |
1018 : | Isibaar | 1.24 | int y_row = h->y_row; |
1019 : | syskin | 1.19 | int start_y = h->start_y; |
1020 : | Isibaar | 1.24 | int stop_y = h->stop_y; |
1021 : | Isibaar | 1.23 | int MVmax = 0, mvSum = 0, mvCount = 0; |
1022 : | syskin | 1.19 | |
1023 : | Isibaar | 1.24 | int x, y; |
1024 : | syskin | 1.19 | int sad00; |
1025 : | Isibaar | 1.24 | int block = (start_y+y_row)*mb_width; |
1026 : | syskin | 1.19 | int * complete_count_self = h->complete_count_self; |
1027 : | syskin | 1.21 | const volatile int * complete_count_above = h->complete_count_above; |
1028 : | syskin | 1.19 | int max_mbs; |
1029 : | int current_mb = 0; | ||
1030 : | |||
1031 : | /* some pre-initialized thingies for SearchP */ | ||
1032 : | DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE); | ||
1033 : | SearchData Data; | ||
1034 : | memset(&Data, 0, sizeof(SearchData)); | ||
1035 : | Data.iEdgedWidth = iEdgedWidth; | ||
1036 : | Data.iFcode = current->fcode; | ||
1037 : | Data.rounding = pParam->m_rounding_type; | ||
1038 : | Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0); | ||
1039 : | Data.chroma = MotionFlags & XVID_ME_CHROMA_PVOP; | ||
1040 : | Data.dctSpace = dct_space; | ||
1041 : | Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT); | ||
1042 : | Data.mpeg_quant_matrices = pParam->mpeg_quant_matrices; | ||
1043 : | |||
1044 : | /* todo: sort out temp memory space */ | ||
1045 : | Data.RefQ = h->RefQ; | ||
1046 : | if (sadInit) (*sadInit) (); | ||
1047 : | |||
1048 : | max_mbs = 0; | ||
1049 : | |||
1050 : | Isibaar | 1.24 | for (y = (start_y + y_row); y < stop_y; y += y_step) { |
1051 : | bound = mb_width * ((((y*num_slices) / mb_height) * mb_height + (num_slices-1)) / num_slices); | ||
1052 : | |||
1053 : | if (y == start_y) max_mbs = mb_width; /* we can process all blocks of the first row */ | ||
1054 : | syskin | 1.19 | |
1055 : | for (x = 0; x < mb_width; x++) { | ||
1056 : | |||
1057 : | MACROBLOCK *pMB, *prevMB; | ||
1058 : | int skip; | ||
1059 : | |||
1060 : | if (current_mb >= max_mbs) { | ||
1061 : | /* we ME-ed all macroblocks we safely could. grab next portion */ | ||
1062 : | int above_count = *complete_count_above; /* sync point */ | ||
1063 : | if (above_count == mb_width) { | ||
1064 : | /* full line above is ready */ | ||
1065 : | above_count = mb_width+1; | ||
1066 : | Isibaar | 1.24 | if (y < (stop_y-y_step)) { |
1067 : | syskin | 1.19 | /* this is not last line, grab a portion of MBs from the next line too */ |
1068 : | above_count += MAX(0, complete_count_above[1] - 1); | ||
1069 : | } | ||
1070 : | } | ||
1071 : | |||
1072 : | max_mbs = current_mb + above_count - x - 1; | ||
1073 : | |||
1074 : | if (current_mb >= max_mbs) { | ||
1075 : | /* current workload is zero */ | ||
1076 : | x--; | ||
1077 : | sched_yield(); | ||
1078 : | continue; | ||
1079 : | } | ||
1080 : | } | ||
1081 : | |||
1082 : | syskin | 1.21 | pMB = &pMBs[block]; |
1083 : | prevMB = &reference->mbs[block]; | ||
1084 : | |||
1085 : | pMB->sad16 = | ||
1086 : | sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16, | ||
1087 : | pRef->y + (x + y * iEdgedWidth) * 16, | ||
1088 : | pParam->edged_width, pMB->sad8); | ||
1089 : | |||
1090 : | sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3])); | ||
1091 : | |||
1092 : | if (Data.chroma) { | ||
1093 : | Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, | ||
1094 : | pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2) | ||
1095 : | + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, | ||
1096 : | pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2); | ||
1097 : | pMB->sad16 += Data.chromaSAD; | ||
1098 : | sad00 += Data.chromaSAD; | ||
1099 : | } | ||
1100 : | |||
1101 : | syskin | 1.19 | skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC, |
1102 : | Isibaar | 1.24 | pCurrent, pRef, MotionFlags, bound); |
1103 : | syskin | 1.19 | |
1104 : | if (skip) { | ||
1105 : | current_mb++; | ||
1106 : | block++; | ||
1107 : | *complete_count_self = x+1; | ||
1108 : | continue; | ||
1109 : | } | ||
1110 : | |||
1111 : | SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x, | ||
1112 : | y, MotionFlags, current->vop_flags, | ||
1113 : | Isibaar | 1.24 | &Data, pParam, pMBs, reference->mbs, pMB, bound); |
1114 : | syskin | 1.19 | |
1115 : | if (current->vop_flags & XVID_VOP_MODEDECISION_RD) | ||
1116 : | xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam, | ||
1117 : | MotionFlags, current->vop_flags, current->vol_flags, | ||
1118 : | Isibaar | 1.24 | pCurrent, pRef, pGMC, current->coding_type, bound); |
1119 : | syskin | 1.19 | |
1120 : | else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD) | ||
1121 : | xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam, | ||
1122 : | MotionFlags, current->vop_flags, current->vol_flags, | ||
1123 : | Isibaar | 1.24 | pCurrent, pRef, pGMC, current->coding_type, bound); |
1124 : | syskin | 1.19 | else |
1125 : | ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam, | ||
1126 : | MotionFlags, current->vop_flags, current->vol_flags, | ||
1127 : | pCurrent, pRef, pGMC, current->coding_type, sad00); | ||
1128 : | |||
1129 : | *complete_count_self = x+1; | ||
1130 : | |||
1131 : | current_mb++; | ||
1132 : | block++; | ||
1133 : | |||
1134 : | motionStatsPVOP(&MVmax, &mvCount, &mvSum, pMB, Data.qpel); | ||
1135 : | |||
1136 : | } | ||
1137 : | Isibaar | 1.24 | |
1138 : | syskin | 1.19 | block += (y_step-1)*pParam->mb_width; |
1139 : | Isibaar | 1.24 | |
1140 : | syskin | 1.19 | complete_count_self++; |
1141 : | complete_count_above++; | ||
1142 : | } | ||
1143 : | |||
1144 : | syskin | 1.20 | h->minfcode = getMinFcode(MVmax); |
1145 : | |||
1146 : | syskin | 1.19 | h->MVmax = MVmax; |
1147 : | h->mvSum = mvSum; | ||
1148 : | h->mvCount = mvCount; | ||
1149 : | } | ||
1150 : | |||
1151 : |
No admin address has been configured | ViewVC Help |
Powered by ViewVC 1.0.4 |