annotate motion_est.c @ 890:653d9419ea01 libavcodec

dont put flies in the stdout soup patch by (Agent Smith <asmith at wgz dot com>)
author michaelni
date Tue, 26 Nov 2002 00:54:27 +0000
parents 2cef5c4c0ca6
children 22ee74da2cd3
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1 /*
986e461dc072 Initial revision
glantau
parents:
diff changeset
2 * Motion estimation
429
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
3 * Copyright (c) 2000,2001 Fabrice Bellard.
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
4 * Copyright (c) 2002 Michael Niedermayer
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
5 *
986e461dc072 Initial revision
glantau
parents:
diff changeset
6 *
429
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
7 * This library is free software; you can redistribute it and/or
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
8 * modify it under the terms of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
9 * License as published by the Free Software Foundation; either
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
10 * version 2 of the License, or (at your option) any later version.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
11 *
429
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
12 * This library is distributed in the hope that it will be useful,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
429
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
15 * Lesser General Public License for more details.
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
16 *
429
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
17 * You should have received a copy of the GNU Lesser General Public
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
18 * License along with this library; if not, write to the Free Software
718a22dc121f license/copyright change
glantau
parents: 376
diff changeset
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
20 *
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
21 * new Motion Estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at>
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
22 */
986e461dc072 Initial revision
glantau
parents:
diff changeset
23 #include <stdlib.h>
986e461dc072 Initial revision
glantau
parents:
diff changeset
24 #include <stdio.h>
986e461dc072 Initial revision
glantau
parents:
diff changeset
25 #include "avcodec.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
26 #include "dsputil.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
27 #include "mpegvideo.h"
986e461dc072 Initial revision
glantau
parents:
diff changeset
28
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
29 #define SQ(a) ((a)*(a))
284
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
30 #define INTER_BIAS 257
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
31
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
32 #define P_LAST P[0]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
33 #define P_LEFT P[1]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
34 #define P_TOP P[2]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
35 #define P_TOPRIGHT P[3]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
36 #define P_MEDIAN P[4]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
37 #define P_LAST_LEFT P[5]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
38 #define P_LAST_RIGHT P[6]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
39 #define P_LAST_TOP P[7]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
40 #define P_LAST_BOTTOM P[8]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
41 #define P_MV1 P[9]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
42
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
43
284
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
44 static int pix_dev(UINT8 * pix, int line_size, int mean)
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
45 {
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
46 int s, i, j;
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
47
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
48 s = 0;
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
49 for (i = 0; i < 16; i++) {
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
50 for (j = 0; j < 16; j += 8) {
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
51 s += ABS(pix[0]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
52 s += ABS(pix[1]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
53 s += ABS(pix[2]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
54 s += ABS(pix[3]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
55 s += ABS(pix[4]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
56 s += ABS(pix[5]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
57 s += ABS(pix[6]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
58 s += ABS(pix[7]-mean);
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
59 pix += 8;
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
60 }
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
61 pix += line_size - 16;
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
62 }
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
63 return s;
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
64 }
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
65
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
66 static inline void no_motion_search(MpegEncContext * s,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
67 int *mx_ptr, int *my_ptr)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
68 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
69 *mx_ptr = 16 * s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
70 *my_ptr = 16 * s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
71 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
72
986e461dc072 Initial revision
glantau
parents:
diff changeset
73 static int full_motion_search(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
74 int *mx_ptr, int *my_ptr, int range,
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
75 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
76 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
77 int x1, y1, x2, y2, xx, yy, x, y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
78 int mx, my, dmin, d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
79 UINT8 *pix;
986e461dc072 Initial revision
glantau
parents:
diff changeset
80
986e461dc072 Initial revision
glantau
parents:
diff changeset
81 xx = 16 * s->mb_x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
82 yy = 16 * s->mb_y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
83 x1 = xx - range + 1; /* we loose one pixel to avoid boundary pb with half pixel pred */
986e461dc072 Initial revision
glantau
parents:
diff changeset
84 if (x1 < xmin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
85 x1 = xmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
86 x2 = xx + range - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
87 if (x2 > xmax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
88 x2 = xmax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
89 y1 = yy - range + 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
90 if (y1 < ymin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
91 y1 = ymin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
92 y2 = yy + range - 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
93 if (y2 > ymax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
94 y2 = ymax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
95 pix = s->new_picture[0] + (yy * s->linesize) + xx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
96 dmin = 0x7fffffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
97 mx = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
98 my = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
99 for (y = y1; y <= y2; y++) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
100 for (x = x1; x <= x2; x++) {
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
101 d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x,
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
102 s->linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
103 if (d < dmin ||
986e461dc072 Initial revision
glantau
parents:
diff changeset
104 (d == dmin &&
986e461dc072 Initial revision
glantau
parents:
diff changeset
105 (abs(x - xx) + abs(y - yy)) <
986e461dc072 Initial revision
glantau
parents:
diff changeset
106 (abs(mx - xx) + abs(my - yy)))) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
107 dmin = d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
108 mx = x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
109 my = y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
110 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
111 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
112 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
113
986e461dc072 Initial revision
glantau
parents:
diff changeset
114 *mx_ptr = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
115 *my_ptr = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
116
986e461dc072 Initial revision
glantau
parents:
diff changeset
117 #if 0
986e461dc072 Initial revision
glantau
parents:
diff changeset
118 if (*mx_ptr < -(2 * range) || *mx_ptr >= (2 * range) ||
986e461dc072 Initial revision
glantau
parents:
diff changeset
119 *my_ptr < -(2 * range) || *my_ptr >= (2 * range)) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
120 fprintf(stderr, "error %d %d\n", *mx_ptr, *my_ptr);
986e461dc072 Initial revision
glantau
parents:
diff changeset
121 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
122 #endif
986e461dc072 Initial revision
glantau
parents:
diff changeset
123 return dmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
124 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
125
986e461dc072 Initial revision
glantau
parents:
diff changeset
126
986e461dc072 Initial revision
glantau
parents:
diff changeset
127 static int log_motion_search(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
128 int *mx_ptr, int *my_ptr, int range,
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
129 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
130 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
131 int x1, y1, x2, y2, xx, yy, x, y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
132 int mx, my, dmin, d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
133 UINT8 *pix;
986e461dc072 Initial revision
glantau
parents:
diff changeset
134
986e461dc072 Initial revision
glantau
parents:
diff changeset
135 xx = s->mb_x << 4;
986e461dc072 Initial revision
glantau
parents:
diff changeset
136 yy = s->mb_y << 4;
986e461dc072 Initial revision
glantau
parents:
diff changeset
137
986e461dc072 Initial revision
glantau
parents:
diff changeset
138 /* Left limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
139 x1 = xx - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
140 if (x1 < xmin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
141 x1 = xmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
142
986e461dc072 Initial revision
glantau
parents:
diff changeset
143 /* Right limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
144 x2 = xx + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
145 if (x2 > xmax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
146 x2 = xmax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
147
986e461dc072 Initial revision
glantau
parents:
diff changeset
148 /* Upper limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
149 y1 = yy - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
150 if (y1 < ymin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
151 y1 = ymin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
152
986e461dc072 Initial revision
glantau
parents:
diff changeset
153 /* Lower limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
154 y2 = yy + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
155 if (y2 > ymax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
156 y2 = ymax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
157
986e461dc072 Initial revision
glantau
parents:
diff changeset
158 pix = s->new_picture[0] + (yy * s->linesize) + xx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
159 dmin = 0x7fffffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
160 mx = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
161 my = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
162
986e461dc072 Initial revision
glantau
parents:
diff changeset
163 do {
986e461dc072 Initial revision
glantau
parents:
diff changeset
164 for (y = y1; y <= y2; y += range) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
165 for (x = x1; x <= x2; x += range) {
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
166 d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
167 if (d < dmin || (d == dmin && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
168 dmin = d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
169 mx = x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
170 my = y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
171 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
172 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
173 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
174
986e461dc072 Initial revision
glantau
parents:
diff changeset
175 range = range >> 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
176
986e461dc072 Initial revision
glantau
parents:
diff changeset
177 x1 = mx - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
178 if (x1 < xmin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
179 x1 = xmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
180
986e461dc072 Initial revision
glantau
parents:
diff changeset
181 x2 = mx + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
182 if (x2 > xmax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
183 x2 = xmax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
184
986e461dc072 Initial revision
glantau
parents:
diff changeset
185 y1 = my - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
186 if (y1 < ymin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
187 y1 = ymin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
188
986e461dc072 Initial revision
glantau
parents:
diff changeset
189 y2 = my + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
190 if (y2 > ymax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
191 y2 = ymax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
192
986e461dc072 Initial revision
glantau
parents:
diff changeset
193 } while (range >= 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
194
986e461dc072 Initial revision
glantau
parents:
diff changeset
195 #ifdef DEBUG
986e461dc072 Initial revision
glantau
parents:
diff changeset
196 fprintf(stderr, "log - MX: %d\tMY: %d\n", mx, my);
986e461dc072 Initial revision
glantau
parents:
diff changeset
197 #endif
986e461dc072 Initial revision
glantau
parents:
diff changeset
198 *mx_ptr = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
199 *my_ptr = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
200 return dmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
201 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
202
986e461dc072 Initial revision
glantau
parents:
diff changeset
203 static int phods_motion_search(MpegEncContext * s,
986e461dc072 Initial revision
glantau
parents:
diff changeset
204 int *mx_ptr, int *my_ptr, int range,
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
205 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
206 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
207 int x1, y1, x2, y2, xx, yy, x, y, lastx, d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
208 int mx, my, dminx, dminy;
986e461dc072 Initial revision
glantau
parents:
diff changeset
209 UINT8 *pix;
986e461dc072 Initial revision
glantau
parents:
diff changeset
210
986e461dc072 Initial revision
glantau
parents:
diff changeset
211 xx = s->mb_x << 4;
986e461dc072 Initial revision
glantau
parents:
diff changeset
212 yy = s->mb_y << 4;
986e461dc072 Initial revision
glantau
parents:
diff changeset
213
986e461dc072 Initial revision
glantau
parents:
diff changeset
214 /* Left limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
215 x1 = xx - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
216 if (x1 < xmin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
217 x1 = xmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
218
986e461dc072 Initial revision
glantau
parents:
diff changeset
219 /* Right limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
220 x2 = xx + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
221 if (x2 > xmax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
222 x2 = xmax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
223
986e461dc072 Initial revision
glantau
parents:
diff changeset
224 /* Upper limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
225 y1 = yy - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
226 if (y1 < ymin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
227 y1 = ymin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
228
986e461dc072 Initial revision
glantau
parents:
diff changeset
229 /* Lower limit */
986e461dc072 Initial revision
glantau
parents:
diff changeset
230 y2 = yy + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
231 if (y2 > ymax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
232 y2 = ymax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
233
986e461dc072 Initial revision
glantau
parents:
diff changeset
234 pix = s->new_picture[0] + (yy * s->linesize) + xx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
235 mx = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
236 my = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
237
986e461dc072 Initial revision
glantau
parents:
diff changeset
238 x = xx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
239 y = yy;
986e461dc072 Initial revision
glantau
parents:
diff changeset
240 do {
986e461dc072 Initial revision
glantau
parents:
diff changeset
241 dminx = 0x7fffffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
242 dminy = 0x7fffffff;
986e461dc072 Initial revision
glantau
parents:
diff changeset
243
986e461dc072 Initial revision
glantau
parents:
diff changeset
244 lastx = x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
245 for (x = x1; x <= x2; x += range) {
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
246 d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
247 if (d < dminx || (d == dminx && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
248 dminx = d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
249 mx = x;
986e461dc072 Initial revision
glantau
parents:
diff changeset
250 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
251 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
252
986e461dc072 Initial revision
glantau
parents:
diff changeset
253 x = lastx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
254 for (y = y1; y <= y2; y += range) {
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
255 d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
256 if (d < dminy || (d == dminy && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
986e461dc072 Initial revision
glantau
parents:
diff changeset
257 dminy = d;
986e461dc072 Initial revision
glantau
parents:
diff changeset
258 my = y;
986e461dc072 Initial revision
glantau
parents:
diff changeset
259 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
260 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
261
986e461dc072 Initial revision
glantau
parents:
diff changeset
262 range = range >> 1;
986e461dc072 Initial revision
glantau
parents:
diff changeset
263
986e461dc072 Initial revision
glantau
parents:
diff changeset
264 x = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
265 y = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
266 x1 = mx - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
267 if (x1 < xmin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
268 x1 = xmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
269
986e461dc072 Initial revision
glantau
parents:
diff changeset
270 x2 = mx + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
271 if (x2 > xmax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
272 x2 = xmax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
273
986e461dc072 Initial revision
glantau
parents:
diff changeset
274 y1 = my - range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
275 if (y1 < ymin)
986e461dc072 Initial revision
glantau
parents:
diff changeset
276 y1 = ymin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
277
986e461dc072 Initial revision
glantau
parents:
diff changeset
278 y2 = my + range;
986e461dc072 Initial revision
glantau
parents:
diff changeset
279 if (y2 > ymax)
986e461dc072 Initial revision
glantau
parents:
diff changeset
280 y2 = ymax;
986e461dc072 Initial revision
glantau
parents:
diff changeset
281
986e461dc072 Initial revision
glantau
parents:
diff changeset
282 } while (range >= 1);
986e461dc072 Initial revision
glantau
parents:
diff changeset
283
986e461dc072 Initial revision
glantau
parents:
diff changeset
284 #ifdef DEBUG
986e461dc072 Initial revision
glantau
parents:
diff changeset
285 fprintf(stderr, "phods - MX: %d\tMY: %d\n", mx, my);
986e461dc072 Initial revision
glantau
parents:
diff changeset
286 #endif
986e461dc072 Initial revision
glantau
parents:
diff changeset
287
986e461dc072 Initial revision
glantau
parents:
diff changeset
288 /* half pixel search */
986e461dc072 Initial revision
glantau
parents:
diff changeset
289 *mx_ptr = mx;
986e461dc072 Initial revision
glantau
parents:
diff changeset
290 *my_ptr = my;
986e461dc072 Initial revision
glantau
parents:
diff changeset
291 return dminy;
986e461dc072 Initial revision
glantau
parents:
diff changeset
292 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
293
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
294
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
295 #define Z_THRESHOLD 256
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
296
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
297 #define CHECK_MV(x,y)\
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
298 {\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
299 const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
300 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
301 if(map[index]!=key){\
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
302 d = s->dsp.pix_abs16x16(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
303 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
304 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
305 map[index]= key;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
306 score_map[index]= d;\
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
307 }\
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
308 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
309
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
310 #define CHECK_MV_DIR(x,y,new_dir)\
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
311 {\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
312 const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
313 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
314 if(map[index]!=key){\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
315 d = pix_abs(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
316 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
317 if(d<dmin){\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
318 best[0]=x;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
319 best[1]=y;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
320 dmin=d;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
321 next_dir= new_dir;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
322 }\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
323 map[index]= key;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
324 score_map[index]= d;\
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
325 }\
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
326 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
327
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
328 #define CHECK_MV4(x,y)\
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
329 {\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
330 const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
331 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
332 if(map[index]!=key){\
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
333 d = s->dsp.pix_abs8x8(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
334 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
335 COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
336 map[index]= key;\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
337 score_map[index]= d;\
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
338 }\
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
339 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
340
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
341 #define check(x,y,S,v)\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
342 if( (x)<(xmin<<(S)) ) printf("%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
343 if( (x)>(xmax<<(S)) ) printf("%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
344 if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
345 if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
346
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
347
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
348 static inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
349 UINT8 *new_pic, UINT8 *old_pic, int pic_stride,
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
350 int pred_x, int pred_y, UINT16 *mv_penalty, int quant,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
351 int xmin, int ymin, int xmax, int ymax, int shift,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
352 uint32_t *map, uint16_t *score_map, int map_generation,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
353 op_pixels_abs_func pix_abs)
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
354 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
355 int next_dir=-1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
356
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
357 for(;;){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
358 int d;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
359 const int dir= next_dir;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
360 const int x= best[0];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
361 const int y= best[1];
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
362 next_dir=-1;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
363
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
364 //printf("%d", dir);
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
365 if(dir!=2 && x>xmin) CHECK_MV_DIR(x-1, y , 0)
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
366 if(dir!=3 && y>ymin) CHECK_MV_DIR(x , y-1, 1)
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
367 if(dir!=0 && x<xmax) CHECK_MV_DIR(x+1, y , 2)
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
368 if(dir!=1 && y<ymax) CHECK_MV_DIR(x , y+1, 3)
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
369
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
370 if(next_dir==-1){
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
371 return dmin;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
372 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
373 }
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
374
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
375 /* for(;;){
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
376 int d;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
377 const int x= best[0];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
378 const int y= best[1];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
379 const int last_min=dmin;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
380 if(x>xmin) CHECK_MV(x-1, y )
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
381 if(y>xmin) CHECK_MV(x , y-1)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
382 if(x<xmax) CHECK_MV(x+1, y )
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
383 if(y<xmax) CHECK_MV(x , y+1)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
384 if(x>xmin && y>ymin) CHECK_MV(x-1, y-1)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
385 if(x>xmin && y<ymax) CHECK_MV(x-1, y+1)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
386 if(x<xmax && y>ymin) CHECK_MV(x+1, y-1)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
387 if(x<xmax && y<ymax) CHECK_MV(x+1, y+1)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
388 if(x-1>xmin) CHECK_MV(x-2, y )
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
389 if(y-1>xmin) CHECK_MV(x , y-2)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
390 if(x+1<xmax) CHECK_MV(x+2, y )
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
391 if(y+1<xmax) CHECK_MV(x , y+2)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
392 if(x-1>xmin && y-1>ymin) CHECK_MV(x-2, y-2)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
393 if(x-1>xmin && y+1<ymax) CHECK_MV(x-2, y+2)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
394 if(x+1<xmax && y-1>ymin) CHECK_MV(x+2, y-2)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
395 if(x+1<xmax && y+1<ymax) CHECK_MV(x+2, y+2)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
396 if(dmin==last_min) return dmin;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
397 }
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
398 */
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
399 }
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
400
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
401 #if 1
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
402 #define SNAKE_1 3
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
403 #define SNAKE_2 2
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
404 #else
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
405 #define SNAKE_1 7
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
406 #define SNAKE_2 3
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
407 #endif
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
408 static inline int snake_search(MpegEncContext * s, int *best, int dmin,
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
409 UINT8 *new_pic, UINT8 *old_pic, int pic_stride,
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
410 int pred_x, int pred_y, UINT16 *mv_penalty, int quant,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
411 int xmin, int ymin, int xmax, int ymax, int shift,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
412 uint32_t *map, uint16_t *score_map,int map_generation,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
413 op_pixels_abs_func pix_abs)
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
414 {
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
415 int dir=0;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
416 int c=1;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
417 static int x_dir[8]= {1,1,0,-1,-1,-1, 0, 1};
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
418 static int y_dir[8]= {0,1,1, 1, 0,-1,-1,-1};
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
419 int fails=0;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
420 int last_d[2]={dmin, dmin};
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
421
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
422 /*static int good=0;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
423 static int bad=0;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
424 static int point=0;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
425
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
426 point++;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
427 if(256*256*256*64%point==0)
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
428 {
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
429 printf("%d %d %d\n", good, bad, point);
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
430 }*/
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
431
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
432 for(;;){
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
433 int x= best[0];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
434 int y= best[1];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
435 int d;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
436 x+=x_dir[dir];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
437 y+=y_dir[dir];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
438 if(x>=xmin && x<=xmax && y>=ymin && y<=ymax){
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
439 const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
440 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
441 if(map[index]!=key){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
442 d = pix_abs(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
443 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
444 map[index]=key;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
445 score_map[index]=d;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
446 }else
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
447 d= dmin+1;
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
448 }else{
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
449 d = dmin + 10000; //FIXME smarter boundary handling
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
450 }
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
451 if(d<dmin){
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
452 best[0]=x;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
453 best[1]=y;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
454 dmin=d;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
455
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
456 if(last_d[1] - last_d[0] > last_d[0] - d) c= -c;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
457 dir+=c;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
458
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
459 fails=0;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
460 //good++;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
461 last_d[1]=last_d[0];
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
462 last_d[0]=d;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
463 }else{
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
464 //bad++;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
465 if(fails){
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
466 if(fails>=SNAKE_1+1) return dmin;
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
467 }else{
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
468 if(dir&1) dir-= c*3;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
469 else c= -c;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
470 // c= -c;
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
471 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
472 dir+=c*SNAKE_2;
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
473 fails++;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
474 }
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
475 dir&=7;
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
476 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
477 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
478
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
479 static inline int cross_search(MpegEncContext * s, int *best, int dmin,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
480 UINT8 *new_pic, UINT8 *old_pic, int pic_stride,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
481 int pred_x, int pred_y, UINT16 *mv_penalty, int quant,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
482 int xmin, int ymin, int xmax, int ymax, int shift,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
483 uint32_t *map, uint16_t *score_map,int map_generation,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
484 op_pixels_abs_func pix_abs)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
485 {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
486 static int x_dir[4]= {-1, 0, 1, 0};
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
487 static int y_dir[4]= { 0,-1, 0, 1};
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
488 int improvement[2]={100000, 100000};
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
489 int dirs[2]={2, 3};
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
490 int dir;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
491 int last_dir= -1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
492
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
493 for(;;){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
494 dir= dirs[ improvement[0] > improvement[1] ? 0 : 1 ];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
495 if(improvement[dir&1]==-1) return dmin;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
496
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
497 {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
498 const int x= best[0] + x_dir[dir];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
499 const int y= best[1] + y_dir[dir];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
500 const int key= (y<<ME_MAP_MV_BITS) + x + map_generation;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
501 const int index= ((y<<ME_MAP_SHIFT) + x)&(ME_MAP_SIZE-1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
502 int d;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
503 if(x>=xmin && x<=xmax && y>=ymin && y<=ymax){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
504 if(map[index]!=key){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
505 d = pix_abs(new_pic, old_pic + x + y*pic_stride, pic_stride);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
506 d += (mv_penalty[(x<<shift)-pred_x] + mv_penalty[(y<<shift)-pred_y])*quant;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
507 map[index]=key;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
508 score_map[index]=d;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
509 if(d<dmin){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
510 improvement[dir&1]= dmin-d;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
511 improvement[(dir&1)^1]++;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
512 dmin=d;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
513 best[0]= x;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
514 best[1]= y;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
515 last_dir=dir;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
516 continue;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
517 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
518 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
519 d= score_map[index];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
520 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
521 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
522 d= dmin + 1000; //FIXME is this a good idea?
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
523 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
524 /* evaluated point was cached or checked and worse */
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
525
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
526 if(last_dir==dir){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
527 improvement[dir&1]= -1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
528 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
529 improvement[dir&1]= d-dmin;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
530 last_dir= dirs[dir&1]= dir^2;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
531 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
532 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
533 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
534 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
535
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
536 static inline int update_map_generation(MpegEncContext * s)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
537 {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
538 s->me_map_generation+= 1<<(ME_MAP_MV_BITS*2);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
539 if(s->me_map_generation==0){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
540 s->me_map_generation= 1<<(ME_MAP_MV_BITS*2);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
541 memset(s->me_map, 0, sizeof(uint32_t)*ME_MAP_SIZE);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
542 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
543 return s->me_map_generation;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
544 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
545
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
546 static int epzs_motion_search(MpegEncContext * s,
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
547 int *mx_ptr, int *my_ptr,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
548 int P[10][2], int pred_x, int pred_y,
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
549 int xmin, int ymin, int xmax, int ymax, uint8_t * ref_picture)
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
550 {
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
551 int best[2]={0, 0};
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
552 int d, dmin;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
553 UINT8 *new_pic, *old_pic;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
554 const int pic_stride= s->linesize;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
555 const int pic_xy= (s->mb_y*pic_stride + s->mb_x)*16;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
556 UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
557 int quant= s->qscale; // qscale of the prev frame
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
558 const int shift= 1+s->quarter_sample;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
559 uint32_t *map= s->me_map;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
560 uint16_t *score_map= s->me_score_map;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
561 int map_generation;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
562
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
563 new_pic = s->new_picture[0] + pic_xy;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
564 old_pic = ref_picture + pic_xy;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
565
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
566 map_generation= update_map_generation(s);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
567
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
568 dmin = s->dsp.pix_abs16x16(new_pic, old_pic, pic_stride);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
569 map[0]= map_generation;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
570 score_map[0]= dmin;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
571
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
572 /* first line */
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
573 if ((s->mb_y == 0 || s->first_slice_line)) {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
574 CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
575 CHECK_MV(P_LAST[0]>>shift, P_LAST[1]>>shift)
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
576 }else{
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
577 if(dmin<256 && ( P_LEFT[0] |P_LEFT[1]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
578 |P_TOP[0] |P_TOP[1]
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
579 |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
580 *mx_ptr= 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
581 *my_ptr= 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
582 s->skip_me=1;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
583 return dmin;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
584 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
585 CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
586 if(dmin>256*2){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
587 CHECK_MV(P_LAST[0] >>shift, P_LAST[1] >>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
588 CHECK_MV(P_LEFT[0] >>shift, P_LEFT[1] >>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
589 CHECK_MV(P_TOP[0] >>shift, P_TOP[1] >>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
590 CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
591 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
592 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
593 if(dmin>256*4){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
594 CHECK_MV(P_LAST_RIGHT[0] >>shift, P_LAST_RIGHT[1] >>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
595 CHECK_MV(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift)
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
596 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
597 #if 0 //doest only slow things down
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
598 if(dmin>512*3){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
599 int step;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
600 dmin= score_map[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
601 best[0]= best[1]=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
602 for(step=128; step>0; step>>=1){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
603 const int step2= step;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
604 int y;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
605 for(y=-step2+best[1]; y<=step2+best[1]; y+=step){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
606 int x;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
607 if(y<ymin || y>ymax) continue;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
608
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
609 for(x=-step2+best[0]; x<=step2+best[0]; x+=step){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
610 if(x<xmin || x>xmax) continue;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
611 if(x==best[0] && y==best[1]) continue;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
612 CHECK_MV(x,y)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
613 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
614 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
615 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
616 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
617 #endif
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
618 //check(best[0],best[1],0, b0)
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
619 if(s->me_method==ME_EPZS)
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
620 dmin= small_diamond_search(s, best, dmin, new_pic, old_pic, pic_stride,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
621 pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax,
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
622 shift, map, score_map, map_generation, s->dsp.pix_abs16x16);
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
623 else
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
624 dmin= cross_search(s, best, dmin, new_pic, old_pic, pic_stride,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
625 pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax,
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
626 shift, map, score_map, map_generation, s->dsp.pix_abs16x16);
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
627 //check(best[0],best[1],0, b1)
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
628 *mx_ptr= best[0];
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
629 *my_ptr= best[1];
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
630
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
631 // printf("%d %d %d \n", best[0], best[1], dmin);
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
632 return dmin;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
633 }
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
634
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
635 static int epzs_motion_search4(MpegEncContext * s, int block,
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
636 int *mx_ptr, int *my_ptr,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
637 int P[10][2], int pred_x, int pred_y,
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
638 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
639 {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
640 int best[2]={0, 0};
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
641 int d, dmin;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
642 UINT8 *new_pic, *old_pic;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
643 const int pic_stride= s->linesize;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
644 const int pic_xy= ((s->mb_y*2 + (block>>1))*pic_stride + s->mb_x*2 + (block&1))*8;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
645 UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
646 int quant= s->qscale; // qscale of the prev frame
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
647 const int shift= 1+s->quarter_sample;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
648 uint32_t *map= s->me_map;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
649 uint16_t *score_map= s->me_score_map;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
650 int map_generation;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
651
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
652 new_pic = s->new_picture[0] + pic_xy;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
653 old_pic = ref_picture + pic_xy;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
654
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
655 map_generation= update_map_generation(s);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
656
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
657 dmin = 1000000;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
658 //printf("%d %d %d %d //",xmin, ymin, xmax, ymax);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
659 /* first line */
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
660 if ((s->mb_y == 0 || s->first_slice_line) && block<2) {
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
661 CHECK_MV4(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
662 CHECK_MV4(P_LAST[0]>>shift, P_LAST[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
663 CHECK_MV4(P_MV1[0]>>shift, P_MV1[1]>>shift)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
664 }else{
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
665 CHECK_MV4(P_MV1[0]>>shift, P_MV1[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
666 //FIXME try some early stop
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
667 if(dmin>64*2){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
668 CHECK_MV4(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
669 CHECK_MV4(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
670 CHECK_MV4(P_TOP[0]>>shift, P_TOP[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
671 CHECK_MV4(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
672 CHECK_MV4(P_LAST[0]>>shift, P_LAST[1]>>shift)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
673 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
674 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
675 if(dmin>64*4){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
676 CHECK_MV4(P_LAST_RIGHT[0]>>shift, P_LAST_RIGHT[1]>>shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
677 CHECK_MV4(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
678 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
679
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
680 if(s->me_method==ME_EPZS)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
681 dmin= small_diamond_search(s, best, dmin, new_pic, old_pic, pic_stride,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
682 pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax,
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
683 shift, map, score_map, map_generation, s->dsp.pix_abs8x8);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
684 else
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
685 dmin= cross_search(s, best, dmin, new_pic, old_pic, pic_stride,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
686 pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax,
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
687 shift, map, score_map, map_generation, s->dsp.pix_abs8x8);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
688
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
689 *mx_ptr= best[0];
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
690 *my_ptr= best[1];
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
691
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
692 // printf("%d %d %d \n", best[0], best[1], dmin);
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
693 return dmin;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
694 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
695
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
696 #define CHECK_HALF_MV(suffix, x, y) \
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
697 {\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
698 d= pix_abs_ ## suffix(pix, ptr+((x)>>1), s->linesize);\
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
699 d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*quant;\
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
700 COPY3_IF_LT(dminh, d, dx, x, dy, y)\
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
701 }
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
702
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
703
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
704 /* The idea would be to make half pel ME after Inter/Intra decision to
986e461dc072 Initial revision
glantau
parents:
diff changeset
705 save time. */
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
706 static inline int halfpel_motion_search(MpegEncContext * s,
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
707 int *mx_ptr, int *my_ptr, int dmin,
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
708 int xmin, int ymin, int xmax, int ymax,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
709 int pred_x, int pred_y, uint8_t *ref_picture,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
710 op_pixels_abs_func pix_abs_x2,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
711 op_pixels_abs_func pix_abs_y2, op_pixels_abs_func pix_abs_xy2, int n)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
712 {
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
713 UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
714 const int quant= s->qscale;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
715 int mx, my, xx, yy, dminh;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
716 UINT8 *pix, *ptr;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
717
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
718 if(s->skip_me){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
719 *mx_ptr = 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
720 *my_ptr = 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
721 return dmin;
863
4ba00af12589 1l found by kabi
michaelni
parents: 853
diff changeset
722 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
723
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
724 xx = 16 * s->mb_x + 8*(n&1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
725 yy = 16 * s->mb_y + 8*(n>>1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
726 pix = s->new_picture[0] + (yy * s->linesize) + xx;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
727
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
728 mx = *mx_ptr;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
729 my = *my_ptr;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
730 ptr = ref_picture + ((yy + my) * s->linesize) + (xx + mx);
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
731
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
732 dminh = dmin;
986e461dc072 Initial revision
glantau
parents:
diff changeset
733
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
734 if (mx > xmin && mx < xmax &&
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
735 my > ymin && my < ymax) {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
736 int dx=0, dy=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
737 int d, pen_x, pen_y;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
738
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
739 mx<<=1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
740 my<<=1;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
741
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
742 pen_x= pred_x + mx;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
743 pen_y= pred_y + my;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
744
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
745 ptr-= s->linesize;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
746 CHECK_HALF_MV(xy2, -1, -1)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
747 CHECK_HALF_MV(y2 , 0, -1)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
748 CHECK_HALF_MV(xy2, +1, -1)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
749
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
750 ptr+= s->linesize;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
751 CHECK_HALF_MV(x2 , -1, 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
752 CHECK_HALF_MV(x2 , +1, 0)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
753 CHECK_HALF_MV(xy2, -1, +1)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
754 CHECK_HALF_MV(y2 , 0, +1)
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
755 CHECK_HALF_MV(xy2, +1, +1)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
756
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
757 mx+=dx;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
758 my+=dy;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
759 }else{
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
760 mx<<=1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
761 my<<=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
762 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
763
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
764 *mx_ptr = mx;
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
765 *my_ptr = my;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
766 return dminh;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
767 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
768
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
769 static inline int fast_halfpel_motion_search(MpegEncContext * s,
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
770 int *mx_ptr, int *my_ptr, int dmin,
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
771 int xmin, int ymin, int xmax, int ymax,
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
772 int pred_x, int pred_y, uint8_t *ref_picture,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
773 op_pixels_abs_func pix_abs_x2,
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
774 op_pixels_abs_func pix_abs_y2, op_pixels_abs_func pix_abs_xy2, int n)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
775 {
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
776 UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
777 uint16_t *score_map= s->me_score_map;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
778 const int quant= s->qscale;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
779 int mx, my, xx, yy, dminh;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
780 UINT8 *pix, *ptr;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
781
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
782 if(s->skip_me){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
783 // printf("S");
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
784 *mx_ptr = 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
785 *my_ptr = 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
786 return dmin;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
787 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
788 // printf("N");
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
789
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
790 xx = 16 * s->mb_x + 8*(n&1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
791 yy = 16 * s->mb_y + 8*(n>>1);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
792 pix = s->new_picture[0] + (yy * s->linesize) + xx;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
793
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
794 mx = *mx_ptr;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
795 my = *my_ptr;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
796 ptr = ref_picture + ((yy + my) * s->linesize) + (xx + mx);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
797
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
798 dminh = dmin;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
799
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
800 if (mx > xmin && mx < xmax &&
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
801 my > ymin && my < ymax) {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
802 int dx=0, dy=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
803 int d, pen_x, pen_y;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
804 const int index= (my<<ME_MAP_SHIFT) + mx;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
805 const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
806 const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
807 const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
808 const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
809 mx<<=1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
810 my<<=1;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
811
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
812
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
813 pen_x= pred_x + mx;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
814 pen_y= pred_y + my;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
815
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
816 ptr-= s->linesize;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
817 if(t<=b){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
818 CHECK_HALF_MV(y2 , 0, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
819 if(l<=r){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
820 CHECK_HALF_MV(xy2, -1, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
821 if(t+r<=b+l){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
822 CHECK_HALF_MV(xy2, +1, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
823 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
824 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
825 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
826 CHECK_HALF_MV(xy2, -1, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
827 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
828 CHECK_HALF_MV(x2 , -1, 0)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
829 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
830 CHECK_HALF_MV(xy2, +1, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
831 if(t+l<=b+r){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
832 CHECK_HALF_MV(xy2, -1, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
833 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
834 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
835 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
836 CHECK_HALF_MV(xy2, +1, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
837 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
838 CHECK_HALF_MV(x2 , +1, 0)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
839 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
840 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
841 if(l<=r){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
842 if(t+l<=b+r){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
843 CHECK_HALF_MV(xy2, -1, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
844 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
845 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
846 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
847 CHECK_HALF_MV(xy2, +1, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
848 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
849 CHECK_HALF_MV(x2 , -1, 0)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
850 CHECK_HALF_MV(xy2, -1, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
851 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
852 if(t+r<=b+l){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
853 CHECK_HALF_MV(xy2, +1, -1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
854 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
855 }else{
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
856 ptr+= s->linesize;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
857 CHECK_HALF_MV(xy2, -1, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
858 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
859 CHECK_HALF_MV(x2 , +1, 0)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
860 CHECK_HALF_MV(xy2, +1, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
861 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
862 CHECK_HALF_MV(y2 , 0, +1)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
863 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
864 mx+=dx;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
865 my+=dy;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
866
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
867 }else{
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
868 mx<<=1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
869 my<<=1;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
870 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
871
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
872 *mx_ptr = mx;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
873 *my_ptr = my;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
874 return dminh;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
875 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
876
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
877 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
878 {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
879 const int xy= s->mb_x + 1 + (s->mb_y + 1)*(s->mb_width + 2);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
880
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
881 s->p_mv_table[xy][0] = mx;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
882 s->p_mv_table[xy][1] = my;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
883
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
884 /* has allready been set to the 4 MV if 4MV is done */
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
885 if(mv4){
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
886 int mot_xy= s->block_index[0];
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
887
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
888 s->motion_val[mot_xy ][0]= mx;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
889 s->motion_val[mot_xy ][1]= my;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
890 s->motion_val[mot_xy+1][0]= mx;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
891 s->motion_val[mot_xy+1][1]= my;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
892
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
893 mot_xy += s->block_wrap[0];
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
894 s->motion_val[mot_xy ][0]= mx;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
895 s->motion_val[mot_xy ][1]= my;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
896 s->motion_val[mot_xy+1][0]= mx;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
897 s->motion_val[mot_xy+1][1]= my;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
898 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
899 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
900
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
901 static inline void get_limits(MpegEncContext *s, int *range, int *xmin, int *ymin, int *xmax, int *ymax, int f_code)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
902 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
903 *range = 8 * (1 << (f_code - 1));
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
904 /* XXX: temporary kludge to avoid overflow for msmpeg4 */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
905 if (s->out_format == FMT_H263 && !s->h263_msmpeg4)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
906 *range *= 2;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
907
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
908 if (s->unrestricted_mv) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
909 *xmin = -16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
910 *ymin = -16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
911 if (s->h263_plus)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
912 *range *= 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
913 if(s->avctx==NULL || s->avctx->codec->id!=CODEC_ID_MPEG4){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
914 *xmax = s->mb_width*16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
915 *ymax = s->mb_height*16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
916 }else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
917 /* XXX: dunno if this is correct but ffmpeg4 decoder wont like it otherwise
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
918 (cuz the drawn edge isnt large enough))*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
919 *xmax = s->width;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
920 *ymax = s->height;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
921 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
922 } else {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
923 *xmin = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
924 *ymin = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
925 *xmax = s->mb_width*16 - 16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
926 *ymax = s->mb_height*16 - 16;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
927 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
928 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
929
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
930 static inline int mv4_search(MpegEncContext *s, int xmin, int ymin, int xmax, int ymax, int mx, int my, int shift)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
931 {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
932 int block;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
933 int P[10][2];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
934 uint8_t *ref_picture= s->last_picture[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
935 int dmin_sum=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
936
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
937 for(block=0; block<4; block++){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
938 int mx4, my4;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
939 int pred_x4, pred_y4;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
940 int dmin4;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
941 static const int off[4]= {2, 1, 1, -1};
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
942 const int mot_stride = s->block_wrap[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
943 const int mot_xy = s->block_index[block];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
944 // const int block_x= (block&1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
945 // const int block_y= (block>>1);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
946 #if 1 // this saves us a bit of cliping work and shouldnt affect compression in a negative way
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
947 const int rel_xmin4= xmin;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
948 const int rel_xmax4= xmax;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
949 const int rel_ymin4= ymin;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
950 const int rel_ymax4= ymax;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
951 #else
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
952 const int rel_xmin4= xmin - block_x*8;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
953 const int rel_xmax4= xmax - block_x*8 + 8;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
954 const int rel_ymin4= ymin - block_y*8;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
955 const int rel_ymax4= ymax - block_y*8 + 8;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
956 #endif
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
957 P_LAST[0] = s->motion_val[mot_xy ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
958 P_LAST[1] = s->motion_val[mot_xy ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
959 P_LEFT[0] = s->motion_val[mot_xy - 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
960 P_LEFT[1] = s->motion_val[mot_xy - 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
961 P_LAST_RIGHT[0] = s->motion_val[mot_xy + 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
962 P_LAST_RIGHT[1] = s->motion_val[mot_xy + 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
963 P_LAST_BOTTOM[0]= s->motion_val[mot_xy + 1*mot_stride][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
964 P_LAST_BOTTOM[1]= s->motion_val[mot_xy + 1*mot_stride][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
965
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
966 if(P_LEFT[0] > (rel_xmax4<<shift)) P_LEFT[0] = (rel_xmax4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
967 if(P_LAST_RIGHT[0] < (rel_xmin4<<shift)) P_LAST_RIGHT[0] = (rel_xmin4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
968 if(P_LAST_BOTTOM[1]< (rel_ymin4<<shift)) P_LAST_BOTTOM[1]= (rel_ymin4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
969
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
970 /* special case for first line */
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
971 if ((s->mb_y == 0 || s->first_slice_line) && block<2) {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
972 pred_x4= P_LEFT[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
973 pred_y4= P_LEFT[1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
974 } else {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
975 P_TOP[0] = s->motion_val[mot_xy - mot_stride ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
976 P_TOP[1] = s->motion_val[mot_xy - mot_stride ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
977 P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + off[block]][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
978 P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + off[block]][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
979 if(P_TOP[1] > (rel_ymax4<<shift)) P_TOP[1] = (rel_ymax4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
980 if(P_TOPRIGHT[0] < (rel_xmin4<<shift)) P_TOPRIGHT[0]= (rel_xmin4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
981 if(P_TOPRIGHT[0] > (rel_xmax4<<shift)) P_TOPRIGHT[0]= (rel_xmax4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
982 if(P_TOPRIGHT[1] > (rel_ymax4<<shift)) P_TOPRIGHT[1]= (rel_ymax4<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
983
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
984 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
985 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
986
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
987 if(s->out_format == FMT_H263){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
988 pred_x4 = P_MEDIAN[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
989 pred_y4 = P_MEDIAN[1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
990 }else { /* mpeg1 at least */
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
991 pred_x4= P_LEFT[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
992 pred_y4= P_LEFT[1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
993 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
994 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
995 P_MV1[0]= mx;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
996 P_MV1[1]= my;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
997
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
998 dmin4 = epzs_motion_search4(s, block, &mx4, &my4, P, pred_x4, pred_y4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, ref_picture);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
999
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1000 dmin4= fast_halfpel_motion_search(s, &mx4, &my4, dmin4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4,
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1001 pred_x4, pred_y4, ref_picture, s->dsp.pix_abs8x8_x2,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1002 s->dsp.pix_abs8x8_y2, s->dsp.pix_abs8x8_xy2, block);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1003
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1004 s->motion_val[ s->block_index[block] ][0]= mx4;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1005 s->motion_val[ s->block_index[block] ][1]= my4;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1006 dmin_sum+= dmin4;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1007 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1008 return dmin_sum;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1009 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1010
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1011 void ff_estimate_p_frame_motion(MpegEncContext * s,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1012 int mb_x, int mb_y)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1013 {
986e461dc072 Initial revision
glantau
parents:
diff changeset
1014 UINT8 *pix, *ppix;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1015 int sum, varc, vard, mx, my, range, dmin, xx, yy;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1016 int xmin, ymin, xmax, ymax;
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1017 int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
1018 int pred_x=0, pred_y=0;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1019 int P[10][2];
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1020 const int shift= 1+s->quarter_sample;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1021 int mb_type=0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1022 uint8_t *ref_picture= s->last_picture[0];
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1023
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1024 get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, s->f_code);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1025 rel_xmin= xmin - mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1026 rel_xmax= xmax - mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1027 rel_ymin= ymin - mb_y*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1028 rel_ymax= ymax - mb_y*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1029 s->skip_me=0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1030
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1031 switch(s->me_method) {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1032 case ME_ZERO:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1033 default:
986e461dc072 Initial revision
glantau
parents:
diff changeset
1034 no_motion_search(s, &mx, &my);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1035 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1036 my-= mb_y*16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1037 dmin = 0;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1038 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1039 case ME_FULL:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1040 dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1041 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1042 my-= mb_y*16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1043 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1044 case ME_LOG:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1045 dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1046 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1047 my-= mb_y*16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1048 break;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1049 case ME_PHODS:
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1050 dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1051 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1052 my-= mb_y*16;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1053 break;
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 284
diff changeset
1054 case ME_X1:
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
1055 case ME_EPZS:
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 284
diff changeset
1056 {
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1057 const int mot_stride = s->block_wrap[0];
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1058 const int mot_xy = s->block_index[0];
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 284
diff changeset
1059
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1060 P_LAST[0] = s->motion_val[mot_xy ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1061 P_LAST[1] = s->motion_val[mot_xy ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1062 P_LEFT[0] = s->motion_val[mot_xy - 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1063 P_LEFT[1] = s->motion_val[mot_xy - 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1064 P_LAST_RIGHT[0] = s->motion_val[mot_xy + 2][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1065 P_LAST_RIGHT[1] = s->motion_val[mot_xy + 2][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1066 P_LAST_BOTTOM[0]= s->motion_val[mot_xy + 2*mot_stride][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1067 P_LAST_BOTTOM[1]= s->motion_val[mot_xy + 2*mot_stride][1];
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 284
diff changeset
1068
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1069 if(P_LEFT[0] > (rel_xmax<<shift)) P_LEFT[0] = (rel_xmax<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1070 if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1071 if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1072
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1073 /* special case for first line */
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1074 if ((mb_y == 0 || s->first_slice_line)) {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1075 pred_x= P_LEFT[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1076 pred_y= P_LEFT[1];
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1077 } else {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1078 P_TOP[0] = s->motion_val[mot_xy - mot_stride ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1079 P_TOP[1] = s->motion_val[mot_xy - mot_stride ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1080 P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + 2][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1081 P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + 2][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1082 if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1] = (rel_ymax<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1083 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1084 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1085
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1086 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1087 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1088
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1089 if(s->out_format == FMT_H263){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1090 pred_x = P_MEDIAN[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1091 pred_y = P_MEDIAN[1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1092 }else { /* mpeg1 at least */
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1093 pred_x= P_LEFT[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1094 pred_y= P_LEFT[1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1095 }
288
f82cce6cb182 10l (motion_val was uninitilized)
michaelni
parents: 284
diff changeset
1096 }
280
3dc1ca4ba717 fixing epzs & mpeg1 (hopefully now really ...)
michaelni
parents: 277
diff changeset
1097 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1098 dmin = epzs_motion_search(s, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, ref_picture);
281
1fc96b02142e mpeg4 aspect_ratio_info in AVCodecContext (requested by alex)
michaelni
parents: 280
diff changeset
1099
277
5cb2978e701f new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents: 275
diff changeset
1100 break;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1101 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1102
986e461dc072 Initial revision
glantau
parents:
diff changeset
1103 /* intra / predictive decision */
986e461dc072 Initial revision
glantau
parents:
diff changeset
1104 xx = mb_x * 16;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1105 yy = mb_y * 16;
986e461dc072 Initial revision
glantau
parents:
diff changeset
1106
986e461dc072 Initial revision
glantau
parents:
diff changeset
1107 pix = s->new_picture[0] + (yy * s->linesize) + xx;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1108 /* At this point (mx,my) are full-pell and the relative displacement */
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1109 ppix = ref_picture + ((yy+my) * s->linesize) + (xx+mx);
289
648e9245546d seems the old intra/inter decission is slightly better with a threshold, than the new one
michaelni
parents: 288
diff changeset
1110
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1111 sum = s->dsp.pix_sum(pix, s->linesize);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1112
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1113 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1114 // FIXME: MMX OPTIMIZE
884
2cef5c4c0ca6 * altivec and pix_norm patch by Brian Foley
kabi
parents: 863
diff changeset
1115 vard = (s->dsp.pix_norm(pix, ppix, s->linesize)+128)>>8;
608
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1116
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1117 //printf("%d %d %d %X %X %X\n", s->mb_width, mb_x, mb_y,(int)s, (int)s->mb_var, (int)s->mc_mb_var); fflush(stdout);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1118 s->mb_var [s->mb_width * mb_y + mb_x] = varc;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1119 s->mc_mb_var[s->mb_width * mb_y + mb_x] = vard;
809
79de6308c34d fixing another assert q>0.0 issue caused by variance < 0, this fix allso changes the inter/intra decission very slightly -> all regression checksums need to be updated
michaelni
parents: 807
diff changeset
1120 s->mb_mean [s->mb_width * mb_y + mb_x] = (sum+128)>>8;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1121 s->mb_var_sum += varc;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1122 s->mc_mb_var_sum += vard;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1123 //printf("E%d %d %d %X %X %X\n", s->mb_width, mb_x, mb_y,(int)s, (int)s->mb_var, (int)s->mc_mb_var); fflush(stdout);
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1124
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1125 #if 0
233
3f5b72726118 - More work on preliminary bit rate control, just to be able to get an
pulento
parents: 232
diff changeset
1126 printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",
3f5b72726118 - More work on preliminary bit rate control, just to be able to get an
pulento
parents: 232
diff changeset
1127 varc, s->avg_mb_var, sum, vard, mx - xx, my - yy);
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1128 #endif
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1129 if(s->flags&CODEC_FLAG_HQ){
608
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1130 if (vard <= 64 || vard < varc)
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1131 s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1132 else
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1133 s->scene_change_score+= 20;
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1134
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1135 if (vard*2 + 200 > varc)
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1136 mb_type|= MB_TYPE_INTRA;
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1137 if (varc*2 + 200 > vard){
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1138 mb_type|= MB_TYPE_INTER;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1139 if(s->me_method >= ME_EPZS)
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1140 fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1141 pred_x, pred_y, ref_picture, s->dsp.pix_abs16x16_x2,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1142 s->dsp.pix_abs16x16_y2, s->dsp.pix_abs16x16_xy2, 0);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1143 else
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1144 halfpel_motion_search( s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1145 pred_x, pred_y, ref_picture, s->dsp.pix_abs16x16_x2,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1146 s->dsp.pix_abs16x16_y2, s->dsp.pix_abs16x16_xy2, 0);
304
5753d57e7e6b fixing MVs in hq mode
michaelni
parents: 295
diff changeset
1147 }else{
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1148 mx <<=1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1149 my <<=1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1150 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1151 if((s->flags&CODEC_FLAG_4MV)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1152 && !s->skip_me && varc>50 && vard>10){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1153 mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1154 mb_type|=MB_TYPE_INTER4V;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1155
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1156 set_p_mv_tables(s, mx, my, 0);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1157 }else
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1158 set_p_mv_tables(s, mx, my, 1);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1159 }else{
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1160 if (vard <= 64 || vard < varc) {
608
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1161 s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1162 mb_type|= MB_TYPE_INTER;
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1163 if (s->me_method != ME_ZERO) {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1164 if(s->me_method >= ME_EPZS)
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1165 dmin= fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1166 pred_x, pred_y, ref_picture, s->dsp.pix_abs16x16_x2, s->dsp.pix_abs16x16_y2,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1167 s->dsp.pix_abs16x16_xy2, 0);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1168 else
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1169 dmin= halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1170 pred_x, pred_y, ref_picture, s->dsp.pix_abs16x16_x2, s->dsp.pix_abs16x16_y2,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1171 s->dsp.pix_abs16x16_xy2, 0);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1172 if((s->flags&CODEC_FLAG_4MV)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1173 && !s->skip_me && varc>50 && vard>10){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1174 int dmin4= mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1175 if(dmin4 + 128 <dmin)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1176 mb_type= MB_TYPE_INTER4V;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1177 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1178 set_p_mv_tables(s, mx, my, mb_type!=MB_TYPE_INTER4V);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1179
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1180 } else {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1181 mx <<=1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1182 my <<=1;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1183 }
320
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1184 #if 0
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1185 if (vard < 10) {
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1186 skip++;
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1187 fprintf(stderr,"\nEarly skip: %d vard: %2d varc: %5d dmin: %d",
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1188 skip, vard, varc, dmin);
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1189 }
cda7d0857baf - ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents: 304
diff changeset
1190 #endif
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1191 }else{
608
98e39397636b better scene change detection
michaelni
parents: 587
diff changeset
1192 s->scene_change_score+= 20;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1193 mb_type|= MB_TYPE_INTRA;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1194 mx = 0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1195 my = 0;
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1196 }
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1197 }
284
0778d4e1d584 better inter/intra decission algo (same as xvid)
michaelni
parents: 281
diff changeset
1198
294
944632089814 4MV motion estimation (not finished yet)
michaelni
parents: 289
diff changeset
1199 s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1200 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1201
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1202 int ff_estimate_motion_b(MpegEncContext * s,
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1203 int mb_x, int mb_y, int16_t (*mv_table)[2], uint8_t *ref_picture, int f_code)
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1204 {
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1205 int mx, my, range, dmin;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1206 int xmin, ymin, xmax, ymax;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1207 int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1208 int pred_x=0, pred_y=0;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1209 int P[10][2];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1210 const int shift= 1+s->quarter_sample;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1211 const int mot_stride = s->mb_width + 2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1212 const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1213
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1214 get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, f_code);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1215 rel_xmin= xmin - mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1216 rel_xmax= xmax - mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1217 rel_ymin= ymin - mb_y*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1218 rel_ymax= ymax - mb_y*16;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1219
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1220 switch(s->me_method) {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1221 case ME_ZERO:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1222 default:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1223 no_motion_search(s, &mx, &my);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1224 dmin = 0;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1225 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1226 my-= mb_y*16;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1227 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1228 case ME_FULL:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1229 dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1230 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1231 my-= mb_y*16;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1232 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1233 case ME_LOG:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1234 dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1235 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1236 my-= mb_y*16;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1237 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1238 case ME_PHODS:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1239 dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1240 mx-= mb_x*16;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1241 my-= mb_y*16;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1242 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1243 case ME_X1:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1244 case ME_EPZS:
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1245 {
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1246
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1247 P_LAST[0] = mv_table[mot_xy ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1248 P_LAST[1] = mv_table[mot_xy ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1249 P_LEFT[0] = mv_table[mot_xy - 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1250 P_LEFT[1] = mv_table[mot_xy - 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1251 P_LAST_RIGHT[0] = mv_table[mot_xy + 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1252 P_LAST_RIGHT[1] = mv_table[mot_xy + 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1253 P_LAST_BOTTOM[0] = mv_table[mot_xy + mot_stride][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1254 P_LAST_BOTTOM[1] = mv_table[mot_xy + mot_stride][1];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1255
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1256 if(P_LEFT[0] > (rel_xmax<<shift)) P_LEFT[0] = (rel_xmax<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1257 if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1258 if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1259
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1260 /* special case for first line */
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1261 if ((mb_y == 0 || s->first_slice_line)) {
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1262 } else {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1263 P_TOP[0] = mv_table[mot_xy - mot_stride ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1264 P_TOP[1] = mv_table[mot_xy - mot_stride ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1265 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1266 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1267 if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1268 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1269 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1270
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1271 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1272 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1273 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1274 pred_x= P_LEFT[0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1275 pred_y= P_LEFT[1];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1276 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1277 dmin = epzs_motion_search(s, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, ref_picture);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1278
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1279 break;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1280 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1281
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1282 dmin= fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1283 pred_x, pred_y, ref_picture, s->dsp.pix_abs16x16_x2, s->dsp.pix_abs16x16_y2,
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1284 s->dsp.pix_abs16x16_xy2, 0);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1285 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1286 // s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1287 mv_table[mot_xy][0]= mx;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1288 mv_table[mot_xy][1]= my;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1289 return dmin;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1290 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1291
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1292
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1293 static inline int check_bidir_mv(MpegEncContext * s,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1294 int mb_x, int mb_y,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1295 int motion_fx, int motion_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1296 int motion_bx, int motion_by,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1297 int pred_fx, int pred_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1298 int pred_bx, int pred_by)
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1299 {
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1300 //FIXME optimize?
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1301 //FIXME direct mode penalty
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1302 UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1303 uint8_t *dest_y = s->me_scratchpad;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1304 uint8_t *ptr;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1305 int dxy;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1306 int src_x, src_y;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1307 int fbmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1308
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1309 fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*s->qscale;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1310
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1311 dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1312 src_x = mb_x * 16 + (motion_fx >> 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1313 src_y = mb_y * 16 + (motion_fy >> 1);
765
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1314 src_x = clip(src_x, -16, s->width);
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1315 if (src_x == s->width)
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1316 dxy&= 2;
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1317 src_y = clip(src_y, -16, s->height);
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1318 if (src_y == s->height)
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1319 dxy&= 1;
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1320
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1321 ptr = s->last_picture[0] + (src_y * s->linesize) + src_x;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1322 s->dsp.put_pixels_tab[0][dxy](dest_y , ptr , s->linesize, 16);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1323
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1324 fbmin += (mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*s->qscale;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1325
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1326 dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1327 src_x = mb_x * 16 + (motion_bx >> 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1328 src_y = mb_y * 16 + (motion_by >> 1);
765
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1329 src_x = clip(src_x, -16, s->width);
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1330 if (src_x == s->width)
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1331 dxy&= 2;
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1332 src_y = clip(src_y, -16, s->height);
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1333 if (src_y == s->height)
7f0d502a42c5 clip MVs for direct mode
michaelni
parents: 691
diff changeset
1334 dxy&= 1;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1335
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1336 ptr = s->next_picture[0] + (src_y * s->linesize) + src_x;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1337 s->dsp.avg_pixels_tab[0][dxy](dest_y , ptr , s->linesize, 16);
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1338
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1339 fbmin += s->dsp.pix_abs16x16(s->new_picture[0] + mb_x*16 + mb_y*16*s->linesize, dest_y, s->linesize);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1340 return fbmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1341 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1342
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1343 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1344 static inline int bidir_refine(MpegEncContext * s,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1345 int mb_x, int mb_y)
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1346 {
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1347 const int mot_stride = s->mb_width + 2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1348 const int xy = (mb_y + 1)*mot_stride + mb_x + 1;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1349 int fbmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1350 int pred_fx= s->b_bidir_forw_mv_table[xy-1][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1351 int pred_fy= s->b_bidir_forw_mv_table[xy-1][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1352 int pred_bx= s->b_bidir_back_mv_table[xy-1][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1353 int pred_by= s->b_bidir_back_mv_table[xy-1][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1354 int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1355 int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1356 int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1357 int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1358
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1359 //FIXME do refinement and add flag
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1360
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1361 fbmin= check_bidir_mv(s, mb_x, mb_y,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1362 motion_fx, motion_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1363 motion_bx, motion_by,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1364 pred_fx, pred_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1365 pred_bx, pred_by);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1366
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1367 return fbmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1368 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1369
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1370 static inline int direct_search(MpegEncContext * s,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1371 int mb_x, int mb_y)
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1372 {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1373 int P[10][2];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1374 const int mot_stride = s->mb_width + 2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1375 const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1376 int dmin, dmin2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1377 int motion_fx, motion_fy, motion_bx, motion_by, motion_bx0, motion_by0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1378 int motion_dx, motion_dy;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1379 const int motion_px= s->p_mv_table[mot_xy][0];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1380 const int motion_py= s->p_mv_table[mot_xy][1];
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1381 const int time_pp= s->pp_time;
664
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 651
diff changeset
1382 const int time_pb= s->pb_time;
00a882f626bd interlaced mpeg4 b frame decoding
michaelni
parents: 651
diff changeset
1383 const int time_bp= time_pp - time_pb;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1384 int bx, by;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1385 int mx, my, mx2, my2;
587
4d41fe7eb780 b frame direct mode bugfix (bug found by CM <chenm001 at 163 dot com>)
michaelni
parents: 502
diff changeset
1386 uint8_t *ref_picture= s->me_scratchpad - (mb_x - 1 + (mb_y - 1)*s->linesize)*16;
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1387 int16_t (*mv_table)[2]= s->b_direct_mv_table;
620
a5aa53b6e648 warning patch by (Dominik Mierzejewski <dominik at rangers dot eu dot org>)
michaelni
parents: 612
diff changeset
1388 /* uint16_t *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; */ // f_code of the prev frame
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1389
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1390 /* thanks to iso-mpeg the rounding is different for the zero vector, so we need to handle that ... */
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1391 motion_fx= (motion_px*time_pb)/time_pp;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1392 motion_fy= (motion_py*time_pb)/time_pp;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1393 motion_bx0= (-motion_px*time_bp)/time_pp;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1394 motion_by0= (-motion_py*time_bp)/time_pp;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1395 motion_dx= motion_dy=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1396 dmin2= check_bidir_mv(s, mb_x, mb_y,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1397 motion_fx, motion_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1398 motion_bx0, motion_by0,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1399 motion_fx, motion_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1400 motion_bx0, motion_by0) - s->qscale;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1401
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1402 motion_bx= motion_fx - motion_px;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1403 motion_by= motion_fy - motion_py;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1404 for(by=-1; by<2; by++){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1405 for(bx=-1; bx<2; bx++){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1406 uint8_t *dest_y = s->me_scratchpad + (by+1)*s->linesize*16 + (bx+1)*16;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1407 uint8_t *ptr;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1408 int dxy;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1409 int src_x, src_y;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1410 const int width= s->width;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1411 const int height= s->height;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1412
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1413 dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1414 src_x = (mb_x + bx) * 16 + (motion_fx >> 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1415 src_y = (mb_y + by) * 16 + (motion_fy >> 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1416 src_x = clip(src_x, -16, width);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1417 if (src_x == width) dxy &= ~1;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1418 src_y = clip(src_y, -16, height);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1419 if (src_y == height) dxy &= ~2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1420
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1421 ptr = s->last_picture[0] + (src_y * s->linesize) + src_x;
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1422 s->dsp.put_pixels_tab[0][dxy](dest_y , ptr , s->linesize, 16);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1423
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1424 dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1425 src_x = (mb_x + bx) * 16 + (motion_bx >> 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1426 src_y = (mb_y + by) * 16 + (motion_by >> 1);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1427 src_x = clip(src_x, -16, width);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1428 if (src_x == width) dxy &= ~1;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1429 src_y = clip(src_y, -16, height);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1430 if (src_y == height) dxy &= ~2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1431
853
eacc2dd8fd9d * using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents: 847
diff changeset
1432 s->dsp.avg_pixels_tab[0][dxy](dest_y , ptr , s->linesize, 16);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1433 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1434 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1435
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1436 P_LAST[0] = mv_table[mot_xy ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1437 P_LAST[1] = mv_table[mot_xy ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1438 P_LEFT[0] = mv_table[mot_xy - 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1439 P_LEFT[1] = mv_table[mot_xy - 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1440 P_LAST_RIGHT[0] = mv_table[mot_xy + 1][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1441 P_LAST_RIGHT[1] = mv_table[mot_xy + 1][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1442 P_LAST_BOTTOM[0] = mv_table[mot_xy + mot_stride][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1443 P_LAST_BOTTOM[1] = mv_table[mot_xy + mot_stride][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1444 /*
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1445 if(P_LEFT[0] > (rel_xmax<<shift)) P_LEFT[0] = (rel_xmax<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1446 if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1447 if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1448 */
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1449 /* special case for first line */
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1450 if ((mb_y == 0 || s->first_slice_line)) {
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1451 } else {
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1452 P_TOP[0] = mv_table[mot_xy - mot_stride ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1453 P_TOP[1] = mv_table[mot_xy - mot_stride ][1];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1454 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1455 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1];
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1456
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1457 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1458 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1459 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1460 dmin = epzs_motion_search(s, &mx, &my, P, 0, 0, -16, -16, 15, 15, ref_picture);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1461 if(mx==0 && my==0) dmin=99999999; // not representable, due to rounding stuff
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1462 if(dmin2<dmin){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1463 dmin= dmin2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1464 mx=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1465 my=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1466 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1467 #if 1
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1468 mx2= mx= mx*2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1469 my2= my= my*2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1470 for(by=-1; by<2; by++){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1471 if(my2+by < -32) continue;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1472 for(bx=-1; bx<2; bx++){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1473 if(bx==0 && by==0) continue;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1474 if(mx2+bx < -32) continue;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1475 dmin2= check_bidir_mv(s, mb_x, mb_y,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1476 mx2+bx+motion_fx, my2+by+motion_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1477 mx2+bx+motion_bx, my2+by+motion_by,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1478 mx2+bx+motion_fx, my2+by+motion_fy,
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1479 motion_bx, motion_by) - s->qscale;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1480
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1481 if(dmin2<dmin){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1482 dmin=dmin2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1483 mx= mx2 + bx;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1484 my= my2 + by;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1485 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1486 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1487 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1488 #else
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1489 mx*=2; my*=2;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1490 #endif
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1491 if(mx==0 && my==0){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1492 motion_bx= motion_bx0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1493 motion_by= motion_by0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1494 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1495
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1496 s->b_direct_mv_table[mot_xy][0]= mx;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1497 s->b_direct_mv_table[mot_xy][1]= my;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1498 s->b_direct_forw_mv_table[mot_xy][0]= motion_fx + mx;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1499 s->b_direct_forw_mv_table[mot_xy][1]= motion_fy + my;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1500 s->b_direct_back_mv_table[mot_xy][0]= motion_bx + mx;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1501 s->b_direct_back_mv_table[mot_xy][1]= motion_by + my;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1502 return dmin;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1503 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1504
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1505 void ff_estimate_b_frame_motion(MpegEncContext * s,
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1506 int mb_x, int mb_y)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1507 {
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1508 const int quant= s->qscale;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1509 int fmin, bmin, dmin, fbmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1510 int type=0;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1511
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1512 dmin= direct_search(s, mb_x, mb_y);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1513
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1514 fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, s->last_picture[0], s->f_code);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1515 bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, s->next_picture[0], s->b_code) - quant;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1516 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1517
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1518 fbmin= bidir_refine(s, mb_x, mb_y);
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1519
612
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1520 {
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1521 int score= dmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1522 type=MB_TYPE_DIRECT;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1523
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1524 if(fmin<score){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1525 score=fmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1526 type= MB_TYPE_FORWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1527 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1528 if(bmin<score){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1529 score=bmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1530 type= MB_TYPE_BACKWARD;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1531 }
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1532 if(fbmin<score){
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1533 score=fbmin;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1534 type= MB_TYPE_BIDIR;
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1535 }
807
0e1d375c537f fixing q>0.0 assert failure caused by overflow of variance for b frames
michaelni
parents: 765
diff changeset
1536 score= ((unsigned)(score*score + 128*256))>>16;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1537 s->mc_mb_var_sum += score;
612
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1538 s->mc_mb_var[mb_y*s->mb_width + mb_x] = score; //FIXME use SSD
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1539 }
612
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1540
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1541 if(s->flags&CODEC_FLAG_HQ){
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1542 type= MB_TYPE_FORWARD | MB_TYPE_BACKWARD | MB_TYPE_BIDIR | MB_TYPE_DIRECT; //FIXME something smarter
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1543 }
c0005de2be59 new ratecontrol code
michaelni
parents: 608
diff changeset
1544
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1545 /*
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1546 {
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1547 static int count=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1548 static int sum=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1549 if(type==MB_TYPE_DIRECT){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1550 int diff= ABS(s->b_forw_mv_table)
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1551 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1552 }*/
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1553
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1554 s->mb_type[mb_y*s->mb_width + mb_x]= type;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1555 /* if(mb_y==0 && mb_x==0) printf("\n");
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1556 if(mb_x==0) printf("\n");
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1557 printf("%d", av_log2(type));
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1558 */
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1559 }
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1560
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1561 /* find best f_code for ME which do unlimited searches */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1562 int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1563 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1564 if(s->me_method>=ME_EPZS){
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1565 int score[8];
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1566 int i, y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1567 UINT8 * fcode_tab= s->fcode_tab;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1568 int best_fcode=-1;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1569 int best_score=-10000000;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1570
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1571 for(i=0; i<8; i++) score[i]= s->mb_num*(8-i); //FIXME *2 and all other too so its the same but nicer
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1572
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1573 for(y=0; y<s->mb_height; y++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1574 int x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1575 int xy= (y+1)* (s->mb_width+2) + 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1576 i= y*s->mb_width;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1577 for(x=0; x<s->mb_width; x++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1578 if(s->mb_type[i] & type){
847
f3c369b8ddca reversing header game
michaelni
parents: 809
diff changeset
1579 int fcode= FFMAX(fcode_tab[mv_table[xy][0] + MAX_MV],
f3c369b8ddca reversing header game
michaelni
parents: 809
diff changeset
1580 fcode_tab[mv_table[xy][1] + MAX_MV]);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1581 int j;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1582
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1583 for(j=0; j<fcode && j<8; j++){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1584 if(s->pict_type==B_TYPE || s->mc_mb_var[i] < s->mb_var[i])
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1585 score[j]-= 170;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1586 }
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1587 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1588 i++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1589 xy++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1590 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1591 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1592
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1593 for(i=1; i<8; i++){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1594 if(score[i] > best_score){
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1595 best_score= score[i];
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1596 best_fcode= i;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1597 }
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1598 // printf("%d %d\n", i, score[i]);
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1599 }
327
d359db02fc90 much better ME for b frames (a bit slow though)
michaelni
parents: 324
diff changeset
1600
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1601 // printf("fcode: %d type: %d\n", i, s->pict_type);
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1602 return best_fcode;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1603 /* for(i=0; i<=MAX_FCODE; i++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1604 printf("%d ", mv_num[i]);
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1605 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1606 printf("\n");*/
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1607 }else{
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1608 return 1;
0
986e461dc072 Initial revision
glantau
parents:
diff changeset
1609 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1610 }
986e461dc072 Initial revision
glantau
parents:
diff changeset
1611
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1612 void ff_fix_long_p_mvs(MpegEncContext * s)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1613 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1614 const int f_code= s->f_code;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1615 int y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1616 UINT8 * fcode_tab= s->fcode_tab;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1617 //int clip=0;
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1618 //int noclip=0;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1619 /* clip / convert to intra 16x16 type MVs */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1620 for(y=0; y<s->mb_height; y++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1621 int x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1622 int xy= (y+1)* (s->mb_width+2)+1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1623 int i= y*s->mb_width;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1624 for(x=0; x<s->mb_width; x++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1625 if(s->mb_type[i]&MB_TYPE_INTER){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1626 if( fcode_tab[s->p_mv_table[xy][0] + MAX_MV] > f_code
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1627 || fcode_tab[s->p_mv_table[xy][0] + MAX_MV] == 0
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1628 || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] > f_code
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1629 || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] == 0 ){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1630 s->mb_type[i] &= ~MB_TYPE_INTER;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1631 s->mb_type[i] |= MB_TYPE_INTRA;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1632 s->p_mv_table[xy][0] = 0;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1633 s->p_mv_table[xy][1] = 0;
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1634 //clip++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1635 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1636 //else
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1637 // noclip++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1638 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1639 xy++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1640 i++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1641 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1642 }
455
7f2d2be2aee9 dont double check vectors
michaelni
parents: 429
diff changeset
1643 //printf("%d no:%d %d//\n", clip, noclip, f_code);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1644 if(s->flags&CODEC_FLAG_4MV){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1645 const int wrap= 2+ s->mb_width*2;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1646
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1647 /* clip / convert to intra 8x8 type MVs */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1648 for(y=0; y<s->mb_height; y++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1649 int xy= (y*2 + 1)*wrap + 1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1650 int i= y*s->mb_width;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1651 int x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1652
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1653 for(x=0; x<s->mb_width; x++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1654 if(s->mb_type[i]&MB_TYPE_INTER4V){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1655 int block;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1656 for(block=0; block<4; block++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1657 int off= (block& 1) + (block>>1)*wrap;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1658 int mx= s->motion_val[ xy + off ][0];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1659 int my= s->motion_val[ xy + off ][1];
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1660
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1661 if( fcode_tab[mx + MAX_MV] > f_code
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1662 || fcode_tab[mx + MAX_MV] == 0
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1663 || fcode_tab[my + MAX_MV] > f_code
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1664 || fcode_tab[my + MAX_MV] == 0 ){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1665 s->mb_type[i] &= ~MB_TYPE_INTER4V;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1666 s->mb_type[i] |= MB_TYPE_INTRA;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1667 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1668 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1669 }
502
f74798aca30e 4mv bugfix
michaelni
parents: 455
diff changeset
1670 xy+=2;
f74798aca30e 4mv bugfix
michaelni
parents: 455
diff changeset
1671 i++;
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1672 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1673 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1674 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1675 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1676
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1677 void ff_fix_long_b_mvs(MpegEncContext * s, int16_t (*mv_table)[2], int f_code, int type)
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1678 {
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1679 int y;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1680 UINT8 * fcode_tab= s->fcode_tab;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1681
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1682 /* clip / convert to intra 16x16 type MVs */
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1683 for(y=0; y<s->mb_height; y++){
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1684 int x;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1685 int xy= (y+1)* (s->mb_width+2)+1;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1686 int i= y*s->mb_width;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1687 for(x=0; x<s->mb_width; x++){
691
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1688 if( fcode_tab[mv_table[xy][0] + MAX_MV] > f_code
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1689 || fcode_tab[mv_table[xy][0] + MAX_MV] == 0){
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1690 if(mv_table[xy][0]>0) mv_table[xy][0]= (16<<f_code)-1;
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1691 else mv_table[xy][0]= -(16<<f_code);
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1692 }
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1693 if( fcode_tab[mv_table[xy][1] + MAX_MV] > f_code
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1694 || fcode_tab[mv_table[xy][1] + MAX_MV] == 0){
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1695 if(mv_table[xy][1]>0) mv_table[xy][1]= (16<<f_code)-1;
199b324b2693 fixing variance scaling for b frames (messed adaptive quants up)
michaelni
parents: 690
diff changeset
1696 else mv_table[xy][1]= -(16<<f_code);
324
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1697 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1698 xy++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1699 i++;
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1700 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1701 }
9c6f056f0e41 fixed mpeg4 time stuff on encoding
michaelni
parents: 320
diff changeset
1702 }