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