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