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