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