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