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