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