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