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