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