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