Mercurial > libavcodec.hg
annotate motion_est.c @ 2809:75400dfbe117 libavcodec
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
untested (none of the conformance streams laying around on my disk seems affected by this change)
author | michael |
---|---|
date | Wed, 27 Jul 2005 00:15:55 +0000 |
parents | 2b37bcabe608 |
children | edc4fccb3bec |
rev | line source |
---|---|
0 | 1 /* |
2 * Motion estimation | |
429 | 3 * Copyright (c) 2000,2001 Fabrice Bellard. |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1729
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer |
0 | 5 * |
6 * | |
429 | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2 of the License, or (at your option) any later version. | |
0 | 11 * |
429 | 12 * This library is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
18 * License along with this library; if not, write to the Free Software | |
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 | 22 */ |
1106 | 23 |
24 /** | |
25 * @file motion_est.c | |
26 * Motion estimation. | |
27 */ | |
28 | |
0 | 29 #include <stdlib.h> |
30 #include <stdio.h> | |
1426 | 31 #include <limits.h> |
0 | 32 #include "avcodec.h" |
33 #include "dsputil.h" | |
34 #include "mpegvideo.h" | |
35 | |
1950 | 36 #undef NDEBUG |
37 #include <assert.h> | |
936 | 38 |
455 | 39 #define SQ(a) ((a)*(a)) |
284 | 40 |
455 | 41 #define P_LEFT P[1] |
42 #define P_TOP P[2] | |
43 #define P_TOPRIGHT P[3] | |
44 #define P_MEDIAN P[4] | |
45 #define P_MV1 P[9] | |
46 | |
936 | 47 static inline int sad_hpel_motion_search(MpegEncContext * s, |
48 int *mx_ptr, int *my_ptr, int dmin, | |
1950 | 49 int src_index, int ref_index, |
50 int size, int h); | |
0 | 51 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
52 static inline int update_map_generation(MotionEstContext *c) |
936 | 53 { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
54 c->map_generation+= 1<<(ME_MAP_MV_BITS*2); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
55 if(c->map_generation==0){ |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
56 c->map_generation= 1<<(ME_MAP_MV_BITS*2); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
57 memset(c->map, 0, sizeof(uint32_t)*ME_MAP_SIZE); |
936 | 58 } |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
59 return c->map_generation; |
936 | 60 } |
61 | |
948 | 62 /* shape adaptive search stuff */ |
63 typedef struct Minima{ | |
64 int height; | |
65 int x, y; | |
66 int checked; | |
67 }Minima; | |
936 | 68 |
948 | 69 static int minima_cmp(const void *a, const void *b){ |
1057 | 70 const Minima *da = (const Minima *) a; |
71 const Minima *db = (const Minima *) b; | |
948 | 72 |
73 return da->height - db->height; | |
74 } | |
1950 | 75 |
76 #define FLAG_QPEL 1 //must be 1 | |
77 #define FLAG_CHROMA 2 | |
78 #define FLAG_DIRECT 4 | |
936 | 79 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
80 static inline void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index){ |
1950 | 81 const int offset[3]= { |
82 y*c-> stride + x, | |
83 ((y*c->uvstride + x)>>1), | |
84 ((y*c->uvstride + x)>>1), | |
85 }; | |
86 int i; | |
87 for(i=0; i<3; i++){ | |
88 c->src[0][i]= src [i] + offset[i]; | |
89 c->ref[0][i]= ref [i] + offset[i]; | |
90 } | |
91 if(ref_index){ | |
92 for(i=0; i<3; i++){ | |
93 c->ref[ref_index][i]= ref2[i] + offset[i]; | |
94 } | |
95 } | |
936 | 96 } |
97 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
98 static int get_flags(MotionEstContext *c, int direct, int chroma){ |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
99 return ((c->avctx->flags&CODEC_FLAG_QPEL) ? FLAG_QPEL : 0) |
1950 | 100 + (direct ? FLAG_DIRECT : 0) |
101 + (chroma ? FLAG_CHROMA : 0); | |
102 } | |
1708 | 103 |
1950 | 104 static always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, |
105 const int size, const int h, int ref_index, int src_index, | |
106 me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){ | |
107 MotionEstContext * const c= &s->me; | |
108 const int stride= c->stride; | |
109 const int uvstride= c->uvstride; | |
110 const int qpel= flags&FLAG_QPEL; | |
111 const int chroma= flags&FLAG_CHROMA; | |
112 const int dxy= subx + (suby<<(1+qpel)); //FIXME log2_subpel? | |
113 const int hx= subx + (x<<(1+qpel)); | |
114 const int hy= suby + (y<<(1+qpel)); | |
115 uint8_t * const * const ref= c->ref[ref_index]; | |
116 uint8_t * const * const src= c->src[src_index]; | |
117 int d; | |
118 //FIXME check chroma 4mv, (no crashes ...) | |
119 if(flags&FLAG_DIRECT){ | |
120 if(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1)){ | |
121 const int time_pp= s->pp_time; | |
122 const int time_pb= s->pb_time; | |
123 const int mask= 2*qpel+1; | |
124 if(s->mv_type==MV_TYPE_8X8){ | |
125 int i; | |
126 for(i=0; i<4; i++){ | |
127 int fx = c->direct_basis_mv[i][0] + hx; | |
128 int fy = c->direct_basis_mv[i][1] + hy; | |
129 int bx = hx ? fx - c->co_located_mv[i][0] : c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(qpel+4)); | |
130 int by = hy ? fy - c->co_located_mv[i][1] : c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(qpel+4)); | |
131 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1)); | |
132 int bxy= (bx&mask) + ((by&mask)<<(qpel+1)); | |
133 | |
134 uint8_t *dst= c->temp + 8*(i&1) + 8*stride*(i>>1); | |
135 if(qpel){ | |
136 c->qpel_put[1][fxy](dst, ref[0] + (fx>>2) + (fy>>2)*stride, stride); | |
137 c->qpel_avg[1][bxy](dst, ref[8] + (bx>>2) + (by>>2)*stride, stride); | |
138 }else{ | |
139 c->hpel_put[1][fxy](dst, ref[0] + (fx>>1) + (fy>>1)*stride, stride, 8); | |
140 c->hpel_avg[1][bxy](dst, ref[8] + (bx>>1) + (by>>1)*stride, stride, 8); | |
141 } | |
142 } | |
143 }else{ | |
144 int fx = c->direct_basis_mv[0][0] + hx; | |
145 int fy = c->direct_basis_mv[0][1] + hy; | |
146 int bx = hx ? fx - c->co_located_mv[0][0] : (c->co_located_mv[0][0]*(time_pb - time_pp)/time_pp); | |
147 int by = hy ? fy - c->co_located_mv[0][1] : (c->co_located_mv[0][1]*(time_pb - time_pp)/time_pp); | |
148 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1)); | |
149 int bxy= (bx&mask) + ((by&mask)<<(qpel+1)); | |
150 | |
151 if(qpel){ | |
152 c->qpel_put[1][fxy](c->temp , ref[0] + (fx>>2) + (fy>>2)*stride , stride); | |
153 c->qpel_put[1][fxy](c->temp + 8 , ref[0] + (fx>>2) + (fy>>2)*stride + 8 , stride); | |
154 c->qpel_put[1][fxy](c->temp + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8*stride, stride); | |
155 c->qpel_put[1][fxy](c->temp + 8 + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8 + 8*stride, stride); | |
156 c->qpel_avg[1][bxy](c->temp , ref[8] + (bx>>2) + (by>>2)*stride , stride); | |
157 c->qpel_avg[1][bxy](c->temp + 8 , ref[8] + (bx>>2) + (by>>2)*stride + 8 , stride); | |
158 c->qpel_avg[1][bxy](c->temp + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8*stride, stride); | |
159 c->qpel_avg[1][bxy](c->temp + 8 + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8 + 8*stride, stride); | |
160 }else{ | |
161 assert((fx>>1) + 16*s->mb_x >= -16); | |
162 assert((fy>>1) + 16*s->mb_y >= -16); | |
163 assert((fx>>1) + 16*s->mb_x <= s->width); | |
164 assert((fy>>1) + 16*s->mb_y <= s->height); | |
165 assert((bx>>1) + 16*s->mb_x >= -16); | |
166 assert((by>>1) + 16*s->mb_y >= -16); | |
167 assert((bx>>1) + 16*s->mb_x <= s->width); | |
168 assert((by>>1) + 16*s->mb_y <= s->height); | |
936 | 169 |
1950 | 170 c->hpel_put[0][fxy](c->temp, ref[0] + (fx>>1) + (fy>>1)*stride, stride, 16); |
171 c->hpel_avg[0][bxy](c->temp, ref[8] + (bx>>1) + (by>>1)*stride, stride, 16); | |
172 } | |
173 } | |
174 d = cmp_func(s, c->temp, src[0], stride, 16); | |
175 }else | |
176 d= 256*256*256*32; | |
177 }else{ | |
178 int uvdxy; | |
179 if(dxy){ | |
180 if(qpel){ | |
181 c->qpel_put[size][dxy](c->temp, ref[0] + x + y*stride, stride); //FIXME prototype (add h) | |
182 if(chroma){ | |
183 int cx= hx/2; | |
184 int cy= hy/2; | |
185 cx= (cx>>1)|(cx&1); | |
186 cy= (cy>>1)|(cy&1); | |
187 uvdxy= (cx&1) + 2*(cy&1); | |
188 //FIXME x/y wrong, but mpeg4 qpel is sick anyway, we should drop as much of it as possible in favor for h264 | |
189 } | |
190 }else{ | |
191 c->hpel_put[size][dxy](c->temp, ref[0] + x + y*stride, stride, h); | |
192 if(chroma) | |
193 uvdxy= dxy | (x&1) | (2*(y&1)); | |
194 } | |
195 d = cmp_func(s, c->temp, src[0], stride, h); | |
196 }else{ | |
197 d = cmp_func(s, src[0], ref[0] + x + y*stride, stride, h); | |
198 if(chroma) | |
199 uvdxy= (x&1) + 2*(y&1); | |
200 } | |
201 if(chroma){ | |
202 uint8_t * const uvtemp= c->temp + 16*stride; | |
203 c->hpel_put[size+1][uvdxy](uvtemp , ref[1] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1); | |
204 c->hpel_put[size+1][uvdxy](uvtemp+8, ref[2] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1); | |
205 d += chroma_cmp_func(s, uvtemp , src[1], uvstride, h>>1); | |
206 d += chroma_cmp_func(s, uvtemp+8, src[2], uvstride, h>>1); | |
207 } | |
208 } | |
209 #if 0 | |
210 if(full_pel){ | |
211 const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1); | |
212 score_map[index]= d; | |
213 } | |
936 | 214 |
1950 | 215 d += (c->mv_penalty[hx - c->pred_x] + c->mv_penalty[hy - c->pred_y])*c->penalty_factor; |
216 #endif | |
217 return d; | |
936 | 218 } |
219 | |
220 #include "motion_est_template.c" | |
221 | |
2075 | 222 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){ |
223 return 0; | |
224 } | |
225 | |
226 static void zero_hpel(uint8_t *a, const uint8_t *b, int stride, int h){ | |
227 } | |
228 | |
936 | 229 void ff_init_me(MpegEncContext *s){ |
1962 | 230 MotionEstContext * const c= &s->me; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
231 c->avctx= s->avctx; |
1962 | 232 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
233 ff_set_cmp(&s->dsp, s->dsp.me_pre_cmp, c->avctx->me_pre_cmp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
234 ff_set_cmp(&s->dsp, s->dsp.me_cmp, c->avctx->me_cmp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
235 ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, c->avctx->me_sub_cmp); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
236 ff_set_cmp(&s->dsp, s->dsp.mb_cmp, c->avctx->mb_cmp); |
1950 | 237 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
238 c->flags = get_flags(c, 0, c->avctx->me_cmp &FF_CMP_CHROMA); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
239 c->sub_flags= get_flags(c, 0, c->avctx->me_sub_cmp&FF_CMP_CHROMA); |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
240 c->mb_flags = get_flags(c, 0, c->avctx->mb_cmp &FF_CMP_CHROMA); |
936 | 241 |
1962 | 242 /*FIXME s->no_rounding b_type*/ |
936 | 243 if(s->flags&CODEC_FLAG_QPEL){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
244 c->sub_motion_search= qpel_motion_search; |
1962 | 245 c->qpel_avg= s->dsp.avg_qpel_pixels_tab; |
246 if(s->no_rounding) c->qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab; | |
247 else c->qpel_put= s->dsp.put_qpel_pixels_tab; | |
936 | 248 }else{ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
249 if(c->avctx->me_sub_cmp&FF_CMP_CHROMA) |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
250 c->sub_motion_search= hpel_motion_search; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
251 else if( c->avctx->me_sub_cmp == FF_CMP_SAD |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
252 && c->avctx-> me_cmp == FF_CMP_SAD |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
253 && c->avctx-> mb_cmp == FF_CMP_SAD) |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
254 c->sub_motion_search= sad_hpel_motion_search; // 2050 vs. 2450 cycles |
936 | 255 else |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
256 c->sub_motion_search= hpel_motion_search; |
936 | 257 } |
2075 | 258 c->hpel_avg= s->dsp.avg_pixels_tab; |
259 if(s->no_rounding) c->hpel_put= s->dsp.put_no_rnd_pixels_tab; | |
260 else c->hpel_put= s->dsp.put_pixels_tab; | |
261 | |
1950 | 262 if(s->linesize){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
263 c->stride = s->linesize; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
264 c->uvstride= s->uvlinesize; |
954 | 265 }else{ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
266 c->stride = 16*s->mb_width + 32; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
267 c->uvstride= 8*s->mb_width + 16; |
1013 | 268 } |
1962 | 269 |
2075 | 270 // 8x8 fullpel search would need a 4x4 chroma compare, which we dont have yet, and even if we had the motion estimation code doesnt expect it |
2189
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
271 if(s->codec_id != CODEC_ID_SNOW){ |
2643
8e42a0463f68
fix segfault with 'ffmpeg -i 1.avi -cmp 257 -4mv 2.avi'
michael
parents:
2628
diff
changeset
|
272 if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){ |
2189
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
273 s->dsp.me_cmp[2]= zero_cmp; |
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
274 } |
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
275 if((c->avctx->me_sub_cmp&FF_CMP_CHROMA) && !s->dsp.me_sub_cmp[2]){ |
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
276 s->dsp.me_sub_cmp[2]= zero_cmp; |
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
277 } |
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
278 c->hpel_put[2][0]= c->hpel_put[2][1]= |
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
279 c->hpel_put[2][2]= c->hpel_put[2][3]= zero_hpel; |
2075 | 280 } |
281 | |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
282 if(s->codec_id == CODEC_ID_H261){ |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
283 c->sub_motion_search= no_sub_motion_search; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
284 } |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
285 |
1962 | 286 c->temp= c->scratchpad; |
936 | 287 } |
288 | |
1419 | 289 #if 0 |
1064 | 290 static int pix_dev(uint8_t * pix, int line_size, int mean) |
284 | 291 { |
292 int s, i, j; | |
293 | |
294 s = 0; | |
295 for (i = 0; i < 16; i++) { | |
296 for (j = 0; j < 16; j += 8) { | |
297 s += ABS(pix[0]-mean); | |
298 s += ABS(pix[1]-mean); | |
299 s += ABS(pix[2]-mean); | |
300 s += ABS(pix[3]-mean); | |
301 s += ABS(pix[4]-mean); | |
302 s += ABS(pix[5]-mean); | |
303 s += ABS(pix[6]-mean); | |
304 s += ABS(pix[7]-mean); | |
305 pix += 8; | |
306 } | |
307 pix += line_size - 16; | |
308 } | |
309 return s; | |
310 } | |
1419 | 311 #endif |
284 | 312 |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
313 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
|
314 int *mx_ptr, int *my_ptr) |
0 | 315 { |
316 *mx_ptr = 16 * s->mb_x; | |
317 *my_ptr = 16 * s->mb_y; | |
318 } | |
319 | |
2522
e25782262d7d
kill warnings patch by (M¸«©ns Rullg¸«©rd <mru inprovide com>)
michael
parents:
2354
diff
changeset
|
320 #if 0 /* the use of these functions is inside #if 0 */ |
0 | 321 static int full_motion_search(MpegEncContext * s, |
322 int *mx_ptr, int *my_ptr, int range, | |
324 | 323 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture) |
0 | 324 { |
325 int x1, y1, x2, y2, xx, yy, x, y; | |
326 int mx, my, dmin, d; | |
1064 | 327 uint8_t *pix; |
0 | 328 |
329 xx = 16 * s->mb_x; | |
330 yy = 16 * s->mb_y; | |
331 x1 = xx - range + 1; /* we loose one pixel to avoid boundary pb with half pixel pred */ | |
332 if (x1 < xmin) | |
333 x1 = xmin; | |
334 x2 = xx + range - 1; | |
335 if (x2 > xmax) | |
336 x2 = xmax; | |
337 y1 = yy - range + 1; | |
338 if (y1 < ymin) | |
339 y1 = ymin; | |
340 y2 = yy + range - 1; | |
341 if (y2 > ymax) | |
342 y2 = ymax; | |
903 | 343 pix = s->new_picture.data[0] + (yy * s->linesize) + xx; |
0 | 344 dmin = 0x7fffffff; |
345 mx = 0; | |
346 my = 0; | |
347 for (y = y1; y <= y2; y++) { | |
348 for (x = x1; x <= x2; x++) { | |
1708 | 349 d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, |
350 s->linesize, 16); | |
0 | 351 if (d < dmin || |
352 (d == dmin && | |
353 (abs(x - xx) + abs(y - yy)) < | |
354 (abs(mx - xx) + abs(my - yy)))) { | |
355 dmin = d; | |
356 mx = x; | |
357 my = y; | |
358 } | |
359 } | |
360 } | |
361 | |
362 *mx_ptr = mx; | |
363 *my_ptr = my; | |
364 | |
365 #if 0 | |
366 if (*mx_ptr < -(2 * range) || *mx_ptr >= (2 * range) || | |
367 *my_ptr < -(2 * range) || *my_ptr >= (2 * range)) { | |
368 fprintf(stderr, "error %d %d\n", *mx_ptr, *my_ptr); | |
369 } | |
370 #endif | |
371 return dmin; | |
372 } | |
373 | |
374 | |
375 static int log_motion_search(MpegEncContext * s, | |
376 int *mx_ptr, int *my_ptr, int range, | |
324 | 377 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture) |
0 | 378 { |
379 int x1, y1, x2, y2, xx, yy, x, y; | |
380 int mx, my, dmin, d; | |
1064 | 381 uint8_t *pix; |
0 | 382 |
383 xx = s->mb_x << 4; | |
384 yy = s->mb_y << 4; | |
385 | |
386 /* Left limit */ | |
387 x1 = xx - range; | |
388 if (x1 < xmin) | |
389 x1 = xmin; | |
390 | |
391 /* Right limit */ | |
392 x2 = xx + range; | |
393 if (x2 > xmax) | |
394 x2 = xmax; | |
395 | |
396 /* Upper limit */ | |
397 y1 = yy - range; | |
398 if (y1 < ymin) | |
399 y1 = ymin; | |
400 | |
401 /* Lower limit */ | |
402 y2 = yy + range; | |
403 if (y2 > ymax) | |
404 y2 = ymax; | |
405 | |
903 | 406 pix = s->new_picture.data[0] + (yy * s->linesize) + xx; |
0 | 407 dmin = 0x7fffffff; |
408 mx = 0; | |
409 my = 0; | |
410 | |
411 do { | |
412 for (y = y1; y <= y2; y += range) { | |
413 for (x = x1; x <= x2; x += range) { | |
1708 | 414 d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, s->linesize, 16); |
0 | 415 if (d < dmin || (d == dmin && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) { |
416 dmin = d; | |
417 mx = x; | |
418 my = y; | |
419 } | |
420 } | |
421 } | |
422 | |
423 range = range >> 1; | |
424 | |
425 x1 = mx - range; | |
426 if (x1 < xmin) | |
427 x1 = xmin; | |
428 | |
429 x2 = mx + range; | |
430 if (x2 > xmax) | |
431 x2 = xmax; | |
432 | |
433 y1 = my - range; | |
434 if (y1 < ymin) | |
435 y1 = ymin; | |
436 | |
437 y2 = my + range; | |
438 if (y2 > ymax) | |
439 y2 = ymax; | |
440 | |
441 } while (range >= 1); | |
442 | |
443 #ifdef DEBUG | |
444 fprintf(stderr, "log - MX: %d\tMY: %d\n", mx, my); | |
445 #endif | |
446 *mx_ptr = mx; | |
447 *my_ptr = my; | |
448 return dmin; | |
449 } | |
450 | |
451 static int phods_motion_search(MpegEncContext * s, | |
452 int *mx_ptr, int *my_ptr, int range, | |
324 | 453 int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture) |
0 | 454 { |
455 int x1, y1, x2, y2, xx, yy, x, y, lastx, d; | |
456 int mx, my, dminx, dminy; | |
1064 | 457 uint8_t *pix; |
0 | 458 |
459 xx = s->mb_x << 4; | |
460 yy = s->mb_y << 4; | |
461 | |
462 /* Left limit */ | |
463 x1 = xx - range; | |
464 if (x1 < xmin) | |
465 x1 = xmin; | |
466 | |
467 /* Right limit */ | |
468 x2 = xx + range; | |
469 if (x2 > xmax) | |
470 x2 = xmax; | |
471 | |
472 /* Upper limit */ | |
473 y1 = yy - range; | |
474 if (y1 < ymin) | |
475 y1 = ymin; | |
476 | |
477 /* Lower limit */ | |
478 y2 = yy + range; | |
479 if (y2 > ymax) | |
480 y2 = ymax; | |
481 | |
903 | 482 pix = s->new_picture.data[0] + (yy * s->linesize) + xx; |
0 | 483 mx = 0; |
484 my = 0; | |
485 | |
486 x = xx; | |
487 y = yy; | |
488 do { | |
489 dminx = 0x7fffffff; | |
490 dminy = 0x7fffffff; | |
491 | |
492 lastx = x; | |
493 for (x = x1; x <= x2; x += range) { | |
1708 | 494 d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, s->linesize, 16); |
0 | 495 if (d < dminx || (d == dminx && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) { |
496 dminx = d; | |
497 mx = x; | |
498 } | |
499 } | |
500 | |
501 x = lastx; | |
502 for (y = y1; y <= y2; y += range) { | |
1708 | 503 d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, s->linesize, 16); |
0 | 504 if (d < dminy || (d == dminy && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) { |
505 dminy = d; | |
506 my = y; | |
507 } | |
508 } | |
509 | |
510 range = range >> 1; | |
511 | |
512 x = mx; | |
513 y = my; | |
514 x1 = mx - range; | |
515 if (x1 < xmin) | |
516 x1 = xmin; | |
517 | |
518 x2 = mx + range; | |
519 if (x2 > xmax) | |
520 x2 = xmax; | |
521 | |
522 y1 = my - range; | |
523 if (y1 < ymin) | |
524 y1 = ymin; | |
525 | |
526 y2 = my + range; | |
527 if (y2 > ymax) | |
528 y2 = ymax; | |
529 | |
530 } while (range >= 1); | |
531 | |
532 #ifdef DEBUG | |
533 fprintf(stderr, "phods - MX: %d\tMY: %d\n", mx, my); | |
534 #endif | |
535 | |
536 /* half pixel search */ | |
537 *mx_ptr = mx; | |
538 *my_ptr = my; | |
539 return dminy; | |
540 } | |
2522
e25782262d7d
kill warnings patch by (M¸«©ns Rullg¸«©rd <mru inprovide com>)
michael
parents:
2354
diff
changeset
|
541 #endif /* 0 */ |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
275
diff
changeset
|
542 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
275
diff
changeset
|
543 #define Z_THRESHOLD 256 |
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
275
diff
changeset
|
544 |
936 | 545 #define CHECK_SAD_HALF_MV(suffix, x, y) \ |
455 | 546 {\ |
1708 | 547 d= s->dsp.pix_abs[size][(x?1:0)+(y?2:0)](NULL, pix, ptr+((x)>>1), stride, h);\ |
936 | 548 d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\ |
455 | 549 COPY3_IF_LT(dminh, d, dx, x, dy, y)\ |
550 } | |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
275
diff
changeset
|
551 |
936 | 552 static inline int sad_hpel_motion_search(MpegEncContext * s, |
0 | 553 int *mx_ptr, int *my_ptr, int dmin, |
1950 | 554 int src_index, int ref_index, |
555 int size, int h) | |
0 | 556 { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
557 MotionEstContext * const c= &s->me; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
558 const int penalty_factor= c->sub_penalty_factor; |
1708 | 559 int mx, my, dminh; |
1064 | 560 uint8_t *pix, *ptr; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
561 int stride= c->stride; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
562 const int flags= c->sub_flags; |
1950 | 563 LOAD_COMMON |
564 | |
565 assert(flags == 0); | |
455 | 566 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
567 if(c->skip){ |
455 | 568 // printf("S"); |
569 *mx_ptr = 0; | |
570 *my_ptr = 0; | |
571 return dmin; | |
572 } | |
573 // printf("N"); | |
574 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
575 pix = c->src[src_index][0]; |
455 | 576 |
294 | 577 mx = *mx_ptr; |
578 my = *my_ptr; | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
579 ptr = c->ref[ref_index][0] + (my * stride) + mx; |
455 | 580 |
294 | 581 dminh = dmin; |
582 | |
583 if (mx > xmin && mx < xmax && | |
584 my > ymin && my < ymax) { | |
455 | 585 int dx=0, dy=0; |
586 int d, pen_x, pen_y; | |
587 const int index= (my<<ME_MAP_SHIFT) + mx; | |
588 const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]; | |
589 const int l= score_map[(index- 1 )&(ME_MAP_SIZE-1)]; | |
590 const int r= score_map[(index+ 1 )&(ME_MAP_SIZE-1)]; | |
591 const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)]; | |
592 mx<<=1; | |
593 my<<=1; | |
294 | 594 |
595 | |
596 pen_x= pred_x + mx; | |
597 pen_y= pred_y + my; | |
598 | |
1708 | 599 ptr-= stride; |
455 | 600 if(t<=b){ |
936 | 601 CHECK_SAD_HALF_MV(y2 , 0, -1) |
455 | 602 if(l<=r){ |
936 | 603 CHECK_SAD_HALF_MV(xy2, -1, -1) |
455 | 604 if(t+r<=b+l){ |
936 | 605 CHECK_SAD_HALF_MV(xy2, +1, -1) |
1708 | 606 ptr+= stride; |
455 | 607 }else{ |
1708 | 608 ptr+= stride; |
936 | 609 CHECK_SAD_HALF_MV(xy2, -1, +1) |
455 | 610 } |
936 | 611 CHECK_SAD_HALF_MV(x2 , -1, 0) |
455 | 612 }else{ |
936 | 613 CHECK_SAD_HALF_MV(xy2, +1, -1) |
455 | 614 if(t+l<=b+r){ |
936 | 615 CHECK_SAD_HALF_MV(xy2, -1, -1) |
1708 | 616 ptr+= stride; |
455 | 617 }else{ |
1708 | 618 ptr+= stride; |
936 | 619 CHECK_SAD_HALF_MV(xy2, +1, +1) |
455 | 620 } |
936 | 621 CHECK_SAD_HALF_MV(x2 , +1, 0) |
455 | 622 } |
623 }else{ | |
624 if(l<=r){ | |
625 if(t+l<=b+r){ | |
936 | 626 CHECK_SAD_HALF_MV(xy2, -1, -1) |
1708 | 627 ptr+= stride; |
455 | 628 }else{ |
1708 | 629 ptr+= stride; |
936 | 630 CHECK_SAD_HALF_MV(xy2, +1, +1) |
455 | 631 } |
936 | 632 CHECK_SAD_HALF_MV(x2 , -1, 0) |
633 CHECK_SAD_HALF_MV(xy2, -1, +1) | |
455 | 634 }else{ |
635 if(t+r<=b+l){ | |
936 | 636 CHECK_SAD_HALF_MV(xy2, +1, -1) |
1708 | 637 ptr+= stride; |
455 | 638 }else{ |
1708 | 639 ptr+= stride; |
936 | 640 CHECK_SAD_HALF_MV(xy2, -1, +1) |
455 | 641 } |
936 | 642 CHECK_SAD_HALF_MV(x2 , +1, 0) |
643 CHECK_SAD_HALF_MV(xy2, +1, +1) | |
455 | 644 } |
936 | 645 CHECK_SAD_HALF_MV(y2 , 0, +1) |
455 | 646 } |
647 mx+=dx; | |
648 my+=dy; | |
294 | 649 |
650 }else{ | |
455 | 651 mx<<=1; |
652 my<<=1; | |
294 | 653 } |
654 | |
655 *mx_ptr = mx; | |
656 *my_ptr = my; | |
455 | 657 return dminh; |
294 | 658 } |
659 | |
455 | 660 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4) |
294 | 661 { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
662 const int xy= s->mb_x + s->mb_y*s->mb_stride; |
294 | 663 |
324 | 664 s->p_mv_table[xy][0] = mx; |
665 s->p_mv_table[xy][1] = my; | |
294 | 666 |
2764 | 667 /* has already been set to the 4 MV if 4MV is done */ |
455 | 668 if(mv4){ |
294 | 669 int mot_xy= s->block_index[0]; |
670 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
671 s->current_picture.motion_val[0][mot_xy ][0]= mx; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
672 s->current_picture.motion_val[0][mot_xy ][1]= my; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
673 s->current_picture.motion_val[0][mot_xy+1][0]= mx; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
674 s->current_picture.motion_val[0][mot_xy+1][1]= my; |
294 | 675 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1904
diff
changeset
|
676 mot_xy += s->b8_stride; |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
677 s->current_picture.motion_val[0][mot_xy ][0]= mx; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
678 s->current_picture.motion_val[0][mot_xy ][1]= my; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
679 s->current_picture.motion_val[0][mot_xy+1][0]= mx; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
680 s->current_picture.motion_val[0][mot_xy+1][1]= my; |
294 | 681 } |
682 } | |
683 | |
1086 | 684 /** |
685 * get fullpel ME search limits. | |
686 */ | |
1708 | 687 static inline void get_limits(MpegEncContext *s, int x, int y) |
324 | 688 { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
689 MotionEstContext * const c= &s->me; |
1708 | 690 /* |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
691 if(c->avctx->me_range) c->range= c->avctx->me_range >> 1; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
692 else c->range= 16; |
1708 | 693 */ |
324 | 694 if (s->unrestricted_mv) { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
695 c->xmin = - x - 16; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
696 c->ymin = - y - 16; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
697 c->xmax = - x + s->mb_width *16; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
698 c->ymax = - y + s->mb_height*16; |
2327
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
699 } else if (s->out_format == FMT_H261){ |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
700 // Search range of H261 is different from other codec standards |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
701 c->xmin = (x > 15) ? - 15 : 0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
702 c->ymin = (y > 15) ? - 15 : 0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
703 c->xmax = (x < s->mb_width * 16 - 16) ? 15 : 0; |
5e5cf598a48b
H.261 encoder by (Maarten Daniels <maarten dot daniels at luc dot ac dot be>)
michael
parents:
2302
diff
changeset
|
704 c->ymax = (y < s->mb_height * 16 - 16) ? 15 : 0; |
324 | 705 } else { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
706 c->xmin = - x; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
707 c->ymin = - y; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
708 c->xmax = - x + s->mb_width *16 - 16; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
709 c->ymax = - y + s->mb_height*16 - 16; |
324 | 710 } |
711 } | |
712 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
713 static inline void init_mv4_ref(MotionEstContext *c){ |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
714 const int stride= c->stride; |
1962 | 715 |
716 c->ref[1][0] = c->ref[0][0] + 8; | |
717 c->ref[2][0] = c->ref[0][0] + 8*stride; | |
718 c->ref[3][0] = c->ref[2][0] + 8; | |
719 c->src[1][0] = c->src[0][0] + 8; | |
720 c->src[2][0] = c->src[0][0] + 8*stride; | |
721 c->src[3][0] = c->src[2][0] + 8; | |
722 } | |
723 | |
1708 | 724 static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift) |
455 | 725 { |
1950 | 726 MotionEstContext * const c= &s->me; |
1708 | 727 const int size= 1; |
728 const int h=8; | |
455 | 729 int block; |
730 int P[10][2]; | |
1013 | 731 int dmin_sum=0, mx4_sum=0, my4_sum=0; |
1494
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
732 int same=1; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
733 const int stride= c->stride; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
734 uint8_t *mv_penalty= c->current_mv_penalty; |
455 | 735 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
736 init_mv4_ref(c); |
1950 | 737 |
455 | 738 for(block=0; block<4; block++){ |
739 int mx4, my4; | |
740 int pred_x4, pred_y4; | |
741 int dmin4; | |
742 static const int off[4]= {2, 1, 1, -1}; | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1904
diff
changeset
|
743 const int mot_stride = s->b8_stride; |
455 | 744 const int mot_xy = s->block_index[block]; |
1708 | 745 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
746 P_LEFT[0] = s->current_picture.motion_val[0][mot_xy - 1][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
747 P_LEFT[1] = s->current_picture.motion_val[0][mot_xy - 1][1]; |
455 | 748 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
749 if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift); |
455 | 750 |
751 /* special case for first line */ | |
1799 | 752 if (s->first_slice_line && block<2) { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
753 c->pred_x= pred_x4= P_LEFT[0]; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
754 c->pred_y= pred_y4= P_LEFT[1]; |
455 | 755 } else { |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
756 P_TOP[0] = s->current_picture.motion_val[0][mot_xy - mot_stride ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
757 P_TOP[1] = s->current_picture.motion_val[0][mot_xy - mot_stride ][1]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
758 P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
759 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][1]; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
760 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
761 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
762 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
763 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); |
455 | 764 |
765 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | |
766 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | |
767 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
768 c->pred_x= pred_x4 = P_MEDIAN[0]; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
769 c->pred_y= pred_y4 = P_MEDIAN[1]; |
455 | 770 } |
771 P_MV1[0]= mx; | |
772 P_MV1[1]= my; | |
773 | |
1950 | 774 dmin4 = epzs_motion_search4(s, &mx4, &my4, P, block, block, s->p_mv_table, (1<<16)>>shift); |
455 | 775 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
776 dmin4= c->sub_motion_search(s, &mx4, &my4, dmin4, block, block, size, h); |
1038 | 777 |
1950 | 778 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ |
1013 | 779 int dxy; |
1708 | 780 const int offset= ((block&1) + (block>>1)*stride)*8; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
781 uint8_t *dest_y = c->scratchpad + offset; |
1013 | 782 if(s->quarter_sample){ |
1950 | 783 uint8_t *ref= c->ref[block][0] + (mx4>>2) + (my4>>2)*stride; |
1013 | 784 dxy = ((my4 & 3) << 2) | (mx4 & 3); |
785 | |
786 if(s->no_rounding) | |
1799 | 787 s->dsp.put_no_rnd_qpel_pixels_tab[1][dxy](dest_y , ref , stride); |
1013 | 788 else |
1708 | 789 s->dsp.put_qpel_pixels_tab [1][dxy](dest_y , ref , stride); |
1013 | 790 }else{ |
1950 | 791 uint8_t *ref= c->ref[block][0] + (mx4>>1) + (my4>>1)*stride; |
1013 | 792 dxy = ((my4 & 1) << 1) | (mx4 & 1); |
793 | |
794 if(s->no_rounding) | |
1708 | 795 s->dsp.put_no_rnd_pixels_tab[1][dxy](dest_y , ref , stride, h); |
1013 | 796 else |
1708 | 797 s->dsp.put_pixels_tab [1][dxy](dest_y , ref , stride, h); |
1013 | 798 } |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
799 dmin_sum+= (mv_penalty[mx4-pred_x4] + mv_penalty[my4-pred_y4])*c->mb_penalty_factor; |
1013 | 800 }else |
801 dmin_sum+= dmin4; | |
802 | |
803 if(s->quarter_sample){ | |
804 mx4_sum+= mx4/2; | |
805 my4_sum+= my4/2; | |
806 }else{ | |
807 mx4_sum+= mx4; | |
808 my4_sum+= my4; | |
809 } | |
810 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
811 s->current_picture.motion_val[0][ s->block_index[block] ][0]= mx4; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
812 s->current_picture.motion_val[0][ s->block_index[block] ][1]= my4; |
1494
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
813 |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
814 if(mx4 != mx || my4 != my) same=0; |
1013 | 815 } |
816 | |
1494
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
817 if(same) |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
818 return INT_MAX; |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
819 |
1038 | 820 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
821 dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*16*stride, c->scratchpad, stride, 16); |
455 | 822 } |
1013 | 823 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
824 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ |
1013 | 825 int dxy; |
826 int mx, my; | |
827 int offset; | |
828 | |
829 mx= ff_h263_round_chroma(mx4_sum); | |
830 my= ff_h263_round_chroma(my4_sum); | |
831 dxy = ((my & 1) << 1) | (mx & 1); | |
832 | |
833 offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize; | |
834 | |
835 if(s->no_rounding){ | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
836 s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad , s->last_picture.data[1] + offset, s->uvlinesize, 8); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
837 s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad+8 , s->last_picture.data[2] + offset, s->uvlinesize, 8); |
1013 | 838 }else{ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
839 s->dsp.put_pixels_tab [1][dxy](c->scratchpad , s->last_picture.data[1] + offset, s->uvlinesize, 8); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
840 s->dsp.put_pixels_tab [1][dxy](c->scratchpad+8 , s->last_picture.data[2] + offset, s->uvlinesize, 8); |
1013 | 841 } |
842 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
843 dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad , s->uvlinesize, 8); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
844 dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad+8, s->uvlinesize, 8); |
1013 | 845 } |
1950 | 846 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
847 c->pred_x= mx; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
848 c->pred_y= my; |
1013 | 849 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
850 switch(c->avctx->mb_cmp&0xFF){ |
1013 | 851 /*case FF_CMP_SSE: |
852 return dmin_sum+ 32*s->qscale*s->qscale;*/ | |
853 case FF_CMP_RD: | |
854 return dmin_sum; | |
855 default: | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
856 return dmin_sum+ 11*c->mb_penalty_factor; |
1013 | 857 } |
455 | 858 } |
859 | |
1962 | 860 static inline void init_interlaced_ref(MpegEncContext *s, int ref_index){ |
861 MotionEstContext * const c= &s->me; | |
862 | |
863 c->ref[1+ref_index][0] = c->ref[0+ref_index][0] + s->linesize; | |
864 c->src[1][0] = c->src[0][0] + s->linesize; | |
865 if(c->flags & FLAG_CHROMA){ | |
866 c->ref[1+ref_index][1] = c->ref[0+ref_index][1] + s->uvlinesize; | |
867 c->ref[1+ref_index][2] = c->ref[0+ref_index][2] + s->uvlinesize; | |
868 c->src[1][1] = c->src[0][1] + s->uvlinesize; | |
869 c->src[1][2] = c->src[0][2] + s->uvlinesize; | |
870 } | |
871 } | |
872 | |
1950 | 873 static int interlaced_search(MpegEncContext *s, int ref_index, |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
874 int16_t (*mv_tables[2][2])[2], uint8_t *field_select_tables[2], int mx, int my, int user_field_select) |
1708 | 875 { |
1950 | 876 MotionEstContext * const c= &s->me; |
1708 | 877 const int size=0; |
878 const int h=8; | |
879 int block; | |
880 int P[10][2]; | |
1950 | 881 uint8_t * const mv_penalty= c->current_mv_penalty; |
1708 | 882 int same=1; |
883 const int stride= 2*s->linesize; | |
884 int dmin_sum= 0; | |
885 const int mot_stride= s->mb_stride; | |
886 const int xy= s->mb_x + s->mb_y*mot_stride; | |
887 | |
1950 | 888 c->ymin>>=1; |
889 c->ymax>>=1; | |
890 c->stride<<=1; | |
891 c->uvstride<<=1; | |
1962 | 892 init_interlaced_ref(s, ref_index); |
1708 | 893 |
894 for(block=0; block<2; block++){ | |
895 int field_select; | |
896 int best_dmin= INT_MAX; | |
897 int best_field= -1; | |
898 | |
899 for(field_select=0; field_select<2; field_select++){ | |
1950 | 900 int dmin, mx_i, my_i; |
1708 | 901 int16_t (*mv_table)[2]= mv_tables[block][field_select]; |
902 | |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
903 if(user_field_select){ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
904 if(field_select_tables[block][xy] != field_select) |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
905 continue; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
906 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
907 |
1708 | 908 P_LEFT[0] = mv_table[xy - 1][0]; |
909 P_LEFT[1] = mv_table[xy - 1][1]; | |
1950 | 910 if(P_LEFT[0] > (c->xmax<<1)) P_LEFT[0] = (c->xmax<<1); |
1708 | 911 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
912 c->pred_x= P_LEFT[0]; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
913 c->pred_y= P_LEFT[1]; |
1708 | 914 |
1799 | 915 if(!s->first_slice_line){ |
1708 | 916 P_TOP[0] = mv_table[xy - mot_stride][0]; |
917 P_TOP[1] = mv_table[xy - mot_stride][1]; | |
918 P_TOPRIGHT[0] = mv_table[xy - mot_stride + 1][0]; | |
919 P_TOPRIGHT[1] = mv_table[xy - mot_stride + 1][1]; | |
1950 | 920 if(P_TOP[1] > (c->ymax<<1)) P_TOP[1] = (c->ymax<<1); |
921 if(P_TOPRIGHT[0] < (c->xmin<<1)) P_TOPRIGHT[0]= (c->xmin<<1); | |
922 if(P_TOPRIGHT[0] > (c->xmax<<1)) P_TOPRIGHT[0]= (c->xmax<<1); | |
923 if(P_TOPRIGHT[1] > (c->ymax<<1)) P_TOPRIGHT[1]= (c->ymax<<1); | |
1708 | 924 |
925 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | |
926 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | |
927 } | |
928 P_MV1[0]= mx; //FIXME not correct if block != field_select | |
929 P_MV1[1]= my / 2; | |
930 | |
1950 | 931 dmin = epzs_motion_search2(s, &mx_i, &my_i, P, block, field_select+ref_index, mv_table, (1<<16)>>1); |
1708 | 932 |
1950 | 933 dmin= c->sub_motion_search(s, &mx_i, &my_i, dmin, block, field_select+ref_index, size, h); |
1708 | 934 |
935 mv_table[xy][0]= mx_i; | |
936 mv_table[xy][1]= my_i; | |
937 | |
1950 | 938 if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){ |
1708 | 939 int dxy; |
940 | |
941 //FIXME chroma ME | |
1950 | 942 uint8_t *ref= c->ref[field_select+ref_index][0] + (mx_i>>1) + (my_i>>1)*stride; |
1708 | 943 dxy = ((my_i & 1) << 1) | (mx_i & 1); |
944 | |
945 if(s->no_rounding){ | |
1950 | 946 s->dsp.put_no_rnd_pixels_tab[size][dxy](c->scratchpad, ref , stride, h); |
1708 | 947 }else{ |
1950 | 948 s->dsp.put_pixels_tab [size][dxy](c->scratchpad, ref , stride, h); |
1708 | 949 } |
1950 | 950 dmin= s->dsp.mb_cmp[size](s, c->src[block][0], c->scratchpad, stride, h); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
951 dmin+= (mv_penalty[mx_i-c->pred_x] + mv_penalty[my_i-c->pred_y] + 1)*c->mb_penalty_factor; |
1708 | 952 }else |
1950 | 953 dmin+= c->mb_penalty_factor; //field_select bits |
1708 | 954 |
955 dmin += field_select != block; //slightly prefer same field | |
956 | |
957 if(dmin < best_dmin){ | |
958 best_dmin= dmin; | |
959 best_field= field_select; | |
960 } | |
961 } | |
962 { | |
963 int16_t (*mv_table)[2]= mv_tables[block][best_field]; | |
964 | |
965 if(mv_table[xy][0] != mx) same=0; //FIXME check if these checks work and are any good at all | |
966 if(mv_table[xy][1]&1) same=0; | |
967 if(mv_table[xy][1]*2 != my) same=0; | |
968 if(best_field != block) same=0; | |
969 } | |
970 | |
971 field_select_tables[block][xy]= best_field; | |
972 dmin_sum += best_dmin; | |
973 } | |
974 | |
1950 | 975 c->ymin<<=1; |
976 c->ymax<<=1; | |
977 c->stride>>=1; | |
978 c->uvstride>>=1; | |
1708 | 979 |
980 if(same) | |
981 return INT_MAX; | |
982 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
983 switch(c->avctx->mb_cmp&0xFF){ |
1708 | 984 /*case FF_CMP_SSE: |
985 return dmin_sum+ 32*s->qscale*s->qscale;*/ | |
986 case FF_CMP_RD: | |
987 return dmin_sum; | |
988 default: | |
1950 | 989 return dmin_sum+ 11*c->mb_penalty_factor; |
1708 | 990 } |
991 } | |
992 | |
2072 | 993 static void clip_input_mv(MpegEncContext * s, int16_t *mv, int interlaced){ |
994 int ymax= s->me.ymax>>interlaced; | |
995 int ymin= s->me.ymin>>interlaced; | |
996 | |
997 if(mv[0] < s->me.xmin) mv[0] = s->me.xmin; | |
998 if(mv[0] > s->me.xmax) mv[0] = s->me.xmax; | |
999 if(mv[1] < ymin) mv[1] = ymin; | |
1000 if(mv[1] > ymax) mv[1] = ymax; | |
1001 } | |
1002 | |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1003 static inline int check_input_motion(MpegEncContext * s, int mb_x, int mb_y, int p_type){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1004 MotionEstContext * const c= &s->me; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1005 Picture *p= s->current_picture_ptr; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1006 int mb_xy= mb_x + mb_y*s->mb_stride; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1007 int xy= 2*mb_x + 2*mb_y*s->b8_stride; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1008 int mb_type= s->current_picture.mb_type[mb_xy]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1009 int flags= c->flags; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1010 int shift= (flags&FLAG_QPEL) + 1; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1011 int mask= (1<<shift)-1; |
1962 | 1012 int x, y, i; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1013 int d=0; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1014 me_cmp_func cmpf= s->dsp.sse[0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1015 me_cmp_func chroma_cmpf= s->dsp.sse[1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1016 |
2072 | 1017 if(p_type && USES_LIST(mb_type, 1)){ |
1018 av_log(c->avctx, AV_LOG_ERROR, "backward motion vector in P frame\n"); | |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2522
diff
changeset
|
1019 return INT_MAX/2; |
2072 | 1020 } |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1021 assert(IS_INTRA(mb_type) || USES_LIST(mb_type,0) || USES_LIST(mb_type,1)); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1022 |
2072 | 1023 for(i=0; i<4; i++){ |
1024 int xy= s->block_index[i]; | |
1025 clip_input_mv(s, p->motion_val[0][xy], !!IS_INTERLACED(mb_type)); | |
1026 clip_input_mv(s, p->motion_val[1][xy], !!IS_INTERLACED(mb_type)); | |
1027 } | |
1028 | |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1029 if(IS_INTERLACED(mb_type)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1030 int xy2= xy + s->b8_stride; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1031 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1032 c->stride<<=1; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1033 c->uvstride<<=1; |
1963 | 1034 |
1995 | 1035 if(!(s->flags & CODEC_FLAG_INTERLACED_ME)){ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1036 av_log(c->avctx, AV_LOG_ERROR, "Interlaced macroblock selected but interlaced motion estimation disabled\n"); |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2522
diff
changeset
|
1037 return INT_MAX/2; |
1995 | 1038 } |
1962 | 1039 |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1040 if(USES_LIST(mb_type, 0)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1041 int field_select0= p->ref_index[0][xy ]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1042 int field_select1= p->ref_index[0][xy2]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1043 assert(field_select0==0 ||field_select0==1); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1044 assert(field_select1==0 ||field_select1==1); |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1045 init_interlaced_ref(s, 0); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1046 |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1047 if(p_type){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1048 s->p_field_select_table[0][mb_xy]= field_select0; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1049 s->p_field_select_table[1][mb_xy]= field_select1; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1050 *(uint32_t*)s->p_field_mv_table[0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[0][xy ]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1051 *(uint32_t*)s->p_field_mv_table[1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[0][xy2]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1052 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER_I; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1053 }else{ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1054 s->b_field_select_table[0][0][mb_xy]= field_select0; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1055 s->b_field_select_table[0][1][mb_xy]= field_select1; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1056 *(uint32_t*)s->b_field_mv_table[0][0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[0][xy ]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1057 *(uint32_t*)s->b_field_mv_table[0][1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[0][xy2]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1058 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_FORWARD_I; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1059 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1060 |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1061 x= p->motion_val[0][xy ][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1062 y= p->motion_val[0][xy ][1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1063 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0, 0, cmpf, chroma_cmpf, flags); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1064 x= p->motion_val[0][xy2][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1065 y= p->motion_val[0][xy2][1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1066 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1, 1, cmpf, chroma_cmpf, flags); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1067 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1068 if(USES_LIST(mb_type, 1)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1069 int field_select0= p->ref_index[1][xy ]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1070 int field_select1= p->ref_index[1][xy2]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1071 assert(field_select0==0 ||field_select0==1); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1072 assert(field_select1==0 ||field_select1==1); |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1073 init_interlaced_ref(s, 2); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1074 |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1075 s->b_field_select_table[1][0][mb_xy]= field_select0; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1076 s->b_field_select_table[1][1][mb_xy]= field_select1; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1077 *(uint32_t*)s->b_field_mv_table[1][0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[1][xy ]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1078 *(uint32_t*)s->b_field_mv_table[1][1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[1][xy2]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1079 if(USES_LIST(mb_type, 0)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1080 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BIDIR_I; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1081 }else{ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1082 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BACKWARD_I; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1083 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1084 |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1085 x= p->motion_val[1][xy ][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1086 y= p->motion_val[1][xy ][1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1087 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0+2, 0, cmpf, chroma_cmpf, flags); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1088 x= p->motion_val[1][xy2][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1089 y= p->motion_val[1][xy2][1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1090 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1+2, 1, cmpf, chroma_cmpf, flags); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1091 //FIXME bidir scores |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1092 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1093 c->stride>>=1; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1094 c->uvstride>>=1; |
1962 | 1095 }else if(IS_8X8(mb_type)){ |
1995 | 1096 if(!(s->flags & CODEC_FLAG_4MV)){ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1097 av_log(c->avctx, AV_LOG_ERROR, "4MV macroblock selected but 4MV encoding disabled\n"); |
2576
e237d9bd0f8c
check mb/me_threshold range, fixes assertion failure
michael
parents:
2522
diff
changeset
|
1098 return INT_MAX/2; |
1995 | 1099 } |
1962 | 1100 cmpf= s->dsp.sse[1]; |
1101 chroma_cmpf= s->dsp.sse[1]; | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1102 init_mv4_ref(c); |
1962 | 1103 for(i=0; i<4; i++){ |
1104 xy= s->block_index[i]; | |
1105 x= p->motion_val[0][xy][0]; | |
1106 y= p->motion_val[0][xy][1]; | |
1107 d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 1, 8, i, i, cmpf, chroma_cmpf, flags); | |
1108 } | |
1109 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER4V; | |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1110 }else{ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1111 if(USES_LIST(mb_type, 0)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1112 if(p_type){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1113 *(uint32_t*)s->p_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1114 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1115 }else if(USES_LIST(mb_type, 1)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1116 *(uint32_t*)s->b_bidir_forw_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1117 *(uint32_t*)s->b_bidir_back_mv_table[mb_xy]= *(uint32_t*)p->motion_val[1][xy]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1118 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BIDIR; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1119 }else{ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1120 *(uint32_t*)s->b_forw_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1121 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_FORWARD; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1122 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1123 x= p->motion_val[0][xy][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1124 y= p->motion_val[0][xy][1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1125 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 0, 0, cmpf, chroma_cmpf, flags); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1126 }else if(USES_LIST(mb_type, 1)){ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1127 *(uint32_t*)s->b_back_mv_table[mb_xy]= *(uint32_t*)p->motion_val[1][xy]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1128 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BACKWARD; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1129 |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1130 x= p->motion_val[1][xy][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1131 y= p->motion_val[1][xy][1]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1132 d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 2, 0, cmpf, chroma_cmpf, flags); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1133 }else |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1134 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1135 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1136 return d; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1137 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1138 |
324 | 1139 void ff_estimate_p_frame_motion(MpegEncContext * s, |
1140 int mb_x, int mb_y) | |
0 | 1141 { |
1950 | 1142 MotionEstContext * const c= &s->me; |
1064 | 1143 uint8_t *pix, *ppix; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1144 int sum, varc, vard, mx, my, dmin; |
455 | 1145 int P[10][2]; |
280 | 1146 const int shift= 1+s->quarter_sample; |
294 | 1147 int mb_type=0; |
903 | 1148 Picture * const pic= &s->current_picture; |
1950 | 1149 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1150 init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0); |
1708 | 1151 |
936 | 1152 assert(s->quarter_sample==0 || s->quarter_sample==1); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1153 assert(s->linesize == c->stride); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1154 assert(s->uvlinesize == c->uvstride); |
936 | 1155 |
2184 | 1156 c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp); |
1157 c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp); | |
1158 c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp); | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1159 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; |
0 | 1160 |
1708 | 1161 get_limits(s, 16*mb_x, 16*mb_y); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1162 c->skip=0; |
324 | 1163 |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1164 /* intra / predictive decision */ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1165 pix = c->src[0][0]; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1166 sum = s->dsp.pix_sum(pix, s->linesize); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1167 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1168 |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1169 pic->mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1170 pic->mb_var [s->mb_stride * mb_y + mb_x] = varc; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1171 c->mb_var_sum_temp += varc; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1172 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1173 if(c->avctx->me_threshold){ |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1174 vard= (check_input_motion(s, mb_x, mb_y, 1)+128)>>8; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1175 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1176 if(vard<c->avctx->me_threshold){ |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1177 pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1178 c->mc_mb_var_sum_temp += vard; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1179 if (vard <= 64 || vard < varc) { //FIXME |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1180 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1181 }else{ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1182 c->scene_change_score+= s->qscale; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1183 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1184 return; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1185 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1186 if(vard<c->avctx->mb_threshold) |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1187 mb_type= s->mb_type[mb_x + mb_y*s->mb_stride]; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1188 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1189 |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
304
diff
changeset
|
1190 switch(s->me_method) { |
0 | 1191 case ME_ZERO: |
1192 default: | |
1193 no_motion_search(s, &mx, &my); | |
455 | 1194 mx-= mb_x*16; |
1195 my-= mb_y*16; | |
0 | 1196 dmin = 0; |
1197 break; | |
1708 | 1198 #if 0 |
0 | 1199 case ME_FULL: |
1708 | 1200 dmin = full_motion_search(s, &mx, &my, range, ref_picture); |
455 | 1201 mx-= mb_x*16; |
1202 my-= mb_y*16; | |
0 | 1203 break; |
1204 case ME_LOG: | |
1708 | 1205 dmin = log_motion_search(s, &mx, &my, range / 2, ref_picture); |
455 | 1206 mx-= mb_x*16; |
1207 my-= mb_y*16; | |
0 | 1208 break; |
1209 case ME_PHODS: | |
1708 | 1210 dmin = phods_motion_search(s, &mx, &my, range / 2, ref_picture); |
455 | 1211 mx-= mb_x*16; |
1212 my-= mb_y*16; | |
0 | 1213 break; |
1708 | 1214 #endif |
288 | 1215 case ME_X1: |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
275
diff
changeset
|
1216 case ME_EPZS: |
288 | 1217 { |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1904
diff
changeset
|
1218 const int mot_stride = s->b8_stride; |
294 | 1219 const int mot_xy = s->block_index[0]; |
288 | 1220 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1221 P_LEFT[0] = s->current_picture.motion_val[0][mot_xy - 1][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1222 P_LEFT[1] = s->current_picture.motion_val[0][mot_xy - 1][1]; |
288 | 1223 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1224 if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift); |
280 | 1225 |
1799 | 1226 if(!s->first_slice_line) { |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1227 P_TOP[0] = s->current_picture.motion_val[0][mot_xy - mot_stride ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1228 P_TOP[1] = s->current_picture.motion_val[0][mot_xy - mot_stride ][1]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1229 P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1230 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][1]; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1231 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1232 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1233 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); |
280 | 1234 |
455 | 1235 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
1236 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | |
1237 | |
1238 if(s->out_format == FMT_H263){ | |
1950 | 1239 c->pred_x = P_MEDIAN[0]; |
1240 c->pred_y = P_MEDIAN[1]; | |
455 | 1241 }else { /* mpeg1 at least */ |
1950 | 1242 c->pred_x= P_LEFT[0]; |
1243 c->pred_y= P_LEFT[1]; | |
455 | 1244 } |
952 | 1245 }else{ |
1950 | 1246 c->pred_x= P_LEFT[0]; |
1247 c->pred_y= P_LEFT[1]; | |
288 | 1248 } |
952 | 1249 |
280 | 1250 } |
2184 | 1251 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16); |
1950 | 1252 |
277
5cb2978e701f
new motion estimation (epzs) not complete yet but allready pretty good :)
michaelni
parents:
275
diff
changeset
|
1253 break; |
0 | 1254 } |
1255 | |
455 | 1256 /* At this point (mx,my) are full-pell and the relative displacement */ |
1950 | 1257 ppix = c->ref[0][0] + (my * s->linesize) + mx; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1258 |
1708 | 1259 vard = (s->dsp.sse[0](NULL, pix, ppix, s->linesize, 16)+128)>>8; |
608 | 1260 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1261 pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1262 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1263 c->mc_mb_var_sum_temp += vard; |
320
cda7d0857baf
- ME setting moved to AVCodecContext/MpegEncContext, no longer a global.
pulento
parents:
304
diff
changeset
|
1264 |
0 | 1265 #if 0 |
233
3f5b72726118
- More work on preliminary bit rate control, just to be able to get an
pulento
parents:
232
diff
changeset
|
1266 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
|
1267 varc, s->avg_mb_var, sum, vard, mx - xx, my - yy); |
0 | 1268 #endif |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1269 if(mb_type){ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1270 if (vard <= 64 || vard < varc) |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1271 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1272 else |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1273 c->scene_change_score+= s->qscale; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1274 |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1275 if(mb_type == CANDIDATE_MB_TYPE_INTER){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1276 c->sub_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1277 set_p_mv_tables(s, mx, my, 1); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1278 }else{ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1279 mx <<=shift; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1280 my <<=shift; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1281 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1282 if(mb_type == CANDIDATE_MB_TYPE_INTER4V){ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1283 h263_mv4_search(s, mx, my, shift); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1284 |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1285 set_p_mv_tables(s, mx, my, 0); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1286 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1287 if(mb_type == CANDIDATE_MB_TYPE_INTER_I){ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1288 interlaced_search(s, 0, s->p_field_mv_table, s->p_field_select_table, mx, my, 1); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1289 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1290 }else if(c->avctx->mb_decision > FF_MB_DECISION_SIMPLE){ |
608 | 1291 if (vard <= 64 || vard < varc) |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1292 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
608 | 1293 else |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1294 c->scene_change_score+= s->qscale; |
608 | 1295 |
294 | 1296 if (vard*2 + 200 > varc) |
1708 | 1297 mb_type|= CANDIDATE_MB_TYPE_INTRA; |
294 | 1298 if (varc*2 + 200 > vard){ |
1708 | 1299 mb_type|= CANDIDATE_MB_TYPE_INTER; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1300 c->sub_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); |
1494
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
1301 if(s->flags&CODEC_FLAG_MV0) |
3ee63c12ea30
optionally try to encode each MB with MV=<0,0> and choose the one with better RD
michaelni
parents:
1426
diff
changeset
|
1302 if(mx || my) |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2576
diff
changeset
|
1303 mb_type |= CANDIDATE_MB_TYPE_SKIPPED; //FIXME check difference |
304 | 1304 }else{ |
936 | 1305 mx <<=shift; |
1306 my <<=shift; | |
0 | 1307 } |
455 | 1308 if((s->flags&CODEC_FLAG_4MV) |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1309 && !c->skip && varc>50 && vard>10){ |
1708 | 1310 if(h263_mv4_search(s, mx, my, shift) < INT_MAX) |
1311 mb_type|=CANDIDATE_MB_TYPE_INTER4V; | |
455 | 1312 |
1313 set_p_mv_tables(s, mx, my, 0); | |
1314 }else | |
1315 set_p_mv_tables(s, mx, my, 1); | |
1708 | 1316 if((s->flags&CODEC_FLAG_INTERLACED_ME) |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1317 && !c->skip){ //FIXME varc/d checks |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1318 if(interlaced_search(s, 0, s->p_field_mv_table, s->p_field_select_table, mx, my, 0) < INT_MAX) |
1708 | 1319 mb_type |= CANDIDATE_MB_TYPE_INTER_I; |
1320 } | |
294 | 1321 }else{ |
1633 | 1322 int intra_score, i; |
1708 | 1323 mb_type= CANDIDATE_MB_TYPE_INTER; |
1013 | 1324 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1325 dmin= c->sub_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1326 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) |
2189
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
1327 dmin= ff_get_mb_score(s, mx, my, 0, 0, 0, 16, 1); |
1013 | 1328 |
1329 if((s->flags&CODEC_FLAG_4MV) | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1330 && !c->skip && varc>50 && vard>10){ |
1708 | 1331 int dmin4= h263_mv4_search(s, mx, my, shift); |
1013 | 1332 if(dmin4 < dmin){ |
1708 | 1333 mb_type= CANDIDATE_MB_TYPE_INTER4V; |
1013 | 1334 dmin=dmin4; |
1335 } | |
1336 } | |
1708 | 1337 if((s->flags&CODEC_FLAG_INTERLACED_ME) |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1338 && !c->skip){ //FIXME varc/d checks |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1339 int dmin_i= interlaced_search(s, 0, s->p_field_mv_table, s->p_field_select_table, mx, my, 0); |
1708 | 1340 if(dmin_i < dmin){ |
1341 mb_type = CANDIDATE_MB_TYPE_INTER_I; | |
1342 dmin= dmin_i; | |
1343 } | |
1344 } | |
1633 | 1345 |
1346 // pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin; | |
1708 | 1347 set_p_mv_tables(s, mx, my, mb_type!=CANDIDATE_MB_TYPE_INTER4V); |
1633 | 1348 |
1349 /* get intra luma score */ | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1350 if((c->avctx->mb_cmp&0xFF)==FF_CMP_SSE){ |
1633 | 1351 intra_score= (varc<<8) - 500; //FIXME dont scale it down so we dont have to fix it |
1352 }else{ | |
1353 int mean= (sum+128)>>8; | |
1354 mean*= 0x01010101; | |
1355 | |
1356 for(i=0; i<16; i++){ | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1357 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 0]) = mean; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1358 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 4]) = mean; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1359 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 8]) = mean; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1360 *(uint32_t*)(&c->scratchpad[i*s->linesize+12]) = mean; |
1633 | 1361 } |
1362 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1363 intra_score= s->dsp.mb_cmp[0](s, c->scratchpad, pix, s->linesize, 16); |
1633 | 1364 } |
1365 #if 0 //FIXME | |
1366 /* get chroma score */ | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1367 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ |
1633 | 1368 for(i=1; i<3; i++){ |
1369 uint8_t *dest_c; | |
1370 int mean; | |
1371 | |
1372 if(s->out_format == FMT_H263){ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1904
diff
changeset
|
1373 mean= (s->dc_val[i][mb_x + mb_y*s->b8_stride] + 4)>>3; //FIXME not exact but simple ;) |
1633 | 1374 }else{ |
1375 mean= (s->last_dc[i] + 4)>>3; | |
1376 } | |
1377 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8; | |
1378 | |
1379 mean*= 0x01010101; | |
1380 for(i=0; i<8; i++){ | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1381 *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 0]) = mean; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1382 *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 4]) = mean; |
1633 | 1383 } |
1384 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1385 intra_score+= s->dsp.mb_cmp[1](s, c->scratchpad, dest_c, s->uvlinesize); |
1633 | 1386 } |
1387 } | |
1388 #endif | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1389 intra_score += c->mb_penalty_factor*16; |
1013 | 1390 |
1633 | 1391 if(intra_score < dmin){ |
1708 | 1392 mb_type= CANDIDATE_MB_TYPE_INTRA; |
1393 s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup | |
1633 | 1394 }else |
1395 s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= 0; | |
1396 | |
1397 if (vard <= 64 || vard < varc) { //FIXME | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1398 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
294 | 1399 }else{ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1400 c->scene_change_score+= s->qscale; |
294 | 1401 } |
1402 } | |
284 | 1403 |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1404 s->mb_type[mb_y*s->mb_stride + mb_x]= mb_type; |
0 | 1405 } |
1406 | |
951 | 1407 int ff_pre_estimate_p_frame_motion(MpegEncContext * s, |
1408 int mb_x, int mb_y) | |
1409 { | |
1950 | 1410 MotionEstContext * const c= &s->me; |
1708 | 1411 int mx, my, dmin; |
951 | 1412 int P[10][2]; |
1413 const int shift= 1+s->quarter_sample; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1414 const int xy= mb_x + mb_y*s->mb_stride; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1415 init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0); |
951 | 1416 |
1417 assert(s->quarter_sample==0 || s->quarter_sample==1); | |
1418 | |
2184 | 1419 c->pre_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_pre_cmp); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1420 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; |
951 | 1421 |
1708 | 1422 get_limits(s, 16*mb_x, 16*mb_y); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1423 c->skip=0; |
951 | 1424 |
1425 P_LEFT[0] = s->p_mv_table[xy + 1][0]; | |
1426 P_LEFT[1] = s->p_mv_table[xy + 1][1]; | |
1427 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1428 if(P_LEFT[0] < (c->xmin<<shift)) P_LEFT[0] = (c->xmin<<shift); |
951 | 1429 |
1430 /* special case for first line */ | |
1799 | 1431 if (s->first_slice_line) { |
1950 | 1432 c->pred_x= P_LEFT[0]; |
1433 c->pred_y= P_LEFT[1]; | |
952 | 1434 P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]= |
1435 P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME | |
951 | 1436 } else { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1437 P_TOP[0] = s->p_mv_table[xy + s->mb_stride ][0]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1438 P_TOP[1] = s->p_mv_table[xy + s->mb_stride ][1]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1439 P_TOPRIGHT[0] = s->p_mv_table[xy + s->mb_stride - 1][0]; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1440 P_TOPRIGHT[1] = s->p_mv_table[xy + s->mb_stride - 1][1]; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1441 if(P_TOP[1] < (c->ymin<<shift)) P_TOP[1] = (c->ymin<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1442 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1443 if(P_TOPRIGHT[1] < (c->ymin<<shift)) P_TOPRIGHT[1]= (c->ymin<<shift); |
951 | 1444 |
1445 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | |
1446 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | |
1447 | |
1950 | 1448 c->pred_x = P_MEDIAN[0]; |
1449 c->pred_y = P_MEDIAN[1]; | |
951 | 1450 } |
1950 | 1451 |
2184 | 1452 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16); |
952 | 1453 |
951 | 1454 s->p_mv_table[xy][0] = mx<<shift; |
1455 s->p_mv_table[xy][1] = my<<shift; | |
1456 | |
1457 return dmin; | |
1458 } | |
1459 | |
1057 | 1460 static int ff_estimate_motion_b(MpegEncContext * s, |
1950 | 1461 int mb_x, int mb_y, int16_t (*mv_table)[2], int ref_index, int f_code) |
0 | 1462 { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1463 MotionEstContext * const c= &s->me; |
1708 | 1464 int mx, my, dmin; |
455 | 1465 int P[10][2]; |
324 | 1466 const int shift= 1+s->quarter_sample; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1467 const int mot_stride = s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1468 const int mot_xy = mb_y*mot_stride + mb_x; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1469 uint8_t * const mv_penalty= c->mv_penalty[f_code] + MAX_MV; |
948 | 1470 int mv_scale; |
936 | 1471 |
2184 | 1472 c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp); |
1473 c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp); | |
1474 c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp); | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1475 c->current_mv_penalty= mv_penalty; |
936 | 1476 |
1708 | 1477 get_limits(s, 16*mb_x, 16*mb_y); |
324 | 1478 |
1479 switch(s->me_method) { | |
1480 case ME_ZERO: | |
1481 default: | |
1482 no_motion_search(s, &mx, &my); | |
1483 dmin = 0; | |
455 | 1484 mx-= mb_x*16; |
1485 my-= mb_y*16; | |
324 | 1486 break; |
1708 | 1487 #if 0 |
324 | 1488 case ME_FULL: |
1708 | 1489 dmin = full_motion_search(s, &mx, &my, range, ref_picture); |
455 | 1490 mx-= mb_x*16; |
1491 my-= mb_y*16; | |
324 | 1492 break; |
1493 case ME_LOG: | |
1708 | 1494 dmin = log_motion_search(s, &mx, &my, range / 2, ref_picture); |
455 | 1495 mx-= mb_x*16; |
1496 my-= mb_y*16; | |
324 | 1497 break; |
1498 case ME_PHODS: | |
1708 | 1499 dmin = phods_motion_search(s, &mx, &my, range / 2, ref_picture); |
455 | 1500 mx-= mb_x*16; |
1501 my-= mb_y*16; | |
324 | 1502 break; |
1708 | 1503 #endif |
324 | 1504 case ME_X1: |
1505 case ME_EPZS: | |
1506 { | |
455 | 1507 P_LEFT[0] = mv_table[mot_xy - 1][0]; |
1508 P_LEFT[1] = mv_table[mot_xy - 1][1]; | |
324 | 1509 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1510 if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift); |
324 | 1511 |
1512 /* special case for first line */ | |
1799 | 1513 if (!s->first_slice_line) { |
455 | 1514 P_TOP[0] = mv_table[mot_xy - mot_stride ][0]; |
1515 P_TOP[1] = mv_table[mot_xy - mot_stride ][1]; | |
1516 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0]; | |
1517 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1]; | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1518 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1]= (c->ymax<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1519 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1520 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift); |
324 | 1521 |
455 | 1522 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); |
1523 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | |
324 | 1524 } |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1525 c->pred_x= P_LEFT[0]; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1526 c->pred_y= P_LEFT[1]; |
324 | 1527 } |
948 | 1528 |
1529 if(mv_table == s->b_forw_mv_table){ | |
1530 mv_scale= (s->pb_time<<16) / (s->pp_time<<shift); | |
1531 }else{ | |
1532 mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift); | |
1533 } | |
1534 | |
2184 | 1535 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, ref_index, s->p_mv_table, mv_scale, 0, 16); |
324 | 1536 |
1537 break; | |
1538 } | |
1539 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1540 dmin= c->sub_motion_search(s, &mx, &my, dmin, 0, ref_index, 0, 16); |
1013 | 1541 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1542 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) |
2189
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
1543 dmin= ff_get_mb_score(s, mx, my, 0, ref_index, 0, 16, 1); |
1013 | 1544 |
455 | 1545 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my); |
324 | 1546 // s->mb_type[mb_y*s->mb_width + mb_x]= mb_type; |
1547 mv_table[mot_xy][0]= mx; | |
1548 mv_table[mot_xy][1]= my; | |
936 | 1549 |
327 | 1550 return dmin; |
324 | 1551 } |
1552 | |
1950 | 1553 static inline int check_bidir_mv(MpegEncContext * s, |
327 | 1554 int motion_fx, int motion_fy, |
1555 int motion_bx, int motion_by, | |
1556 int pred_fx, int pred_fy, | |
1708 | 1557 int pred_bx, int pred_by, |
1558 int size, int h) | |
327 | 1559 { |
1560 //FIXME optimize? | |
936 | 1561 //FIXME better f_code prediction (max mv & distance) |
1708 | 1562 //FIXME pointers |
1950 | 1563 MotionEstContext * const c= &s->me; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1564 uint8_t * const mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1565 int stride= c->stride; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1566 int uvstride= c->uvstride; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1567 uint8_t *dest_y = c->scratchpad; |
327 | 1568 uint8_t *ptr; |
1569 int dxy; | |
1570 int src_x, src_y; | |
1571 int fbmin; | |
1950 | 1572 uint8_t **src_data= c->src[0]; |
1573 uint8_t **ref_data= c->ref[0]; | |
1574 uint8_t **ref2_data= c->ref[2]; | |
327 | 1575 |
936 | 1576 if(s->quarter_sample){ |
1577 dxy = ((motion_fy & 3) << 2) | (motion_fx & 3); | |
1708 | 1578 src_x = motion_fx >> 2; |
1579 src_y = motion_fy >> 2; | |
327 | 1580 |
1708 | 1581 ptr = ref_data[0] + (src_y * stride) + src_x; |
1582 s->dsp.put_qpel_pixels_tab[0][dxy](dest_y , ptr , stride); | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
1583 |
936 | 1584 dxy = ((motion_by & 3) << 2) | (motion_bx & 3); |
1708 | 1585 src_x = motion_bx >> 2; |
1586 src_y = motion_by >> 2; | |
936 | 1587 |
1950 | 1588 ptr = ref2_data[0] + (src_y * stride) + src_x; |
1708 | 1589 s->dsp.avg_qpel_pixels_tab[size][dxy](dest_y , ptr , stride); |
936 | 1590 }else{ |
1591 dxy = ((motion_fy & 1) << 1) | (motion_fx & 1); | |
1708 | 1592 src_x = motion_fx >> 1; |
1593 src_y = motion_fy >> 1; | |
327 | 1594 |
1708 | 1595 ptr = ref_data[0] + (src_y * stride) + src_x; |
1596 s->dsp.put_pixels_tab[size][dxy](dest_y , ptr , stride, h); | |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
1597 |
936 | 1598 dxy = ((motion_by & 1) << 1) | (motion_bx & 1); |
1708 | 1599 src_x = motion_bx >> 1; |
1600 src_y = motion_by >> 1; | |
936 | 1601 |
1950 | 1602 ptr = ref2_data[0] + (src_y * stride) + src_x; |
1708 | 1603 s->dsp.avg_pixels_tab[size][dxy](dest_y , ptr , stride, h); |
936 | 1604 } |
853
eacc2dd8fd9d
* using DSPContext - so each codec could use its local (sub)set of CPU extension
kabi
parents:
847
diff
changeset
|
1605 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1606 fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*c->mb_penalty_factor |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1607 +(mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*c->mb_penalty_factor |
1708 | 1608 + s->dsp.mb_cmp[size](s, src_data[0], dest_y, stride, h); //FIXME new_pic |
1013 | 1609 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1610 if(c->avctx->mb_cmp&FF_CMP_CHROMA){ |
1013 | 1611 } |
1612 //FIXME CHROMA !!! | |
1613 | |
327 | 1614 return fbmin; |
1615 } | |
1616 | |
1617 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/ | |
1950 | 1618 static inline int bidir_refine(MpegEncContext * s, int mb_x, int mb_y) |
327 | 1619 { |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1620 const int mot_stride = s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1621 const int xy = mb_y *mot_stride + mb_x; |
327 | 1622 int fbmin; |
1623 int pred_fx= s->b_bidir_forw_mv_table[xy-1][0]; | |
1624 int pred_fy= s->b_bidir_forw_mv_table[xy-1][1]; | |
1625 int pred_bx= s->b_bidir_back_mv_table[xy-1][0]; | |
1626 int pred_by= s->b_bidir_back_mv_table[xy-1][1]; | |
1627 int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0]; | |
1628 int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1]; | |
1629 int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0]; | |
1630 int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1]; | |
1631 | |
1632 //FIXME do refinement and add flag | |
1633 | |
1950 | 1634 fbmin= check_bidir_mv(s, motion_fx, motion_fy, |
327 | 1635 motion_bx, motion_by, |
1636 pred_fx, pred_fy, | |
1708 | 1637 pred_bx, pred_by, |
1638 0, 16); | |
327 | 1639 |
1640 return fbmin; | |
1641 } | |
1642 | |
1950 | 1643 static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y) |
324 | 1644 { |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1645 MotionEstContext * const c= &s->me; |
455 | 1646 int P[10][2]; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1647 const int mot_stride = s->mb_stride; |
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1648 const int mot_xy = mb_y*mot_stride + mb_x; |
936 | 1649 const int shift= 1+s->quarter_sample; |
1650 int dmin, i; | |
327 | 1651 const int time_pp= s->pp_time; |
664 | 1652 const int time_pb= s->pb_time; |
936 | 1653 int mx, my, xmin, xmax, ymin, ymax; |
327 | 1654 int16_t (*mv_table)[2]= s->b_direct_mv_table; |
936 | 1655 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1656 c->current_mv_penalty= c->mv_penalty[1] + MAX_MV; |
936 | 1657 ymin= xmin=(-32)>>shift; |
1658 ymax= xmax= 31>>shift; | |
1659 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1660 if(IS_8X8(s->next_picture.mb_type[mot_xy])){ |
936 | 1661 s->mv_type= MV_TYPE_8X8; |
1662 }else{ | |
1663 s->mv_type= MV_TYPE_16X16; | |
327 | 1664 } |
936 | 1665 |
1666 for(i=0; i<4; i++){ | |
1667 int index= s->block_index[i]; | |
1668 int min, max; | |
1669 | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1670 c->co_located_mv[i][0]= s->next_picture.motion_val[0][index][0]; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1671 c->co_located_mv[i][1]= s->next_picture.motion_val[0][index][1]; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1672 c->direct_basis_mv[i][0]= c->co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3)); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1673 c->direct_basis_mv[i][1]= c->co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3)); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1674 // c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3); |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1675 // c->direct_basis_mv[1][i][1]= c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(shift+3); |
936 | 1676 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1677 max= FFMAX(c->direct_basis_mv[i][0], c->direct_basis_mv[i][0] - c->co_located_mv[i][0])>>shift; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1678 min= FFMIN(c->direct_basis_mv[i][0], c->direct_basis_mv[i][0] - c->co_located_mv[i][0])>>shift; |
1764 | 1679 max+= 16*mb_x + 1; // +-1 is for the simpler rounding |
1680 min+= 16*mb_x - 1; | |
960 | 1681 xmax= FFMIN(xmax, s->width - max); |
1682 xmin= FFMAX(xmin, - 16 - min); | |
936 | 1683 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1684 max= FFMAX(c->direct_basis_mv[i][1], c->direct_basis_mv[i][1] - c->co_located_mv[i][1])>>shift; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1685 min= FFMIN(c->direct_basis_mv[i][1], c->direct_basis_mv[i][1] - c->co_located_mv[i][1])>>shift; |
1764 | 1686 max+= 16*mb_y + 1; // +-1 is for the simpler rounding |
1687 min+= 16*mb_y - 1; | |
960 | 1688 ymax= FFMIN(ymax, s->height - max); |
1689 ymin= FFMAX(ymin, - 16 - min); | |
936 | 1690 |
1691 if(s->mv_type == MV_TYPE_16X16) break; | |
327 | 1692 } |
936 | 1693 |
1694 assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16); | |
1695 | |
1696 if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){ | |
1697 s->b_direct_mv_table[mot_xy][0]= 0; | |
1698 s->b_direct_mv_table[mot_xy][1]= 0; | |
1699 | |
1700 return 256*256*256*64; | |
1701 } | |
1708 | 1702 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1703 c->xmin= xmin; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1704 c->ymin= ymin; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1705 c->xmax= xmax; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1706 c->ymax= ymax; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1707 c->flags |= FLAG_DIRECT; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1708 c->sub_flags |= FLAG_DIRECT; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1709 c->pred_x=0; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1710 c->pred_y=0; |
936 | 1711 |
950 | 1712 P_LEFT[0] = clip(mv_table[mot_xy - 1][0], xmin<<shift, xmax<<shift); |
1713 P_LEFT[1] = clip(mv_table[mot_xy - 1][1], ymin<<shift, ymax<<shift); | |
1714 | |
1715 /* special case for first line */ | |
1799 | 1716 if (!s->first_slice_line) { //FIXME maybe allow this over thread boundary as its cliped |
950 | 1717 P_TOP[0] = clip(mv_table[mot_xy - mot_stride ][0], xmin<<shift, xmax<<shift); |
1718 P_TOP[1] = clip(mv_table[mot_xy - mot_stride ][1], ymin<<shift, ymax<<shift); | |
1719 P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1 ][0], xmin<<shift, xmax<<shift); | |
1720 P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1 ][1], ymin<<shift, ymax<<shift); | |
1721 | |
1722 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]); | |
1723 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]); | |
1724 } | |
1013 | 1725 |
2184 | 1726 dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, mv_table, 1<<(16-shift), 0, 16); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1727 if(c->sub_flags&FLAG_QPEL) |
1950 | 1728 dmin = qpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); |
1729 else | |
1730 dmin = hpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16); | |
1731 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1732 if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip) |
2189
70b27300a496
quad tree based motion compensation (currently only 16x16 & 8x8 OBMC blocks, but can be extended to other block sizes easily)
michael
parents:
2184
diff
changeset
|
1733 dmin= ff_get_mb_score(s, mx, my, 0, 0, 0, 16, 1); |
1708 | 1734 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1735 get_limits(s, 16*mb_x, 16*mb_y); //restore c->?min/max, maybe not needed |
327 | 1736 |
1737 s->b_direct_mv_table[mot_xy][0]= mx; | |
1738 s->b_direct_mv_table[mot_xy][1]= my; | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1739 c->flags &= ~FLAG_DIRECT; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1740 c->sub_flags &= ~FLAG_DIRECT; |
1950 | 1741 |
327 | 1742 return dmin; |
324 | 1743 } |
1744 | |
1745 void ff_estimate_b_frame_motion(MpegEncContext * s, | |
1746 int mb_x, int mb_y) | |
1747 { | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1748 MotionEstContext * const c= &s->me; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1749 const int penalty_factor= c->mb_penalty_factor; |
1708 | 1750 int fmin, bmin, dmin, fbmin, bimin, fimin; |
327 | 1751 int type=0; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1752 const int xy = mb_y*s->mb_stride + mb_x; |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1753 init_ref(c, s->new_picture.data, s->last_picture.data, s->next_picture.data, 16*mb_x, 16*mb_y, 2); |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1754 |
2072 | 1755 get_limits(s, 16*mb_x, 16*mb_y); |
327 | 1756 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1757 c->skip=0; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1758 if(c->avctx->me_threshold){ |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1759 int vard= (check_input_motion(s, mb_x, mb_y, 0)+128)>>8; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1760 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1761 if(vard<c->avctx->me_threshold){ |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1762 // pix = c->src[0][0]; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1763 // sum = s->dsp.pix_sum(pix, s->linesize); |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1764 // varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1765 |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1766 // pic->mb_var [s->mb_stride * mb_y + mb_x] = varc; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1767 s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] = vard; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1768 /* pic->mb_mean [s->mb_stride * mb_y + mb_x] = (sum+128)>>8; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1769 c->mb_var_sum_temp += varc;*/ |
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1770 c->mc_mb_var_sum_temp += vard; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1771 /* if (vard <= 64 || vard < varc) { |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1772 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc); |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1773 }else{ |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1774 c->scene_change_score+= s->qscale; |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1775 }*/ |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1776 return; |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1777 } |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1778 if(vard<c->avctx->mb_threshold){ |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1779 type= s->mb_type[mb_y*s->mb_stride + mb_x]; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1780 if(type == CANDIDATE_MB_TYPE_DIRECT){ |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1781 direct_search(s, mb_x, mb_y); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1782 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1783 if(type == CANDIDATE_MB_TYPE_FORWARD || type == CANDIDATE_MB_TYPE_BIDIR){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1784 c->skip=0; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1785 ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, 0, s->f_code); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1786 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1787 if(type == CANDIDATE_MB_TYPE_BACKWARD || type == CANDIDATE_MB_TYPE_BIDIR){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1788 c->skip=0; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1789 ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, 2, s->b_code); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1790 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1791 if(type == CANDIDATE_MB_TYPE_FORWARD_I || type == CANDIDATE_MB_TYPE_BIDIR_I){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1792 c->skip=0; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1793 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1794 interlaced_search(s, 0, |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1795 s->b_field_mv_table[0], s->b_field_select_table[0], |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1796 s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1], 1); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1797 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1798 if(type == CANDIDATE_MB_TYPE_BACKWARD_I || type == CANDIDATE_MB_TYPE_BIDIR_I){ |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1799 c->skip=0; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1800 c->current_mv_penalty= c->mv_penalty[s->b_code] + MAX_MV; |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1801 interlaced_search(s, 2, |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1802 s->b_field_mv_table[1], s->b_field_select_table[1], |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1803 s->b_back_mv_table[xy][0], s->b_back_mv_table[xy][1], 1); |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1804 } |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1805 return; |
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1806 } |
1955
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1807 } |
5dafb10e0252
reuse motion vectors/mb types/field select values of the source video, if the SSE for a macroblock which is predicted with these values is below me_threshold
michael
parents:
1950
diff
changeset
|
1808 |
1426 | 1809 if (s->codec_id == CODEC_ID_MPEG4) |
1950 | 1810 dmin= direct_search(s, mb_x, mb_y); |
1426 | 1811 else |
1812 dmin= INT_MAX; | |
1708 | 1813 //FIXME penalty stuff for non mpeg4 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1814 c->skip=0; |
1950 | 1815 fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, 0, s->f_code) + 3*penalty_factor; |
1426 | 1816 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1817 c->skip=0; |
1950 | 1818 bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, 2, s->b_code) + 2*penalty_factor; |
324 | 1819 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]); |
327 | 1820 |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1821 c->skip=0; |
1950 | 1822 fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor; |
1013 | 1823 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin); |
1708 | 1824 |
1825 if(s->flags & CODEC_FLAG_INTERLACED_ME){ | |
1826 //FIXME mb type penalty | |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1827 c->skip=0; |
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1828 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV; |
1950 | 1829 fimin= interlaced_search(s, 0, |
1830 s->b_field_mv_table[0], s->b_field_select_table[0], | |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1831 s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1], 0); |
2014
15c885db82a8
reduce dependancy between motion estimation and MpegEncContext
michael
parents:
1995
diff
changeset
|
1832 c->current_mv_penalty= c->mv_penalty[s->b_code] + MAX_MV; |
1950 | 1833 bimin= interlaced_search(s, 2, |
1834 s->b_field_mv_table[1], s->b_field_select_table[1], | |
1968
19c2344e800a
support reusing mb types and field select values of the source file, but use motion vectors just as additional predictors
michael
parents:
1963
diff
changeset
|
1835 s->b_back_mv_table[xy][0], s->b_back_mv_table[xy][1], 0); |
1708 | 1836 }else |
1837 fimin= bimin= INT_MAX; | |
1838 | |
612 | 1839 { |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1050
diff
changeset
|
1840 int score= fmin; |
1708 | 1841 type = CANDIDATE_MB_TYPE_FORWARD; |
327 | 1842 |
1426 | 1843 if (dmin <= score){ |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1050
diff
changeset
|
1844 score = dmin; |
1708 | 1845 type = CANDIDATE_MB_TYPE_DIRECT; |
327 | 1846 } |
1847 if(bmin<score){ | |
1848 score=bmin; | |
1708 | 1849 type= CANDIDATE_MB_TYPE_BACKWARD; |
327 | 1850 } |
1851 if(fbmin<score){ | |
1852 score=fbmin; | |
1708 | 1853 type= CANDIDATE_MB_TYPE_BIDIR; |
1854 } | |
1855 if(fimin<score){ | |
1856 score=fimin; | |
1857 type= CANDIDATE_MB_TYPE_FORWARD_I; | |
1858 } | |
1859 if(bimin<score){ | |
1860 score=bimin; | |
1861 type= CANDIDATE_MB_TYPE_BACKWARD_I; | |
327 | 1862 } |
1013 | 1863 |
807
0e1d375c537f
fixing q>0.0 assert failure caused by overflow of variance for b frames
michaelni
parents:
765
diff
changeset
|
1864 score= ((unsigned)(score*score + 128*256))>>16; |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1865 c->mc_mb_var_sum_temp += score; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1866 s->current_picture.mc_mb_var[mb_y*s->mb_stride + mb_x] = score; //FIXME use SSE |
327 | 1867 } |
612 | 1868 |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1869 if(c->avctx->mb_decision > FF_MB_DECISION_SIMPLE){ |
1708 | 1870 type= CANDIDATE_MB_TYPE_FORWARD | CANDIDATE_MB_TYPE_BACKWARD | CANDIDATE_MB_TYPE_BIDIR | CANDIDATE_MB_TYPE_DIRECT; |
1871 if(fimin < INT_MAX) | |
1872 type |= CANDIDATE_MB_TYPE_FORWARD_I; | |
1873 if(bimin < INT_MAX) | |
1874 type |= CANDIDATE_MB_TYPE_BACKWARD_I; | |
1875 if(fimin < INT_MAX && bimin < INT_MAX){ | |
1876 type |= CANDIDATE_MB_TYPE_BIDIR_I; | |
1877 } | |
1878 //FIXME something smarter | |
1879 if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB | |
1729 | 1880 #if 0 |
1881 if(s->out_format == FMT_MPEG1) | |
1882 type |= CANDIDATE_MB_TYPE_INTRA; | |
1883 #endif | |
612 | 1884 } |
1885 | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1886 s->mb_type[mb_y*s->mb_stride + mb_x]= type; |
324 | 1887 } |
0 | 1888 |
324 | 1889 /* find best f_code for ME which do unlimited searches */ |
1890 int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type) | |
1891 { | |
1892 if(s->me_method>=ME_EPZS){ | |
455 | 1893 int score[8]; |
2302 | 1894 int i, y, range= s->avctx->me_range; |
1064 | 1895 uint8_t * fcode_tab= s->fcode_tab; |
455 | 1896 int best_fcode=-1; |
1897 int best_score=-10000000; | |
324 | 1898 |
936 | 1899 for(i=0; i<8; i++) score[i]= s->mb_num*(8-i); |
324 | 1900 |
1901 for(y=0; y<s->mb_height; y++){ | |
1902 int x; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1903 int xy= y*s->mb_stride; |
324 | 1904 for(x=0; x<s->mb_width; x++){ |
1634 | 1905 if(s->mb_type[xy] & type){ |
2302 | 1906 int mx= mv_table[xy][0]; |
1907 int my= mv_table[xy][1]; | |
1908 int fcode= FFMAX(fcode_tab[mx + MAX_MV], | |
1909 fcode_tab[my + MAX_MV]); | |
455 | 1910 int j; |
1911 | |
2302 | 1912 if(range){ |
1913 if(mx >= range || mx < -range || | |
1914 my >= range || my < -range) | |
1915 continue; | |
1916 } | |
1917 | |
455 | 1918 for(j=0; j<fcode && j<8; j++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1919 if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[xy] < s->current_picture.mb_var[xy]) |
455 | 1920 score[j]-= 170; |
1921 } | |
324 | 1922 } |
1923 xy++; | |
1924 } | |
1925 } | |
455 | 1926 |
1927 for(i=1; i<8; i++){ | |
1928 if(score[i] > best_score){ | |
1929 best_score= score[i]; | |
1930 best_fcode= i; | |
1931 } | |
1932 // printf("%d %d\n", i, score[i]); | |
1933 } | |
327 | 1934 |
324 | 1935 // printf("fcode: %d type: %d\n", i, s->pict_type); |
455 | 1936 return best_fcode; |
324 | 1937 /* for(i=0; i<=MAX_FCODE; i++){ |
1938 printf("%d ", mv_num[i]); | |
1939 } | |
1940 printf("\n");*/ | |
1941 }else{ | |
1942 return 1; | |
0 | 1943 } |
1944 } | |
1945 | |
324 | 1946 void ff_fix_long_p_mvs(MpegEncContext * s) |
1947 { | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1948 MotionEstContext * const c= &s->me; |
324 | 1949 const int f_code= s->f_code; |
1086 | 1950 int y, range; |
1421 | 1951 assert(s->pict_type==P_TYPE); |
1086 | 1952 |
1421 | 1953 range = (((s->out_format == FMT_MPEG1) ? 8 : 16) << f_code); |
1086 | 1954 |
1955 if(s->msmpeg4_version) range= 16; | |
1956 | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1957 if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range; |
1086 | 1958 |
455 | 1959 //printf("%d no:%d %d//\n", clip, noclip, f_code); |
324 | 1960 if(s->flags&CODEC_FLAG_4MV){ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1904
diff
changeset
|
1961 const int wrap= s->b8_stride; |
324 | 1962 |
1963 /* clip / convert to intra 8x8 type MVs */ | |
1964 for(y=0; y<s->mb_height; y++){ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1904
diff
changeset
|
1965 int xy= y*2*wrap; |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
1966 int i= y*s->mb_stride; |
324 | 1967 int x; |
1968 | |
1969 for(x=0; x<s->mb_width; x++){ | |
1708 | 1970 if(s->mb_type[i]&CANDIDATE_MB_TYPE_INTER4V){ |
324 | 1971 int block; |
1972 for(block=0; block<4; block++){ | |
1973 int off= (block& 1) + (block>>1)*wrap; | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1974 int mx= s->current_picture.motion_val[0][ xy + off ][0]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1634
diff
changeset
|
1975 int my= s->current_picture.motion_val[0][ xy + off ][1]; |
324 | 1976 |
1086 | 1977 if( mx >=range || mx <-range |
1978 || my >=range || my <-range){ | |
1708 | 1979 s->mb_type[i] &= ~CANDIDATE_MB_TYPE_INTER4V; |
1980 s->mb_type[i] |= CANDIDATE_MB_TYPE_INTRA; | |
1981 s->current_picture.mb_type[i]= CANDIDATE_MB_TYPE_INTRA; | |
324 | 1982 } |
1983 } | |
1984 } | |
502 | 1985 xy+=2; |
1986 i++; | |
324 | 1987 } |
1988 } | |
1989 } | |
1990 } | |
1991 | |
1708 | 1992 /** |
1993 * | |
1994 * @param truncate 1 for truncation, 0 for using intra | |
1995 */ | |
1996 void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select, | |
1997 int16_t (*mv_table)[2], int f_code, int type, int truncate) | |
324 | 1998 { |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
1999 MotionEstContext * const c= &s->me; |
1708 | 2000 int y, h_range, v_range; |
324 | 2001 |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1050
diff
changeset
|
2002 // RAL: 8 in MPEG-1, 16 in MPEG-4 |
1421 | 2003 int range = (((s->out_format == FMT_MPEG1) ? 8 : 16) << f_code); |
1708 | 2004 |
2005 if(s->msmpeg4_version) range= 16; | |
2015
3ab8f3e2ae6a
moving motion estimation specific variables from MpegEncContext -> MotionEstContext
michael
parents:
2014
diff
changeset
|
2006 if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range; |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1050
diff
changeset
|
2007 |
1708 | 2008 h_range= range; |
2009 v_range= field_select_table ? range>>1 : range; | |
2010 | |
324 | 2011 /* clip / convert to intra 16x16 type MVs */ |
2012 for(y=0; y<s->mb_height; y++){ | |
2013 int x; | |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
2014 int xy= y*s->mb_stride; |
1086 | 2015 for(x=0; x<s->mb_width; x++){ |
1177
fea03d2c4946
simplified adressing of most mb based arrays (mb_x + mb_y*s->mb_stride) now instead of mb_x + mb_y*mb_width and 1+mb_x + (1+mb_y)*(mb_width+2) and ... mixture
michaelni
parents:
1162
diff
changeset
|
2016 if (s->mb_type[xy] & type){ // RAL: "type" test added... |
1708 | 2017 if(field_select_table==NULL || field_select_table[xy] == field_select){ |
2018 if( mv_table[xy][0] >=h_range || mv_table[xy][0] <-h_range | |
2019 || mv_table[xy][1] >=v_range || mv_table[xy][1] <-v_range){ | |
1086 | 2020 |
1708 | 2021 if(truncate){ |
2022 if (mv_table[xy][0] > h_range-1) mv_table[xy][0]= h_range-1; | |
2023 else if(mv_table[xy][0] < -h_range ) mv_table[xy][0]= -h_range; | |
2024 if (mv_table[xy][1] > v_range-1) mv_table[xy][1]= v_range-1; | |
2025 else if(mv_table[xy][1] < -v_range ) mv_table[xy][1]= -v_range; | |
2026 }else{ | |
2027 s->mb_type[xy] &= ~type; | |
2028 s->mb_type[xy] |= CANDIDATE_MB_TYPE_INTRA; | |
2029 mv_table[xy][0]= | |
2030 mv_table[xy][1]= 0; | |
2031 } | |
1051
e5a9dbf597d4
mpeg1 bframe encoding patch by (Rapha¸«³l LEGRAND) with some modifications by me
michaelni
parents:
1050
diff
changeset
|
2032 } |
1086 | 2033 } |
324 | 2034 } |
2035 xy++; | |
2036 } | |
2037 } | |
2038 } |