731a502c256c2b86f793b5e4dbc109eb50317a5a
[libav.git] / libavcodec / mpegvideo.c
1 /*
2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
21 */
22
23 /**
24 * @file mpegvideo.c
25 * The simplest mpeg encoder (well, it was the simplest!).
26 */
27
28 #include "avcodec.h"
29 #include "dsputil.h"
30 #include "mpegvideo.h"
31 #include "faandct.h"
32 #include <limits.h>
33
34 #ifdef USE_FASTMEMCPY
35 #include "fastmemcpy.h"
36 #endif
37
38 //#undef NDEBUG
39 //#include <assert.h>
40
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 static int sse_mb(MpegEncContext *s);
62 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 #endif //CONFIG_ENCODERS
64
65 #ifdef HAVE_XVMC
66 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67 extern void XVMC_field_end(MpegEncContext *s);
68 extern void XVMC_decode_mb(MpegEncContext *s);
69 #endif
70
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
72
73
74 /* enable all paranoid tests for rounding, overflows, etc... */
75 //#define PARANOID
76
77 //#define DEBUG
78
79
80 /* for jpeg fast DCT */
81 #define CONST_BITS 14
82
83 static const uint16_t aanscales[64] = {
84 /* precomputed values scaled up by 14 bits */
85 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
86 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
87 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
88 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
91 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
92 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
93 };
94
95 static const uint8_t h263_chroma_roundtab[16] = {
96 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
97 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
98 };
99
100 static const uint8_t ff_default_chroma_qscale_table[32]={
101 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
102 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
103 };
104
105 #ifdef CONFIG_ENCODERS
106 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 static uint8_t default_fcode_tab[MAX_MV*2+1];
108
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
110
111 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
113 {
114 int qscale;
115 int shift=0;
116
117 for(qscale=qmin; qscale<=qmax; qscale++){
118 int i;
119 if (dsp->fdct == ff_jpeg_fdct_islow
120 #ifdef FAAN_POSTSCALE
121 || dsp->fdct == ff_faandct
122 #endif
123 ) {
124 for(i=0;i<64;i++) {
125 const int j= dsp->idct_permutation[i];
126 /* 16 <= qscale * quant_matrix[i] <= 7905 */
127 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
128 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
130
131 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 (qscale * quant_matrix[j]));
133 }
134 } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136 || dsp->fdct == ff_faandct
137 #endif
138 ) {
139 for(i=0;i<64;i++) {
140 const int j= dsp->idct_permutation[i];
141 /* 16 <= qscale * quant_matrix[i] <= 7905 */
142 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
143 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
145
146 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 (aanscales[i] * qscale * quant_matrix[j]));
148 }
149 } else {
150 for(i=0;i<64;i++) {
151 const int j= dsp->idct_permutation[i];
152 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153 So 16 <= qscale * quant_matrix[i] <= 7905
154 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
156 */
157 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
160
161 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
163 }
164 }
165
166 for(i=intra; i<64; i++){
167 int64_t max= 8191;
168 if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170 || dsp->fdct == ff_faandct
171 #endif
172 ) {
173 max= (8191LL*aanscales[i]) >> 14;
174 }
175 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
176 shift++;
177 }
178 }
179 }
180 if(shift){
181 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
182 }
183 }
184
185 static inline void update_qscale(MpegEncContext *s){
186 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
188
189 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
190 }
191 #endif //CONFIG_ENCODERS
192
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
194 int i;
195 int end;
196
197 st->scantable= src_scantable;
198
199 for(i=0; i<64; i++){
200 int j;
201 j = src_scantable[i];
202 st->permutated[i] = permutation[j];
203 #ifdef ARCH_POWERPC
204 st->inverse[j] = i;
205 #endif
206 }
207
208 end=-1;
209 for(i=0; i<64; i++){
210 int j;
211 j = st->permutated[i];
212 if(j>end) end=j;
213 st->raster_end[i]= end;
214 }
215 }
216
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
219 int i;
220
221 if(matrix){
222 put_bits(pb, 1, 1);
223 for(i=0;i<64;i++) {
224 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
225 }
226 }else
227 put_bits(pb, 1, 0);
228 }
229 #endif //CONFIG_ENCODERS
230
231 /* init common dct for both encoder and decoder */
232 int DCT_common_init(MpegEncContext *s)
233 {
234 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
240
241 #ifdef CONFIG_ENCODERS
242 s->dct_quantize= dct_quantize_c;
243 s->denoise_dct= denoise_dct_c;
244 #endif //CONFIG_ENCODERS
245
246 #ifdef HAVE_MMX
247 MPV_common_init_mmx(s);
248 #endif
249 #ifdef ARCH_ALPHA
250 MPV_common_init_axp(s);
251 #endif
252 #ifdef HAVE_MLIB
253 MPV_common_init_mlib(s);
254 #endif
255 #ifdef HAVE_MMI
256 MPV_common_init_mmi(s);
257 #endif
258 #ifdef ARCH_ARMV4L
259 MPV_common_init_armv4l(s);
260 #endif
261 #ifdef ARCH_POWERPC
262 MPV_common_init_ppc(s);
263 #endif
264
265 #ifdef CONFIG_ENCODERS
266 s->fast_dct_quantize= s->dct_quantize;
267
268 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
270 }
271
272 #endif //CONFIG_ENCODERS
273
274 /* load & permutate scantables
275 note: only wmv uses different ones
276 */
277 if(s->alternate_scan){
278 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
279 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
280 }else{
281 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
282 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
283 }
284 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
286
287 return 0;
288 }
289
290 static void copy_picture(Picture *dst, Picture *src){
291 *dst = *src;
292 dst->type= FF_BUFFER_TYPE_COPY;
293 }
294
295 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
296 int i;
297
298 dst->pict_type = src->pict_type;
299 dst->quality = src->quality;
300 dst->coded_picture_number = src->coded_picture_number;
301 dst->display_picture_number = src->display_picture_number;
302 // dst->reference = src->reference;
303 dst->pts = src->pts;
304 dst->interlaced_frame = src->interlaced_frame;
305 dst->top_field_first = src->top_field_first;
306
307 if(s->avctx->me_threshold){
308 if(!src->motion_val[0])
309 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
310 if(!src->mb_type)
311 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312 if(!src->ref_index[0])
313 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
316 src->motion_subsample_log2, dst->motion_subsample_log2);
317
318 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
319
320 for(i=0; i<2; i++){
321 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
323
324 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
326 }
327 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
329 }
330 }
331 }
332 }
333
334 /**
335 * allocates a Picture
336 * The pixels are allocated/set by calling get_buffer() if shared=0
337 */
338 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340 const int mb_array_size= s->mb_stride*s->mb_height;
341 const int b8_array_size= s->b8_stride*s->mb_height*2;
342 const int b4_array_size= s->b4_stride*s->mb_height*4;
343 int i;
344
345 if(shared){
346 assert(pic->data[0]);
347 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348 pic->type= FF_BUFFER_TYPE_SHARED;
349 }else{
350 int r;
351
352 assert(!pic->data[0]);
353
354 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
355
356 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
358 return -1;
359 }
360
361 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
363 return -1;
364 }
365
366 if(pic->linesize[1] != pic->linesize[2]){
367 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
368 return -1;
369 }
370
371 s->linesize = pic->linesize[0];
372 s->uvlinesize= pic->linesize[1];
373 }
374
375 if(pic->qscale_table==NULL){
376 if (s->encoding) {
377 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
378 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
380 }
381
382 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
385 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386 if(s->out_format == FMT_H264){
387 for(i=0; i<2; i++){
388 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
389 pic->motion_val[i]= pic->motion_val_base[i]+4;
390 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
391 }
392 pic->motion_subsample_log2= 2;
393 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
394 for(i=0; i<2; i++){
395 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
396 pic->motion_val[i]= pic->motion_val_base[i]+4;
397 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
398 }
399 pic->motion_subsample_log2= 3;
400 }
401 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
403 }
404 pic->qstride= s->mb_stride;
405 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
406 }
407
408 //it might be nicer if the application would keep track of these but it would require a API change
409 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
410 s->prev_pict_types[0]= s->pict_type;
411 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
413
414 return 0;
415 fail: //for the CHECKED_ALLOCZ macro
416 return -1;
417 }
418
419 /**
420 * deallocates a picture
421 */
422 static void free_picture(MpegEncContext *s, Picture *pic){
423 int i;
424
425 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
427 }
428
429 av_freep(&pic->mb_var);
430 av_freep(&pic->mc_mb_var);
431 av_freep(&pic->mb_mean);
432 av_freep(&pic->mbskip_table);
433 av_freep(&pic->qscale_table);
434 av_freep(&pic->mb_type_base);
435 av_freep(&pic->dct_coeff);
436 av_freep(&pic->pan_scan);
437 pic->mb_type= NULL;
438 for(i=0; i<2; i++){
439 av_freep(&pic->motion_val_base[i]);
440 av_freep(&pic->ref_index[i]);
441 }
442
443 if(pic->type == FF_BUFFER_TYPE_SHARED){
444 for(i=0; i<4; i++){
445 pic->base[i]=
446 pic->data[i]= NULL;
447 }
448 pic->type= 0;
449 }
450 }
451
452 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
453 int i;
454
455 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
456 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
458
459 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
461 s->rd_scratchpad= s->me.scratchpad;
462 s->b_scratchpad= s->me.scratchpad;
463 s->obmc_scratchpad= s->me.scratchpad + 16;
464 if (s->encoding) {
465 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
466 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467 if(s->avctx->noise_reduction){
468 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
469 }
470 }
471 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472 s->block= s->blocks[0];
473
474 for(i=0;i<12;i++){
475 s->pblocks[i] = (short *)(&s->block[i]);
476 }
477 return 0;
478 fail:
479 return -1; //free() through MPV_common_end()
480 }
481
482 static void free_duplicate_context(MpegEncContext *s){
483 if(s==NULL) return;
484
485 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486 av_freep(&s->me.scratchpad);
487 s->rd_scratchpad=
488 s->b_scratchpad=
489 s->obmc_scratchpad= NULL;
490
491 av_freep(&s->dct_error_sum);
492 av_freep(&s->me.map);
493 av_freep(&s->me.score_map);
494 av_freep(&s->blocks);
495 s->block= NULL;
496 }
497
498 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499 #define COPY(a) bak->a= src->a
500 COPY(allocated_edge_emu_buffer);
501 COPY(edge_emu_buffer);
502 COPY(me.scratchpad);
503 COPY(rd_scratchpad);
504 COPY(b_scratchpad);
505 COPY(obmc_scratchpad);
506 COPY(me.map);
507 COPY(me.score_map);
508 COPY(blocks);
509 COPY(block);
510 COPY(start_mb_y);
511 COPY(end_mb_y);
512 COPY(me.map_generation);
513 COPY(pb);
514 COPY(dct_error_sum);
515 COPY(dct_count[0]);
516 COPY(dct_count[1]);
517 #undef COPY
518 }
519
520 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
521 MpegEncContext bak;
522 int i;
523 //FIXME copy only needed parts
524 //START_TIMER
525 backup_duplicate_context(&bak, dst);
526 memcpy(dst, src, sizeof(MpegEncContext));
527 backup_duplicate_context(dst, &bak);
528 for(i=0;i<12;i++){
529 dst->pblocks[i] = (short *)(&dst->block[i]);
530 }
531 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
532 }
533
534 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535 #define COPY(a) dst->a= src->a
536 COPY(pict_type);
537 COPY(current_picture);
538 COPY(f_code);
539 COPY(b_code);
540 COPY(qscale);
541 COPY(lambda);
542 COPY(lambda2);
543 COPY(picture_in_gop_number);
544 COPY(gop_picture_number);
545 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
546 COPY(progressive_frame); //FIXME don't set in encode_header
547 COPY(partitioned_frame); //FIXME don't set in encode_header
548 #undef COPY
549 }
550
551 /**
552 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553 * the changed fields will not depend upon the prior state of the MpegEncContext.
554 */
555 static void MPV_common_defaults(MpegEncContext *s){
556 s->y_dc_scale_table=
557 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558 s->chroma_qscale_table= ff_default_chroma_qscale_table;
559 s->progressive_frame= 1;
560 s->progressive_sequence= 1;
561 s->picture_structure= PICT_FRAME;
562
563 s->coded_picture_number = 0;
564 s->picture_number = 0;
565 s->input_picture_number = 0;
566
567 s->picture_in_gop_number = 0;
568
569 s->f_code = 1;
570 s->b_code = 1;
571 }
572
573 /**
574 * sets the given MpegEncContext to defaults for decoding.
575 * the changed fields will not depend upon the prior state of the MpegEncContext.
576 */
577 void MPV_decode_defaults(MpegEncContext *s){
578 MPV_common_defaults(s);
579 }
580
581 /**
582 * sets the given MpegEncContext to defaults for encoding.
583 * the changed fields will not depend upon the prior state of the MpegEncContext.
584 */
585
586 #ifdef CONFIG_ENCODERS
587 static void MPV_encode_defaults(MpegEncContext *s){
588 static int done=0;
589
590 MPV_common_defaults(s);
591
592 if(!done){
593 int i;
594 done=1;
595
596 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
598
599 for(i=-16; i<16; i++){
600 default_fcode_tab[i + MAX_MV]= 1;
601 }
602 }
603 s->me.mv_penalty= default_mv_penalty;
604 s->fcode_tab= default_fcode_tab;
605 }
606 #endif //CONFIG_ENCODERS
607
608 /**
609 * init common structure for both encoder and decoder.
610 * this assumes that some variables like width/height are already set
611 */
612 int MPV_common_init(MpegEncContext *s)
613 {
614 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
615
616 if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
618 return -1;
619 }
620
621 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
622 return -1;
623
624 dsputil_init(&s->dsp, s->avctx);
625 DCT_common_init(s);
626
627 s->flags= s->avctx->flags;
628 s->flags2= s->avctx->flags2;
629
630 s->mb_width = (s->width + 15) / 16;
631 s->mb_height = (s->height + 15) / 16;
632 s->mb_stride = s->mb_width + 1;
633 s->b8_stride = s->mb_width*2 + 1;
634 s->b4_stride = s->mb_width*4 + 1;
635 mb_array_size= s->mb_height * s->mb_stride;
636 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
637
638 /* set chroma shifts */
639 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640 &(s->chroma_y_shift) );
641
642 /* set default edge pos, will be overriden in decode_header if needed */
643 s->h_edge_pos= s->mb_width*16;
644 s->v_edge_pos= s->mb_height*16;
645
646 s->mb_num = s->mb_width * s->mb_height;
647
648 s->block_wrap[0]=
649 s->block_wrap[1]=
650 s->block_wrap[2]=
651 s->block_wrap[3]= s->b8_stride;
652 s->block_wrap[4]=
653 s->block_wrap[5]= s->mb_stride;
654
655 y_size = s->b8_stride * (2 * s->mb_height + 1);
656 c_size = s->mb_stride * (s->mb_height + 1);
657 yc_size = y_size + 2 * c_size;
658
659 /* convert fourcc to upper case */
660 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
661 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
664
665 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
666 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
669
670 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
671
672 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673 for(y=0; y<s->mb_height; y++){
674 for(x=0; x<s->mb_width; x++){
675 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
676 }
677 }
678 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
679
680 if (s->encoding) {
681 /* Allocate MV tables */
682 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
683 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
684 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
685 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
688 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
689 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
690 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
691 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
694
695 if(s->msmpeg4_version){
696 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
697 }
698 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
699
700 /* Allocate MB type table */
701 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
702
703 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
704
705 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
711
712 if(s->avctx->noise_reduction){
713 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
714 }
715 }
716 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
717
718 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
719
720 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721 /* interlaced direct mode decoding tables */
722 for(i=0; i<2; i++){
723 int j, k;
724 for(j=0; j<2; j++){
725 for(k=0; k<2; k++){
726 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
727 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
728 }
729 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
730 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
731 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
732 }
733 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
734 }
735 }
736 if (s->out_format == FMT_H263) {
737 /* ac values */
738 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741 s->ac_val[2] = s->ac_val[1] + c_size;
742
743 /* cbp values */
744 CHECKED_ALLOCZ(s->coded_block_base, y_size);
745 s->coded_block= s->coded_block_base + s->b8_stride + 1;
746
747 /* cbp, ac_pred, pred_dir */
748 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
749 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
750 }
751
752 if (s->h263_pred || s->h263_plus || !s->encoding) {
753 /* dc values */
754 //MN: we need these for error resilience of intra-frames
755 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758 s->dc_val[2] = s->dc_val[1] + c_size;
759 for(i=0;i<yc_size;i++)
760 s->dc_val_base[i] = 1024;
761 }
762
763 /* which mb is a intra block */
764 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765 memset(s->mbintra_table, 1, mb_array_size);
766
767 /* init macroblock skip table */
768 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769 //Note the +1 is for a quicker mpeg4 slice_end detection
770 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
771
772 s->parse_context.state= -1;
773 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
777 }
778
779 s->context_initialized = 1;
780
781 s->thread_context[0]= s;
782 for(i=1; i<s->avctx->thread_count; i++){
783 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
785 }
786
787 for(i=0; i<s->avctx->thread_count; i++){
788 if(init_duplicate_context(s->thread_context[i], s) < 0)
789 goto fail;
790 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
792 }
793
794 return 0;
795 fail:
796 MPV_common_end(s);
797 return -1;
798 }
799
800 /* init common structure for both encoder and decoder */
801 void MPV_common_end(MpegEncContext *s)
802 {
803 int i, j, k;
804
805 for(i=0; i<s->avctx->thread_count; i++){
806 free_duplicate_context(s->thread_context[i]);
807 }
808 for(i=1; i<s->avctx->thread_count; i++){
809 av_freep(&s->thread_context[i]);
810 }
811
812 av_freep(&s->parse_context.buffer);
813 s->parse_context.buffer_size=0;
814
815 av_freep(&s->mb_type);
816 av_freep(&s->p_mv_table_base);
817 av_freep(&s->b_forw_mv_table_base);
818 av_freep(&s->b_back_mv_table_base);
819 av_freep(&s->b_bidir_forw_mv_table_base);
820 av_freep(&s->b_bidir_back_mv_table_base);
821 av_freep(&s->b_direct_mv_table_base);
822 s->p_mv_table= NULL;
823 s->b_forw_mv_table= NULL;
824 s->b_back_mv_table= NULL;
825 s->b_bidir_forw_mv_table= NULL;
826 s->b_bidir_back_mv_table= NULL;
827 s->b_direct_mv_table= NULL;
828 for(i=0; i<2; i++){
829 for(j=0; j<2; j++){
830 for(k=0; k<2; k++){
831 av_freep(&s->b_field_mv_table_base[i][j][k]);
832 s->b_field_mv_table[i][j][k]=NULL;
833 }
834 av_freep(&s->b_field_select_table[i][j]);
835 av_freep(&s->p_field_mv_table_base[i][j]);
836 s->p_field_mv_table[i][j]=NULL;
837 }
838 av_freep(&s->p_field_select_table[i]);
839 }
840
841 av_freep(&s->dc_val_base);
842 av_freep(&s->ac_val_base);
843 av_freep(&s->coded_block_base);
844 av_freep(&s->mbintra_table);
845 av_freep(&s->cbp_table);
846 av_freep(&s->pred_dir_table);
847
848 av_freep(&s->mbskip_table);
849 av_freep(&s->prev_pict_types);
850 av_freep(&s->bitstream_buffer);
851 s->allocated_bitstream_buffer_size=0;
852
853 av_freep(&s->avctx->stats_out);
854 av_freep(&s->ac_stats);
855 av_freep(&s->error_status_table);
856 av_freep(&s->mb_index2xy);
857 av_freep(&s->lambda_table);
858 av_freep(&s->q_intra_matrix);
859 av_freep(&s->q_inter_matrix);
860 av_freep(&s->q_intra_matrix16);
861 av_freep(&s->q_inter_matrix16);
862 av_freep(&s->input_picture);
863 av_freep(&s->reordered_input_picture);
864 av_freep(&s->dct_offset);
865
866 if(s->picture){
867 for(i=0; i<MAX_PICTURE_COUNT; i++){
868 free_picture(s, &s->picture[i]);
869 }
870 }
871 av_freep(&s->picture);
872 s->context_initialized = 0;
873 s->last_picture_ptr=
874 s->next_picture_ptr=
875 s->current_picture_ptr= NULL;
876 s->linesize= s->uvlinesize= 0;
877
878 for(i=0; i<3; i++)
879 av_freep(&s->visualization_buffer[i]);
880
881 avcodec_default_free_buffers(s->avctx);
882 }
883
884 #ifdef CONFIG_ENCODERS
885
886 /* init video encoder */
887 int MPV_encode_init(AVCodecContext *avctx)
888 {
889 MpegEncContext *s = avctx->priv_data;
890 int i;
891 int chroma_h_shift, chroma_v_shift;
892
893 MPV_encode_defaults(s);
894
895 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
897 return -1;
898 }
899
900 if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901 if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
903 return -1;
904 }
905 }else{
906 if(avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL && avctx->pix_fmt != PIX_FMT_YUV420P){
907 av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
908 return -1;
909 }
910 }
911
912 s->bit_rate = avctx->bit_rate;
913 s->width = avctx->width;
914 s->height = avctx->height;
915 if(avctx->gop_size > 600){
916 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
917 avctx->gop_size=600;
918 }
919 s->gop_size = avctx->gop_size;
920 s->avctx = avctx;
921 s->flags= avctx->flags;
922 s->flags2= avctx->flags2;
923 s->max_b_frames= avctx->max_b_frames;
924 s->codec_id= avctx->codec->id;
925 s->luma_elim_threshold = avctx->luma_elim_threshold;
926 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927 s->strict_std_compliance= avctx->strict_std_compliance;
928 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930 s->mpeg_quant= avctx->mpeg_quant;
931 s->rtp_mode= !!avctx->rtp_payload_size;
932 s->intra_dc_precision= avctx->intra_dc_precision;
933 s->user_specified_pts = AV_NOPTS_VALUE;
934
935 if (s->gop_size <= 1) {
936 s->intra_only = 1;
937 s->gop_size = 12;
938 } else {
939 s->intra_only = 0;
940 }
941
942 s->me_method = avctx->me_method;
943
944 /* Fixed QSCALE */
945 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
946
947 s->adaptive_quant= ( s->avctx->lumi_masking
948 || s->avctx->dark_masking
949 || s->avctx->temporal_cplx_masking
950 || s->avctx->spatial_cplx_masking
951 || s->avctx->p_masking
952 || s->avctx->border_masking
953 || (s->flags&CODEC_FLAG_QP_RD))
954 && !s->fixed_qscale;
955
956 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
959
960 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
962 return -1;
963 }
964
965 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
967 }
968
969 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
971 return -1;
972 }
973
974 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
976 return -1;
977 }
978
979 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
982
983 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
984 }
985
986 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
989 return -1;
990 }
991
992 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
994 return -1;
995 }
996
997 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
999 return -1;
1000 }
1001
1002 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1004 return -1;
1005 }
1006
1007 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1009 return -1;
1010 }
1011
1012 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1014 return -1;
1015 }
1016
1017 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1018 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1020 return -1;
1021 }
1022
1023 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1025 return -1;
1026 }
1027
1028 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1030 return -1;
1031 }
1032
1033 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1035 return -1;
1036 }
1037
1038 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1040 return -1;
1041 }
1042
1043 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1044 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1047 return -1;
1048 }
1049
1050 if(s->avctx->thread_count > 1)
1051 s->rtp_mode= 1;
1052
1053 if(!avctx->time_base.den || !avctx->time_base.num){
1054 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1055 return -1;
1056 }
1057
1058 i= (INT_MAX/2+128)>>8;
1059 if(avctx->me_threshold >= i){
1060 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1061 return -1;
1062 }
1063 if(avctx->mb_threshold >= i){
1064 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1065 return -1;
1066 }
1067
1068 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1069 av_log(avctx, AV_LOG_ERROR, "b_frame_strategy must be 0 on the second pass");
1070 return -1;
1071 }
1072
1073 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1074 if(i > 1){
1075 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1076 avctx->time_base.den /= i;
1077 avctx->time_base.num /= i;
1078 // return -1;
1079 }
1080
1081 if(s->codec_id==CODEC_ID_MJPEG){
1082 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1083 s->inter_quant_bias= 0;
1084 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1085 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1086 s->inter_quant_bias= 0;
1087 }else{
1088 s->intra_quant_bias=0;
1089 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1090 }
1091
1092 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1093 s->intra_quant_bias= avctx->intra_quant_bias;
1094 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1095 s->inter_quant_bias= avctx->inter_quant_bias;
1096
1097 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1098
1099 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1100 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1101 return -1;
1102 }
1103 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1104
1105 switch(avctx->codec->id) {
1106 case CODEC_ID_MPEG1VIDEO:
1107 s->out_format = FMT_MPEG1;
1108 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1109 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1110 break;
1111 case CODEC_ID_MPEG2VIDEO:
1112 s->out_format = FMT_MPEG1;
1113 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1114 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1115 s->rtp_mode= 1;
1116 break;
1117 case CODEC_ID_LJPEG:
1118 case CODEC_ID_JPEGLS:
1119 case CODEC_ID_MJPEG:
1120 s->out_format = FMT_MJPEG;
1121 s->intra_only = 1; /* force intra only for jpeg */
1122 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1123 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1124 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1125 s->mjpeg_vsample[1] = 1;
1126 s->mjpeg_vsample[2] = 1;
1127 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1128 s->mjpeg_hsample[1] = 1;
1129 s->mjpeg_hsample[2] = 1;
1130 if (mjpeg_init(s) < 0)
1131 return -1;
1132 avctx->delay=0;
1133 s->low_delay=1;
1134 break;
1135 case CODEC_ID_H261:
1136 s->out_format = FMT_H261;
1137 avctx->delay=0;
1138 s->low_delay=1;
1139 break;
1140 case CODEC_ID_H263:
1141 if (h263_get_picture_format(s->width, s->height) == 7) {
1142 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1143 return -1;
1144 }
1145 s->out_format = FMT_H263;
1146 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1147 avctx->delay=0;
1148 s->low_delay=1;
1149 break;
1150 case CODEC_ID_H263P:
1151 s->out_format = FMT_H263;
1152 s->h263_plus = 1;
1153 /* Fx */
1154 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1155 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1156 s->modified_quant= s->h263_aic;
1157 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1158 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1159 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1160 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1161 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1162
1163 /* /Fx */
1164 /* These are just to be sure */
1165 avctx->delay=0;
1166 s->low_delay=1;
1167 break;
1168 case CODEC_ID_FLV1:
1169 s->out_format = FMT_H263;
1170 s->h263_flv = 2; /* format = 1; 11-bit codes */
1171 s->unrestricted_mv = 1;
1172 s->rtp_mode=0; /* don't allow GOB */
1173 avctx->delay=0;
1174 s->low_delay=1;
1175 break;
1176 case CODEC_ID_RV10:
1177 s->out_format = FMT_H263;
1178 avctx->delay=0;
1179 s->low_delay=1;
1180 break;
1181 case CODEC_ID_RV20:
1182 s->out_format = FMT_H263;
1183 avctx->delay=0;
1184 s->low_delay=1;
1185 s->modified_quant=1;
1186 s->h263_aic=1;
1187 s->h263_plus=1;
1188 s->loop_filter=1;
1189 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1190 break;
1191 case CODEC_ID_MPEG4:
1192 s->out_format = FMT_H263;
1193 s->h263_pred = 1;
1194 s->unrestricted_mv = 1;
1195 s->low_delay= s->max_b_frames ? 0 : 1;
1196 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1197 break;
1198 case CODEC_ID_MSMPEG4V1:
1199 s->out_format = FMT_H263;
1200 s->h263_msmpeg4 = 1;
1201 s->h263_pred = 1;
1202 s->unrestricted_mv = 1;
1203 s->msmpeg4_version= 1;
1204 avctx->delay=0;
1205 s->low_delay=1;
1206 break;
1207 case CODEC_ID_MSMPEG4V2:
1208 s->out_format = FMT_H263;
1209 s->h263_msmpeg4 = 1;
1210 s->h263_pred = 1;
1211 s->unrestricted_mv = 1;
1212 s->msmpeg4_version= 2;
1213 avctx->delay=0;
1214 s->low_delay=1;
1215 break;
1216 case CODEC_ID_MSMPEG4V3:
1217 s->out_format = FMT_H263;
1218 s->h263_msmpeg4 = 1;
1219 s->h263_pred = 1;
1220 s->unrestricted_mv = 1;
1221 s->msmpeg4_version= 3;
1222 s->flipflop_rounding=1;
1223 avctx->delay=0;
1224 s->low_delay=1;
1225 break;
1226 case CODEC_ID_WMV1:
1227 s->out_format = FMT_H263;
1228 s->h263_msmpeg4 = 1;
1229 s->h263_pred = 1;
1230 s->unrestricted_mv = 1;
1231 s->msmpeg4_version= 4;
1232 s->flipflop_rounding=1;
1233 avctx->delay=0;
1234 s->low_delay=1;
1235 break;
1236 case CODEC_ID_WMV2:
1237 s->out_format = FMT_H263;
1238 s->h263_msmpeg4 = 1;
1239 s->h263_pred = 1;
1240 s->unrestricted_mv = 1;
1241 s->msmpeg4_version= 5;
1242 s->flipflop_rounding=1;
1243 avctx->delay=0;
1244 s->low_delay=1;
1245 break;
1246 default:
1247 return -1;
1248 }
1249
1250 avctx->has_b_frames= !s->low_delay;
1251
1252 s->encoding = 1;
1253
1254 /* init */
1255 if (MPV_common_init(s) < 0)
1256 return -1;
1257
1258 if(s->modified_quant)
1259 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1260 s->progressive_frame=
1261 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1262 s->quant_precision=5;
1263
1264 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1265 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1266
1267 #ifdef CONFIG_H261_ENCODER
1268 if (s->out_format == FMT_H261)
1269 ff_h261_encode_init(s);
1270 #endif
1271 if (s->out_format == FMT_H263)
1272 h263_encode_init(s);
1273 if(s->msmpeg4_version)
1274 ff_msmpeg4_encode_init(s);
1275 if (s->out_format == FMT_MPEG1)
1276 ff_mpeg1_encode_init(s);
1277
1278 /* init q matrix */
1279 for(i=0;i<64;i++) {
1280 int j= s->dsp.idct_permutation[i];
1281 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1282 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1283 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1284 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1285 s->intra_matrix[j] =
1286 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1287 }else
1288 { /* mpeg1/2 */
1289 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1290 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1291 }
1292 if(s->avctx->intra_matrix)
1293 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1294 if(s->avctx->inter_matrix)
1295 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1296 }
1297
1298 /* precompute matrix */
1299 /* for mjpeg, we do include qscale in the matrix */
1300 if (s->out_format != FMT_MJPEG) {
1301 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1302 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1303 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1304 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1305 }
1306
1307 if(ff_rate_control_init(s) < 0)
1308 return -1;
1309
1310 return 0;
1311 }
1312
1313 int MPV_encode_end(AVCodecContext *avctx)
1314 {
1315 MpegEncContext *s = avctx->priv_data;
1316
1317 #ifdef STATS
1318 print_stats();
1319 #endif
1320
1321 ff_rate_control_uninit(s);
1322
1323 MPV_common_end(s);
1324 if (s->out_format == FMT_MJPEG)
1325 mjpeg_close(s);
1326
1327 av_freep(&avctx->extradata);
1328
1329 return 0;
1330 }
1331
1332 #endif //CONFIG_ENCODERS
1333
1334 void init_rl(RLTable *rl, int use_static)
1335 {
1336 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1337 uint8_t index_run[MAX_RUN+1];
1338 int last, run, level, start, end, i;
1339
1340 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1341 if(use_static && rl->max_level[0])
1342 return;
1343
1344 /* compute max_level[], max_run[] and index_run[] */
1345 for(last=0;last<2;last++) {
1346 if (last == 0) {
1347 start = 0;
1348 end = rl->last;
1349 } else {
1350 start = rl->last;
1351 end = rl->n;
1352 }
1353
1354 memset(max_level, 0, MAX_RUN + 1);
1355 memset(max_run, 0, MAX_LEVEL + 1);
1356 memset(index_run, rl->n, MAX_RUN + 1);
1357 for(i=start;i<end;i++) {
1358 run = rl->table_run[i];
1359 level = rl->table_level[i];
1360 if (index_run[run] == rl->n)
1361 index_run[run] = i;
1362 if (level > max_level[run])
1363 max_level[run] = level;
1364 if (run > max_run[level])
1365 max_run[level] = run;
1366 }
1367 if(use_static)
1368 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1369 else
1370 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1371 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1372 if(use_static)
1373 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1374 else
1375 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1376 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1377 if(use_static)
1378 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1379 else
1380 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1381 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1382 }
1383 }
1384
1385 /* draw the edges of width 'w' of an image of size width, height */
1386 //FIXME check that this is ok for mpeg4 interlaced
1387 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1388 {
1389 uint8_t *ptr, *last_line;
1390 int i;
1391
1392 last_line = buf + (height - 1) * wrap;
1393 for(i=0;i<w;i++) {
1394 /* top and bottom */
1395 memcpy(buf - (i + 1) * wrap, buf, width);
1396 memcpy(last_line + (i + 1) * wrap, last_line, width);
1397 }
1398 /* left and right */
1399 ptr = buf;
1400 for(i=0;i<height;i++) {
1401 memset(ptr - w, ptr[0], w);
1402 memset(ptr + width, ptr[width-1], w);
1403 ptr += wrap;
1404 }
1405 /* corners */
1406 for(i=0;i<w;i++) {
1407 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1408 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1409 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1410 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1411 }
1412 }
1413
1414 int ff_find_unused_picture(MpegEncContext *s, int shared){
1415 int i;
1416
1417 if(shared){
1418 for(i=0; i<MAX_PICTURE_COUNT; i++){
1419 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1420 }
1421 }else{
1422 for(i=0; i<MAX_PICTURE_COUNT; i++){
1423 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1424 }
1425 for(i=0; i<MAX_PICTURE_COUNT; i++){
1426 if(s->picture[i].data[0]==NULL) return i;
1427 }
1428 }
1429
1430 assert(0);
1431 return -1;
1432 }
1433
1434 static void update_noise_reduction(MpegEncContext *s){
1435 int intra, i;
1436
1437 for(intra=0; intra<2; intra++){
1438 if(s->dct_count[intra] > (1<<16)){
1439 for(i=0; i<64; i++){
1440 s->dct_error_sum[intra][i] >>=1;
1441 }
1442 s->dct_count[intra] >>= 1;
1443 }
1444
1445 for(i=0; i<64; i++){
1446 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1447 }
1448 }
1449 }
1450
1451 /**
1452 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1453 */
1454 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1455 {
1456 int i;
1457 AVFrame *pic;
1458 s->mb_skipped = 0;
1459
1460 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1461
1462 /* mark&release old frames */
1463 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1464 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1465
1466 /* release forgotten pictures */
1467 /* if(mpeg124/h263) */
1468 if(!s->encoding){
1469 for(i=0; i<MAX_PICTURE_COUNT; i++){
1470 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1471 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1472 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1473 }
1474 }
1475 }
1476 }
1477 alloc:
1478 if(!s->encoding){
1479 /* release non reference frames */
1480 for(i=0; i<MAX_PICTURE_COUNT; i++){
1481 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1482 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1483 }
1484 }
1485
1486 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1487 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1488 else{
1489 i= ff_find_unused_picture(s, 0);
1490 pic= (AVFrame*)&s->picture[i];
1491 }
1492
1493 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1494 && !s->dropable ? 3 : 0;
1495
1496 pic->coded_picture_number= s->coded_picture_number++;
1497
1498 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1499 return -1;
1500
1501 s->current_picture_ptr= (Picture*)pic;
1502 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1503 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1504 }
1505
1506 s->current_picture_ptr->pict_type= s->pict_type;
1507 // if(s->flags && CODEC_FLAG_QSCALE)
1508 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1509 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1510
1511 copy_picture(&s->current_picture, s->current_picture_ptr);
1512
1513 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1514 if (s->pict_type != B_TYPE) {
1515 s->last_picture_ptr= s->next_picture_ptr;
1516 if(!s->dropable)
1517 s->next_picture_ptr= s->current_picture_ptr;
1518 }
1519 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1520 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1521 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1522 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1523 s->pict_type, s->dropable);*/
1524
1525 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1526 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1527
1528 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1529 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1530 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1531 goto alloc;
1532 }
1533
1534 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1535
1536 if(s->picture_structure!=PICT_FRAME){
1537 int i;
1538 for(i=0; i<4; i++){
1539 if(s->picture_structure == PICT_BOTTOM_FIELD){
1540 s->current_picture.data[i] += s->current_picture.linesize[i];
1541 }
1542 s->current_picture.linesize[i] *= 2;
1543 s->last_picture.linesize[i] *=2;
1544 s->next_picture.linesize[i] *=2;
1545 }
1546 }
1547 }
1548
1549 s->hurry_up= s->avctx->hurry_up;
1550 s->error_resilience= avctx->error_resilience;
1551
1552 /* set dequantizer, we can't do it during init as it might change for mpeg4
1553 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1554 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1555 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1556 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1557 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1558 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1559 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1560 }else{
1561 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1562 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1563 }
1564
1565 if(s->dct_error_sum){
1566 assert(s->avctx->noise_reduction && s->encoding);
1567
1568 update_noise_reduction(s);
1569 }
1570
1571 #ifdef HAVE_XVMC
1572 if(s->avctx->xvmc_acceleration)
1573 return XVMC_field_start(s, avctx);
1574 #endif
1575 return 0;
1576 }
1577
1578 /* generic function for encode/decode called after a frame has been coded/decoded */
1579 void MPV_frame_end(MpegEncContext *s)
1580 {
1581 int i;
1582 /* draw edge for correct motion prediction if outside */
1583 #ifdef HAVE_XVMC
1584 //just to make sure that all data is rendered.
1585 if(s->avctx->xvmc_acceleration){
1586 XVMC_field_end(s);
1587 }else
1588 #endif
1589 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1590 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1591 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1592 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1593 }
1594 emms_c();
1595
1596 s->last_pict_type = s->pict_type;
1597 if(s->pict_type!=B_TYPE){
1598 s->last_non_b_pict_type= s->pict_type;
1599 }
1600 #if 0
1601 /* copy back current_picture variables */
1602 for(i=0; i<MAX_PICTURE_COUNT; i++){
1603 if(s->picture[i].data[0] == s->current_picture.data[0]){
1604 s->picture[i]= s->current_picture;
1605 break;
1606 }
1607 }
1608 assert(i<MAX_PICTURE_COUNT);
1609 #endif
1610
1611 if(s->encoding){
1612 /* release non-reference frames */
1613 for(i=0; i<MAX_PICTURE_COUNT; i++){
1614 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1615 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1616 }
1617 }
1618 }
1619 // clear copies, to avoid confusion
1620 #if 0
1621 memset(&s->last_picture, 0, sizeof(Picture));
1622 memset(&s->next_picture, 0, sizeof(Picture));
1623 memset(&s->current_picture, 0, sizeof(Picture));
1624 #endif
1625 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1626 }
1627
1628 /**
1629 * draws an line from (ex, ey) -> (sx, sy).
1630 * @param w width of the image
1631 * @param h height of the image
1632 * @param stride stride/linesize of the image
1633 * @param color color of the arrow
1634 */
1635 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1636 int t, x, y, fr, f;
1637
1638 sx= clip(sx, 0, w-1);
1639 sy= clip(sy, 0, h-1);
1640 ex= clip(ex, 0, w-1);
1641 ey= clip(ey, 0, h-1);
1642
1643 buf[sy*stride + sx]+= color;
1644
1645 if(ABS(ex - sx) > ABS(ey - sy)){
1646 if(sx > ex){
1647 t=sx; sx=ex; ex=t;
1648 t=sy; sy=ey; ey=t;
1649 }
1650 buf+= sx + sy*stride;
1651 ex-= sx;
1652 f= ((ey-sy)<<16)/ex;
1653 for(x= 0; x <= ex; x++){
1654 y = (x*f)>>16;
1655 fr= (x*f)&0xFFFF;
1656 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1657 buf[(y+1)*stride + x]+= (color* fr )>>16;
1658 }
1659 }else{
1660 if(sy > ey){
1661 t=sx; sx=ex; ex=t;
1662 t=sy; sy=ey; ey=t;
1663 }
1664 buf+= sx + sy*stride;
1665 ey-= sy;
1666 if(ey) f= ((ex-sx)<<16)/ey;
1667 else f= 0;
1668 for(y= 0; y <= ey; y++){
1669 x = (y*f)>>16;
1670 fr= (y*f)&0xFFFF;
1671 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1672 buf[y*stride + x+1]+= (color* fr )>>16;;
1673 }
1674 }
1675 }
1676
1677 /**
1678 * draws an arrow from (ex, ey) -> (sx, sy).
1679 * @param w width of the image
1680 * @param h height of the image
1681 * @param stride stride/linesize of the image
1682 * @param color color of the arrow
1683 */
1684 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1685 int dx,dy;
1686
1687 sx= clip(sx, -100, w+100);
1688 sy= clip(sy, -100, h+100);
1689 ex= clip(ex, -100, w+100);
1690 ey= clip(ey, -100, h+100);
1691
1692 dx= ex - sx;
1693 dy= ey - sy;
1694
1695 if(dx*dx + dy*dy > 3*3){
1696 int rx= dx + dy;
1697 int ry= -dx + dy;
1698 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1699
1700 //FIXME subpixel accuracy
1701 rx= ROUNDED_DIV(rx*3<<4, length);
1702 ry= ROUNDED_DIV(ry*3<<4, length);
1703
1704 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1705 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1706 }
1707 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1708 }
1709
1710 /**
1711 * prints debuging info for the given picture.
1712 */
1713 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1714
1715 if(!pict || !pict->mb_type) return;
1716
1717 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1718 int x,y;
1719
1720 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1721 switch (pict->pict_type) {
1722 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1723 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1724 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1725 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1726 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1727 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1728 }
1729 for(y=0; y<s->mb_height; y++){
1730 for(x=0; x<s->mb_width; x++){
1731 if(s->avctx->debug&FF_DEBUG_SKIP){
1732 int count= s->mbskip_table[x + y*s->mb_stride];
1733 if(count>9) count=9;
1734 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1735 }
1736 if(s->avctx->debug&FF_DEBUG_QP){
1737 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1738 }
1739 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1740 int mb_type= pict->mb_type[x + y*s->mb_stride];
1741 //Type & MV direction
1742 if(IS_PCM(mb_type))
1743 av_log(s->avctx, AV_LOG_DEBUG, "P");
1744 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1745 av_log(s->avctx, AV_LOG_DEBUG, "A");
1746 else if(IS_INTRA4x4(mb_type))
1747 av_log(s->avctx, AV_LOG_DEBUG, "i");
1748 else if(IS_INTRA16x16(mb_type))
1749 av_log(s->avctx, AV_LOG_DEBUG, "I");
1750 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1751 av_log(s->avctx, AV_LOG_DEBUG, "d");
1752 else if(IS_DIRECT(mb_type))
1753 av_log(s->avctx, AV_LOG_DEBUG, "D");
1754 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1755 av_log(s->avctx, AV_LOG_DEBUG, "g");
1756 else if(IS_GMC(mb_type))
1757 av_log(s->avctx, AV_LOG_DEBUG, "G");
1758 else if(IS_SKIP(mb_type))
1759 av_log(s->avctx, AV_LOG_DEBUG, "S");
1760 else if(!USES_LIST(mb_type, 1))
1761 av_log(s->avctx, AV_LOG_DEBUG, ">");
1762 else if(!USES_LIST(mb_type, 0))
1763 av_log(s->avctx, AV_LOG_DEBUG, "<");
1764 else{
1765 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1766 av_log(s->avctx, AV_LOG_DEBUG, "X");
1767 }
1768
1769 //segmentation
1770 if(IS_8X8(mb_type))
1771 av_log(s->avctx, AV_LOG_DEBUG, "+");
1772 else if(IS_16X8(mb_type))
1773 av_log(s->avctx, AV_LOG_DEBUG, "-");
1774 else if(IS_8X16(mb_type))
1775 av_log(s->avctx, AV_LOG_DEBUG, "|");
1776 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1777 av_log(s->avctx, AV_LOG_DEBUG, " ");
1778 else
1779 av_log(s->avctx, AV_LOG_DEBUG, "?");
1780
1781
1782 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1783 av_log(s->avctx, AV_LOG_DEBUG, "=");
1784 else
1785 av_log(s->avctx, AV_LOG_DEBUG, " ");
1786 }
1787 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1788 }
1789 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1790 }
1791 }
1792
1793 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1794 const int shift= 1 + s->quarter_sample;
1795 int mb_y;
1796 uint8_t *ptr;
1797 int i;
1798 int h_chroma_shift, v_chroma_shift;
1799 const int width = s->avctx->width;
1800 const int height= s->avctx->height;
1801 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1802 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1803 s->low_delay=0; //needed to see the vectors without trashing the buffers
1804
1805 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1806 for(i=0; i<3; i++){
1807 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1808 pict->data[i]= s->visualization_buffer[i];
1809 }
1810 pict->type= FF_BUFFER_TYPE_COPY;
1811 ptr= pict->data[0];
1812
1813 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1814 int mb_x;
1815 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1816 const int mb_index= mb_x + mb_y*s->mb_stride;
1817 if((s->avctx->debug_mv) && pict->motion_val){
1818 int type;
1819 for(type=0; type<3; type++){
1820 int direction = 0;
1821 switch (type) {
1822 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1823 continue;
1824 direction = 0;
1825 break;
1826 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1827 continue;
1828 direction = 0;
1829 break;
1830 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1831 continue;
1832 direction = 1;
1833 break;
1834 }
1835 if(!USES_LIST(pict->mb_type[mb_index], direction))
1836 continue;
1837
1838 if(IS_8X8(pict->mb_type[mb_index])){
1839 int i;
1840 for(i=0; i<4; i++){
1841 int sx= mb_x*16 + 4 + 8*(i&1);
1842 int sy= mb_y*16 + 4 + 8*(i>>1);
1843 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1844 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1845 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1846 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1847 }
1848 }else if(IS_16X8(pict->mb_type[mb_index])){
1849 int i;
1850 for(i=0; i<2; i++){
1851 int sx=mb_x*16 + 8;
1852 int sy=mb_y*16 + 4 + 8*i;
1853 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1854 int mx=(pict->motion_val[direction][xy][0]>>shift);
1855 int my=(pict->motion_val[direction][xy][1]>>shift);
1856
1857 if(IS_INTERLACED(pict->mb_type[mb_index]))
1858 my*=2;
1859
1860 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1861 }
1862 }else if(IS_8X16(pict->mb_type[mb_index])){
1863 int i;
1864 for(i=0; i<2; i++){
1865 int sx=mb_x*16 + 4 + 8*i;
1866 int sy=mb_y*16 + 8;
1867 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1868 int mx=(pict->motion_val[direction][xy][0]>>shift);
1869 int my=(pict->motion_val[direction][xy][1]>>shift);
1870
1871 if(IS_INTERLACED(pict->mb_type[mb_index]))
1872 my*=2;
1873
1874 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1875 }
1876 }else{
1877 int sx= mb_x*16 + 8;
1878 int sy= mb_y*16 + 8;
1879 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1880 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1881 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1882 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1883 }
1884 }
1885 }
1886 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1887 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1888 int y;
1889 for(y=0; y<8; y++){
1890 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1891 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1892 }
1893 }
1894 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1895 int mb_type= pict->mb_type[mb_index];
1896 uint64_t u,v;
1897 int y;
1898 #define COLOR(theta, r)\
1899 u= (int)(128 + r*cos(theta*3.141592/180));\
1900 v= (int)(128 + r*sin(theta*3.141592/180));
1901
1902
1903 u=v=128;
1904 if(IS_PCM(mb_type)){
1905 COLOR(120,48)
1906 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1907 COLOR(30,48)
1908 }else if(IS_INTRA4x4(mb_type)){
1909 COLOR(90,48)
1910 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1911 // COLOR(120,48)
1912 }else if(IS_DIRECT(mb_type)){
1913 COLOR(150,48)
1914 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1915 COLOR(170,48)
1916 }else if(IS_GMC(mb_type)){
1917 COLOR(190,48)
1918 }else if(IS_SKIP(mb_type)){
1919 // COLOR(180,48)
1920 }else if(!USES_LIST(mb_type, 1)){
1921 COLOR(240,48)
1922 }else if(!USES_LIST(mb_type, 0)){
1923 COLOR(0,48)
1924 }else{
1925 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1926 COLOR(300,48)
1927 }
1928
1929 u*= 0x0101010101010101ULL;
1930 v*= 0x0101010101010101ULL;
1931 for(y=0; y<8; y++){
1932 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1933 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1934 }
1935
1936 //segmentation
1937 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1938 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1939 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1940 }
1941 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1942 for(y=0; y<16; y++)
1943 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1944 }
1945 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1946 int dm= 1 << (mv_sample_log2-2);
1947 for(i=0; i<4; i++){
1948 int sx= mb_x*16 + 8*(i&1);
1949 int sy= mb_y*16 + 8*(i>>1);
1950 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1951 //FIXME bidir
1952 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1953 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1954 for(y=0; y<8; y++)
1955 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1956 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1957 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1958 }
1959 }
1960
1961 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1962 // hmm
1963 }
1964 }
1965 s->mbskip_table[mb_index]=0;
1966 }
1967 }
1968 }
1969 }
1970
1971 #ifdef CONFIG_ENCODERS
1972
1973 static int get_sae(uint8_t *src, int ref, int stride){
1974 int x,y;
1975 int acc=0;
1976
1977 for(y=0; y<16; y++){
1978 for(x=0; x<16; x++){
1979 acc+= ABS(src[x+y*stride] - ref);
1980 }
1981 }
1982
1983 return acc;
1984 }
1985
1986 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1987 int x, y, w, h;
1988 int acc=0;
1989
1990 w= s->width &~15;
1991 h= s->height&~15;
1992
1993 for(y=0; y<h; y+=16){
1994 for(x=0; x<w; x+=16){
1995 int offset= x + y*stride;
1996 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1997 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1998 int sae = get_sae(src + offset, mean, stride);
1999
2000 acc+= sae + 500 < sad;
2001 }
2002 }
2003 return acc;
2004 }
2005
2006
2007 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2008 AVFrame *pic=NULL;
2009 int64_t pts;
2010 int i;
2011 const int encoding_delay= s->max_b_frames;
2012 int direct=1;
2013
2014 if(pic_arg){
2015 pts= pic_arg->pts;
2016 pic_arg->display_picture_number= s->input_picture_number++;
2017
2018 if(pts != AV_NOPTS_VALUE){
2019 if(s->user_specified_pts != AV_NOPTS_VALUE){
2020 int64_t time= pts;
2021 int64_t last= s->user_specified_pts;
2022
2023 if(time <= last){
2024 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2025 return -1;
2026 }
2027 }
2028 s->user_specified_pts= pts;
2029 }else{
2030 if(s->user_specified_pts != AV_NOPTS_VALUE){
2031 s->user_specified_pts=
2032 pts= s->user_specified_pts + 1;
2033 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2034 }else{
2035 pts= pic_arg->display_picture_number;
2036 }
2037 }
2038 }
2039
2040 if(pic_arg){
2041 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2042 if(pic_arg->linesize[0] != s->linesize) direct=0;
2043 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2044 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2045
2046 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2047
2048 if(direct){
2049 i= ff_find_unused_picture(s, 1);
2050
2051 pic= (AVFrame*)&s->picture[i];
2052 pic->reference= 3;
2053
2054 for(i=0; i<4; i++){
2055 pic->data[i]= pic_arg->data[i];
2056 pic->linesize[i]= pic_arg->linesize[i];
2057 }
2058 alloc_picture(s, (Picture*)pic, 1);
2059 }else{
2060 int offset= 16;
2061 i= ff_find_unused_picture(s, 0);
2062
2063 pic= (AVFrame*)&s->picture[i];
2064 pic->reference= 3;
2065
2066 alloc_picture(s, (Picture*)pic, 0);
2067
2068 if( pic->data[0] + offset == pic_arg->data[0]
2069 && pic->data[1] + offset == pic_arg->data[1]
2070 && pic->data[2] + offset == pic_arg->data[2]){
2071 // empty
2072 }else{
2073 int h_chroma_shift, v_chroma_shift;
2074 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2075
2076 for(i=0; i<3; i++){
2077 int src_stride= pic_arg->linesize[i];
2078 int dst_stride= i ? s->uvlinesize : s->linesize;
2079 int h_shift= i ? h_chroma_shift : 0;
2080 int v_shift= i ? v_chroma_shift : 0;
2081 int w= s->width >>h_shift;
2082 int h= s->height>>v_shift;
2083 uint8_t *src= pic_arg->data[i];
2084 uint8_t *dst= pic->data[i] + offset;
2085
2086 if(src_stride==dst_stride)
2087 memcpy(dst, src, src_stride*h);
2088 else{
2089 while(h--){
2090 memcpy(dst, src, w);
2091 dst += dst_stride;
2092 src += src_stride;
2093 }
2094 }
2095 }
2096 }
2097 }
2098 copy_picture_attributes(s, pic, pic_arg);
2099 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2100 }
2101
2102 /* shift buffer entries */
2103 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2104 s->input_picture[i-1]= s->input_picture[i];
2105
2106 s->input_picture[encoding_delay]= (Picture*)pic;
2107
2108 return 0;
2109 }
2110
2111 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2112 int x, y, plane;
2113 int score=0;
2114 int64_t score64=0;
2115
2116 for(plane=0; plane<3; plane++){
2117 const int stride= p->linesize[plane];
2118 const int bw= plane ? 1 : 2;
2119 for(y=0; y<s->mb_height*bw; y++){
2120 for(x=0; x<s->mb_width*bw; x++){
2121 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2122 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2123
2124 switch(s->avctx->frame_skip_exp){
2125 case 0: score= FFMAX(score, v); break;
2126 case 1: score+= ABS(v);break;
2127 case 2: score+= v*v;break;
2128 case 3: score64+= ABS(v*v*(int64_t)v);break;
2129 case 4: score64+= v*v*(int64_t)(v*v);break;
2130 }
2131 }
2132 }
2133 }
2134
2135 if(score) score64= score;
2136
2137 if(score64 < s->avctx->frame_skip_threshold)
2138 return 1;
2139 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2140 return 1;
2141 return 0;
2142 }
2143
2144 static int estimate_best_b_count(MpegEncContext *s){
2145 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2146 AVCodecContext *c= avcodec_alloc_context();
2147 AVFrame input[FF_MAX_B_FRAMES+2];
2148 const int scale= s->avctx->brd_scale;
2149 int i, j, out_size;
2150 int outbuf_size= s->width * s->height; //FIXME
2151 uint8_t *outbuf= av_malloc(outbuf_size);
2152 ImgReSampleContext *resample;
2153 int64_t best_rd= INT64_MAX;
2154 int best_b_count= -1;
2155 const int lambda2= s->lambda2;
2156
2157 c->width = s->width >> scale;
2158 c->height= s->height>> scale;
2159 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2160 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2161 c->mb_decision= s->avctx->mb_decision;
2162 c->me_cmp= s->avctx->me_cmp;
2163 c->mb_cmp= s->avctx->mb_cmp;
2164 c->me_sub_cmp= s->avctx->me_sub_cmp;
2165 c->pix_fmt = PIX_FMT_YUV420P;
2166 c->time_base= s->avctx->time_base;
2167 c->max_b_frames= s->max_b_frames;
2168
2169 if (avcodec_open(c, codec) < 0)
2170 return -1;
2171
2172 resample= img_resample_init(c->width, c->height, s->width, s->height); //FIXME use sws
2173
2174 for(i=0; i<s->max_b_frames+2; i++){
2175 int ysize= c->width*c->height;
2176 int csize= (c->width/2)*(c->height/2);
2177
2178 avcodec_get_frame_defaults(&input[i]);
2179 input[i].data[0]= av_malloc(ysize + 2*csize);
2180 input[i].data[1]= input[i].data[0] + ysize;
2181 input[i].data[2]= input[i].data[1] + csize;
2182 input[i].linesize[0]= c->width;
2183 input[i].linesize[1]=
2184 input[i].linesize[2]= c->width/2;
2185
2186 if(!i || s->input_picture[i-1])
2187 img_resample(resample, &input[i], i ? s->input_picture[i-1] : s->next_picture_ptr);
2188 }
2189
2190 for(j=0; j<s->max_b_frames+1; j++){
2191 int64_t rd=0;
2192
2193 if(!s->input_picture[j])
2194 break;
2195
2196 c->error[0]= c->error[1]= c->error[2]= 0;
2197
2198 input[0].pict_type= I_TYPE;
2199 input[0].quality= 2 * FF_QP2LAMBDA;
2200 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2201 rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2202
2203 for(i=0; i<s->max_b_frames+1; i++){
2204 int is_p= i % (j+1) == j || i==s->max_b_frames;
2205
2206 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2207 input[i+1].quality= s->rc_context.last_qscale_for[input[i+1].pict_type];
2208 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2209 rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2210 }
2211
2212 /* get the delayed frames */
2213 while(out_size){
2214 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2215 rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2216 }
2217
2218 rd += c->error[0] + c->error[1] + c->error[2];
2219
2220 if(rd < best_rd){
2221 best_rd= rd;
2222 best_b_count= j;
2223 }
2224 }
2225
2226 av_freep(&outbuf);
2227 avcodec_close(c);
2228 av_freep(&c);
2229 img_resample_close(resample);
2230
2231 for(i=0; i<s->max_b_frames+2; i++){
2232 av_freep(&input[i].data[0]);
2233 }
2234
2235 return best_b_count;
2236 }
2237
2238 static void select_input_picture(MpegEncContext *s){
2239 int i;
2240
2241 for(i=1; i<MAX_PICTURE_COUNT; i++)
2242 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2243 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2244
2245 /* set next picture type & ordering */
2246 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2247 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2248 s->reordered_input_picture[0]= s->input_picture[0];
2249 s->reordered_input_picture[0]->pict_type= I_TYPE;
2250 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2251 }else{
2252 int b_frames;
2253
2254 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2255 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2256 //FIXME check that te gop check above is +-1 correct
2257 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2258
2259 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2260 for(i=0; i<4; i++)
2261 s->input_picture[0]->data[i]= NULL;
2262 s->input_picture[0]->type= 0;
2263 }else{
2264 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2265 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2266
2267 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2268 }
2269
2270 emms_c();
2271 ff_vbv_update(s, 0);
2272
2273 goto no_output_pic;
2274 }
2275 }
2276
2277 if(s->flags&CODEC_FLAG_PASS2){
2278 for(i=0; i<s->max_b_frames+1; i++){
2279 int pict_num= s->input_picture[0]->display_picture_number + i;
2280
2281 if(pict_num >= s->rc_context.num_entries)
2282 break;
2283 if(!s->input_picture[i]){
2284 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2285 break;
2286 }
2287
2288 s->input_picture[i]->pict_type=
2289 s->rc_context.entry[pict_num].new_pict_type;
2290 }
2291 }
2292
2293 if(s->avctx->b_frame_strategy==0){
2294 b_frames= s->max_b_frames;
2295 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2296 }else if(s->avctx->b_frame_strategy==1){
2297 for(i=1; i<s->max_b_frames+1; i++){
2298 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2299 s->input_picture[i]->b_frame_score=
2300 get_intra_count(s, s->input_picture[i ]->data[0],
2301 s->input_picture[i-1]->data[0], s->linesize) + 1;
2302 }
2303 }
2304 for(i=0; i<s->max_b_frames+1; i++){
2305 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2306 }
2307
2308 b_frames= FFMAX(0, i-1);
2309
2310 /* reset scores */
2311 for(i=0; i<b_frames+1; i++){
2312 s->input_picture[i]->b_frame_score=0;
2313 }
2314 }else if(s->avctx->b_frame_strategy==2){
2315 b_frames= estimate_best_b_count(s);
2316 }else{
2317 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2318 b_frames=0;
2319 }
2320
2321 emms_c();
2322 //static int b_count=0;
2323 //b_count+= b_frames;
2324 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2325
2326 for(i= b_frames - 1; i>=0; i--){
2327 int type= s->input_picture[i]->pict_type;
2328 if(type && type != B_TYPE)
2329 b_frames= i;
2330 }
2331 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2332 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2333 }
2334
2335 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2336 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2337 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2338 }else{
2339 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2340 b_frames=0;
2341 s->input_picture[b_frames]->pict_type= I_TYPE;
2342 }
2343 }
2344
2345 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2346 && b_frames
2347 && s->input_picture[b_frames]->pict_type== I_TYPE)
2348 b_frames--;
2349
2350 s->reordered_input_picture[0]= s->input_picture[b_frames];
2351 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2352 s->reordered_input_picture[0]->pict_type= P_TYPE;
2353 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2354 for(i=0; i<b_frames; i++){
2355 s->reordered_input_picture[i+1]= s->input_picture[i];
2356 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2357 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2358 }
2359 }
2360 }
2361 no_output_pic:
2362 if(s->reordered_input_picture[0]){
2363 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2364
2365 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2366
2367 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2368 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2369
2370 int i= ff_find_unused_picture(s, 0);
2371 Picture *pic= &s->picture[i];
2372
2373 /* mark us unused / free shared pic */
2374 for(i=0; i<4; i++)
2375 s->reordered_input_picture[0]->data[i]= NULL;
2376 s->reordered_input_picture[0]->type= 0;
2377
2378 pic->reference = s->reordered_input_picture[0]->reference;
2379
2380 alloc_picture(s, pic, 0);
2381
2382 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2383
2384 s->current_picture_ptr= pic;
2385 }else{
2386 // input is not a shared pix -> reuse buffer for current_pix
2387
2388 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2389 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2390
2391 s->current_picture_ptr= s->reordered_input_picture[0];
2392 for(i=0; i<4; i++){
2393 s->new_picture.data[i]+=16;
2394 }
2395 }
2396 copy_picture(&s->current_picture, s->current_picture_ptr);
2397
2398 s->picture_number= s->new_picture.display_picture_number;
2399 //printf("dpn:%d\n", s->picture_number);
2400 }else{
2401 memset(&s->new_picture, 0, sizeof(Picture));
2402 }
2403 }
2404
2405 int MPV_encode_picture(AVCodecContext *avctx,
2406 unsigned char *buf, int buf_size, void *data)
2407 {
2408 MpegEncContext *s = avctx->priv_data;
2409 AVFrame *pic_arg = data;
2410 int i, stuffing_count;
2411
2412 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2413 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2414 return -1;
2415 }
2416
2417 for(i=0; i<avctx->thread_count; i++){
2418 int start_y= s->thread_context[i]->start_mb_y;
2419 int end_y= s->thread_context[i]-> end_mb_y;
2420 int h= s->mb_height;
2421 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2422 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2423
2424 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2425 }
2426
2427 s->picture_in_gop_number++;
2428
2429 if(load_input_picture(s, pic_arg) < 0)
2430 return -1;
2431
2432 select_input_picture(s);
2433
2434 /* output? */
2435 if(s->new_picture.data[0]){
2436 s->pict_type= s->new_picture.pict_type;
2437 //emms_c();
2438 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2439 MPV_frame_start(s, avctx);
2440
2441 encode_picture(s, s->picture_number);
2442
2443 avctx->real_pict_num = s->picture_number;
2444 avctx->header_bits = s->header_bits;
2445 avctx->mv_bits = s->mv_bits;
2446 avctx->misc_bits = s->misc_bits;
2447 avctx->i_tex_bits = s->i_tex_bits;
2448 avctx->p_tex_bits = s->p_tex_bits;
2449 avctx->i_count = s->i_count;
2450 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2451 avctx->skip_count = s->skip_count;
2452
2453 MPV_frame_end(s);
2454
2455 if (s->out_format == FMT_MJPEG)
2456 mjpeg_picture_trailer(s);
2457
2458 if(s->flags&CODEC_FLAG_PASS1)
2459 ff_write_pass1_stats(s);
2460
2461 for(i=0; i<4; i++){
2462 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2463 avctx->error[i] += s->current_picture_ptr->error[i];
2464 }
2465
2466 if(s->flags&CODEC_FLAG_PASS1)
2467 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2468 flush_put_bits(&s->pb);
2469 s->frame_bits = put_bits_count(&s->pb);
2470
2471 stuffing_count= ff_vbv_update(s, s->frame_bits);
2472 if(stuffing_count){
2473 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2474 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2475 return -1;
2476 }
2477
2478 switch(s->codec_id){
2479 case CODEC_ID_MPEG1VIDEO:
2480 case CODEC_ID_MPEG2VIDEO:
2481 while(stuffing_count--){
2482 put_bits(&s->pb, 8, 0);
2483 }
2484 break;
2485 case CODEC_ID_MPEG4:
2486 put_bits(&s->pb, 16, 0);
2487 put_bits(&s->pb, 16, 0x1C3);
2488 stuffing_count -= 4;
2489 while(stuffing_count--){
2490 put_bits(&s->pb, 8, 0xFF);
2491 }
2492 break;
2493 default:
2494 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2495 }
2496 flush_put_bits(&s->pb);
2497 s->frame_bits = put_bits_count(&s->pb);
2498 }
2499
2500 /* update mpeg1/2 vbv_delay for CBR */
2501 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2502 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2503 int vbv_delay;
2504
2505 assert(s->repeat_first_field==0);
2506
2507 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2508 assert(vbv_delay < 0xFFFF);
2509
2510 s->vbv_delay_ptr[0] &= 0xF8;
2511 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2512 s->vbv_delay_ptr[1] = vbv_delay>>5;
2513 s->vbv_delay_ptr[2] &= 0x07;
2514 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2515 }
2516 s->total_bits += s->frame_bits;
2517 avctx->frame_bits = s->frame_bits;
2518 }else{
2519 assert((pbBufPtr(&s->pb) == s->pb.buf));
2520 s->frame_bits=0;
2521 }
2522 assert((s->frame_bits&7)==0);
2523
2524 return s->frame_bits/8;
2525 }
2526
2527 #endif //CONFIG_ENCODERS
2528
2529 static inline void gmc1_motion(MpegEncContext *s,
2530 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2531 uint8_t **ref_picture)
2532 {
2533 uint8_t *ptr;
2534 int offset, src_x, src_y, linesize, uvlinesize;
2535 int motion_x, motion_y;
2536 int emu=0;
2537
2538 motion_x= s->sprite_offset[0][0];
2539 motion_y= s->sprite_offset[0][1];
2540 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2541 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2542 motion_x<<=(3-s->sprite_warping_accuracy);
2543 motion_y<<=(3-s->sprite_warping_accuracy);
2544 src_x = clip(src_x, -16, s->width);
2545 if (src_x == s->width)
2546 motion_x =0;
2547 src_y = clip(src_y, -16, s->height);
2548 if (src_y == s->height)
2549 motion_y =0;
2550
2551 linesize = s->linesize;
2552 uvlinesize = s->uvlinesize;
2553
2554 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2555
2556 if(s->flags&CODEC_FLAG_EMU_EDGE){
2557 if( (unsigned)src_x >= s->h_edge_pos - 17
2558 || (unsigned)src_y >= s->v_edge_pos - 17){
2559 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2560 ptr= s->edge_emu_buffer;
2561 }
2562 }
2563
2564 if((motion_x|motion_y)&7){
2565 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2566 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2567 }else{
2568 int dxy;
2569
2570 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2571 if (s->no_rounding){
2572 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2573 }else{
2574 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2575 }
2576 }
2577
2578 if(s->flags&CODEC_FLAG_GRAY) return;
2579
2580 motion_x= s->sprite_offset[1][0];
2581 motion_y= s->sprite_offset[1][1];
2582 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2583 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2584 motion_x<<=(3-s->sprite_warping_accuracy);
2585 motion_y<<=(3-s->sprite_warping_accuracy);
2586 src_x = clip(src_x, -8, s->width>>1);
2587 if (src_x == s->width>>1)
2588 motion_x =0;
2589 src_y = clip(src_y, -8, s->height>>1);
2590 if (src_y == s->height>>1)
2591 motion_y =0;
2592
2593 offset = (src_y * uvlinesize) + src_x;
2594 ptr = ref_picture[1] + offset;
2595 if(s->flags&CODEC_FLAG_EMU_EDGE){
2596 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2597 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2598 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2599 ptr= s->edge_emu_buffer;
2600 emu=1;
2601 }
2602 }
2603 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2604
2605 ptr = ref_picture[2] + offset;
2606 if(emu){
2607 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2608 ptr= s->edge_emu_buffer;
2609 }
2610 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2611
2612 return;
2613 }
2614
2615 static inline void gmc_motion(MpegEncContext *s,
2616 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2617 uint8_t **ref_picture)
2618 {
2619 uint8_t *ptr;
2620 int linesize, uvlinesize;
2621 const int a= s->sprite_warping_accuracy;
2622 int ox, oy;
2623
2624 linesize = s->linesize;
2625 uvlinesize = s->uvlinesize;
2626
2627 ptr = ref_picture[0];
2628
2629 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2630 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2631
2632 s->dsp.gmc(dest_y, ptr, linesize, 16,
2633 ox,
2634 oy,
2635 s->sprite_delta[0][0], s->sprite_delta[0][1],
2636 s->sprite_delta[1][0], s->sprite_delta[1][1],
2637 a+1, (1<<(2*a+1)) - s->no_rounding,
2638 s->h_edge_pos, s->v_edge_pos);
2639 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2640 ox + s->sprite_delta[0][0]*8,
2641 oy + s->sprite_delta[1][0]*8,
2642 s->sprite_delta[0][0], s->sprite_delta[0][1],
2643 s->sprite_delta[1][0], s->sprite_delta[1][1],
2644 a+1, (1<<(2*a+1)) - s->no_rounding,
2645 s->h_edge_pos, s->v_edge_pos);
2646
2647 if(s->flags&CODEC_FLAG_GRAY) return;
2648
2649 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2650 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2651
2652 ptr = ref_picture[1];
2653 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2654 ox,
2655 oy,
2656 s->sprite_delta[0][0], s->sprite_delta[0][1],
2657 s->sprite_delta[1][0], s->sprite_delta[1][1],
2658 a+1, (1<<(2*a+1)) - s->no_rounding,
2659 s->h_edge_pos>>1, s->v_edge_pos>>1);
2660
2661 ptr = ref_picture[2];
2662 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2663 ox,
2664 oy,
2665 s->sprite_delta[0][0], s->sprite_delta[0][1],
2666 s->sprite_delta[1][0], s->sprite_delta[1][1],
2667 a+1, (1<<(2*a+1)) - s->no_rounding,
2668 s->h_edge_pos>>1, s->v_edge_pos>>1);
2669 }
2670
2671 /**
2672 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2673 * @param buf destination buffer
2674 * @param src source buffer
2675 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2676 * @param block_w width of block
2677 * @param block_h height of block
2678 * @param src_x x coordinate of the top left sample of the block in the source buffer
2679 * @param src_y y coordinate of the top left sample of the block in the source buffer
2680 * @param w width of the source buffer
2681 * @param h height of the source buffer
2682 */
2683 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2684 int src_x, int src_y, int w, int h){
2685 int x, y;
2686 int start_y, start_x, end_y, end_x;
2687
2688 if(src_y>= h){
2689 src+= (h-1-src_y)*linesize;
2690 src_y=h-1;
2691 }else if(src_y<=-block_h){
2692 src+= (1-block_h-src_y)*linesize;
2693 src_y=1-block_h;
2694 }
2695 if(src_x>= w){
2696 src+= (w-1-src_x);
2697 src_x=w-1;
2698 }else if(src_x<=-block_w){
2699 src+= (1-block_w-src_x);
2700 src_x=1-block_w;
2701 }
2702
2703 start_y= FFMAX(0, -src_y);
2704 start_x= FFMAX(0, -src_x);
2705 end_y= FFMIN(block_h, h-src_y);
2706 end_x= FFMIN(block_w, w-src_x);
2707
2708 // copy existing part
2709 for(y=start_y; y<end_y; y++){
2710 for(x=start_x; x<end_x; x++){
2711 buf[x + y*linesize]= src[x + y*linesize];
2712 }
2713 }
2714
2715 //top
2716 for(y=0; y<start_y; y++){
2717 for(x=start_x; x<end_x; x++){
2718 buf[x + y*linesize]= buf[x + start_y*linesize];
2719 }
2720 }
2721
2722 //bottom
2723 for(y=end_y; y<block_h; y++){
2724 for(x=start_x; x<end_x; x++){
2725 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2726 }
2727 }
2728
2729 for(y=0; y<block_h; y++){
2730 //left
2731 for(x=0; x<start_x; x++){
2732 buf[x + y*linesize]= buf[start_x + y*linesize];
2733 }
2734
2735 //right
2736 for(x=end_x; x<block_w; x++){
2737 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2738 }
2739 }
2740 }
2741
2742 static inline int hpel_motion(MpegEncContext *s,
2743 uint8_t *dest, uint8_t *src,
2744 int field_based, int field_select,
2745 int src_x, int src_y,
2746 int width, int height, int stride,
2747 int h_edge_pos, int v_edge_pos,
2748 int w, int h, op_pixels_func *pix_op,
2749 int motion_x, int motion_y)
2750 {
2751 int dxy;
2752 int emu=0;
2753
2754 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2755 src_x += motion_x >> 1;
2756 src_y += motion_y >> 1;
2757
2758 /* WARNING: do no forget half pels */
2759 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2760 if (src_x == width)
2761 dxy &= ~1;
2762 src_y = clip(src_y, -16, height);
2763 if (src_y == height)
2764 dxy &= ~2;
2765 src += src_y * stride + src_x;
2766
2767 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2768 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2769 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2770 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2771 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2772 src= s->edge_emu_buffer;
2773 emu=1;
2774 }
2775 }
2776 if(field_select)
2777 src += s->linesize;
2778 pix_op[dxy](dest, src, stride, h);
2779 return emu;
2780 }
2781
2782 static inline int hpel_motion_lowres(MpegEncContext *s,
2783 uint8_t *dest, uint8_t *src,
2784 int field_based, int field_select,
2785 int src_x, int src_y,
2786 int width, int height, int stride,
2787 int h_edge_pos, int v_edge_pos,
2788 int w, int h, h264_chroma_mc_func *pix_op,
2789 int motion_x, int motion_y)
2790 {
2791 const int lowres= s->avctx->lowres;
2792 const int s_mask= (2<<lowres)-1;
2793 int emu=0;
2794 int sx, sy;
2795
2796 if(s->quarter_sample){
2797 motion_x/=2;
2798 motion_y/=2;
2799 }
2800
2801 sx= motion_x & s_mask;
2802 sy= motion_y & s_mask;
2803 src_x += motion_x >> (lowres+1);
2804 src_y += motion_y >> (lowres+1);
2805
2806 src += src_y * stride + src_x;
2807
2808 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2809 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2810 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2811 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2812 src= s->edge_emu_buffer;
2813 emu=1;
2814 }
2815
2816 sx <<= 2 - lowres;
2817 sy <<= 2 - lowres;
2818 if(field_select)
2819 src += s->linesize;
2820 pix_op[lowres](dest, src, stride, h, sx, sy);
2821 return emu;
2822 }
2823
2824 /* apply one mpeg motion vector to the three components */
2825 static always_inline void mpeg_motion(MpegEncContext *s,
2826 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2827 int field_based, int bottom_field, int field_select,
2828 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2829 int motion_x, int motion_y, int h)
2830 {
2831 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2832 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2833
2834 #if 0
2835 if(s->quarter_sample)
2836 {
2837 motion_x>>=1;
2838 motion_y>>=1;
2839 }
2840 #endif
2841
2842 v_edge_pos = s->v_edge_pos >> field_based;
2843 linesize = s->current_picture.linesize[0] << field_based;
2844 uvlinesize = s->current_picture.linesize[1] << field_based;
2845
2846 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2847 src_x = s->mb_x* 16 + (motion_x >> 1);
2848 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2849
2850 if (s->out_format == FMT_H263) {
2851 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2852 mx = (motion_x>>1)|(motion_x&1);
2853 my = motion_y >>1;
2854 uvdxy = ((my & 1) << 1) | (mx & 1);
2855 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2856 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2857 }else{
2858 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2859 uvsrc_x = src_x>>1;
2860 uvsrc_y = src_y>>1;
2861 }
2862 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2863 mx = motion_x / 4;
2864 my = motion_y / 4;
2865 uvdxy = 0;
2866 uvsrc_x = s->mb_x*8 + mx;
2867 uvsrc_y = s->mb_y*8 + my;
2868 } else {
2869 if(s->chroma_y_shift){
2870 mx = motion_x / 2;
2871 my = motion_y / 2;
2872 uvdxy = ((my & 1) << 1) | (mx & 1);
2873 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2874 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2875 } else {
2876 if(s->chroma_x_shift){
2877 //Chroma422
2878 mx = motion_x / 2;
2879 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2880 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2881 uvsrc_y = src_y;
2882 } else {
2883 //Chroma444
2884 uvdxy = dxy;
2885 uvsrc_x = src_x;
2886 uvsrc_y = src_y;
2887 }
2888 }
2889 }
2890
2891 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2892 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2893 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2894
2895 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2896 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2897 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2898 s->codec_id == CODEC_ID_MPEG1VIDEO){
2899 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2900 return ;
2901 }
2902 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2903 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2904 ptr_y = s->edge_emu_buffer;
2905 if(!(s->flags&CODEC_FLAG_GRAY)){
2906 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2907 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2908 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2909 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2910 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2911 ptr_cb= uvbuf;
2912 ptr_cr= uvbuf+16;
2913 }
2914 }
2915
2916 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2917 dest_y += s->linesize;
2918 dest_cb+= s->uvlinesize;
2919 dest_cr+= s->uvlinesize;
2920 }
2921
2922 if(field_select){
2923 ptr_y += s->linesize;
2924 ptr_cb+= s->uvlinesize;
2925 ptr_cr+= s->uvlinesize;
2926 }
2927
2928 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2929
2930 if(!(s->flags&CODEC_FLAG_GRAY)){
2931 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2932 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2933 }
2934 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2935 if(s->out_format == FMT_H261){
2936 ff_h261_loop_filter(s);
2937 }
2938 #endif
2939 }
2940
2941 /* apply one mpeg motion vector to the three components */
2942 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2943 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2944 int field_based, int bottom_field, int field_select,
2945 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2946 int motion_x, int motion_y, int h)
2947 {
2948 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2949 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2950 const int lowres= s->avctx->lowres;
2951 const int block_s= 8>>lowres;
2952 const int s_mask= (2<<lowres)-1;
2953 const int h_edge_pos = s->h_edge_pos >> lowres;
2954 const int v_edge_pos = s->v_edge_pos >> lowres;
2955 linesize = s->current_picture.linesize[0] << field_based;
2956 uvlinesize = s->current_picture.linesize[1] << field_based;
2957
2958 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2959 motion_x/=2;
2960 motion_y/=2;
2961 }
2962
2963 if(field_based){
2964 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2965 }
2966
2967 sx= motion_x & s_mask;
2968 sy= motion_y & s_mask;
2969 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2970 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2971
2972 if (s->out_format == FMT_H263) {
2973 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2974 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2975 uvsrc_x = src_x>>1;
2976 uvsrc_y = src_y>>1;
2977 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2978 mx = motion_x / 4;
2979 my = motion_y / 4;
2980 uvsx = (2*mx) & s_mask;
2981 uvsy = (2*my) & s_mask;
2982 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2983 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2984 } else {
2985 mx = motion_x / 2;
2986 my = motion_y / 2;
2987 uvsx = mx & s_mask;
2988 uvsy = my & s_mask;
2989 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2990 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2991 }
2992
2993 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2994 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2995 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2996
2997 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
2998 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2999 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3000 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3001 ptr_y = s->edge_emu_buffer;
3002 if(!(s->flags&CODEC_FLAG_GRAY)){
3003 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3004 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3005 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3006 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3007 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3008 ptr_cb= uvbuf;
3009 ptr_cr= uvbuf+16;
3010 }
3011 }
3012
3013 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3014 dest_y += s->linesize;
3015 dest_cb+= s->uvlinesize;
3016 dest_cr+= s->uvlinesize;
3017 }
3018
3019 if(field_select){
3020 ptr_y += s->linesize;
3021 ptr_cb+= s->uvlinesize;
3022 ptr_cr+= s->uvlinesize;
3023 }
3024
3025 sx <<= 2 - lowres;
3026 sy <<= 2 - lowres;
3027 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3028
3029 if(!(s->flags&CODEC_FLAG_GRAY)){
3030 uvsx <<= 2 - lowres;
3031 uvsy <<= 2 - lowres;
3032 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3033 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3034 }
3035 //FIXME h261 lowres loop filter
3036 }
3037
3038 //FIXME move to dsputil, avg variant, 16x16 version
3039 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3040 int x;
3041 uint8_t * const top = src[1];
3042 uint8_t * const left = src[2];
3043 uint8_t * const mid = src[0];
3044 uint8_t * const right = src[3];
3045 uint8_t * const bottom= src[4];
3046 #define OBMC_FILTER(x, t, l, m, r, b)\
3047 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3048 #define OBMC_FILTER4(x, t, l, m, r, b)\
3049 OBMC_FILTER(x , t, l, m, r, b);\
3050 OBMC_FILTER(x+1 , t, l, m, r, b);\
3051 OBMC_FILTER(x +stride, t, l, m, r, b);\
3052 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3053
3054 x=0;
3055 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3056 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3057 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3058 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3059 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3060 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3061 x+= stride;
3062 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3063 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3064 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3065 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3066 x+= stride;
3067 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3068 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3069 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3070 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3071 x+= 2*stride;
3072 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3073 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3074 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3075 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3076 x+= 2*stride;
3077 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3078 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3079 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3080 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3081 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3082 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3083 x+= stride;
3084 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3085 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3086 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3087 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3088 }
3089
3090 /* obmc for 1 8x8 luma block */
3091 static inline void obmc_motion(MpegEncContext *s,
3092 uint8_t *dest, uint8_t *src,
3093 int src_x, int src_y,
3094 op_pixels_func *pix_op,
3095 int16_t mv[5][2]/* mid top left right bottom*/)
3096 #define MID 0
3097 {
3098 int i;
3099 uint8_t *ptr[5];
3100
3101 assert(s->quarter_sample==0);
3102
3103 for(i=0; i<5; i++){
3104 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3105 ptr[i]= ptr[MID];
3106 }else{
3107 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3108 hpel_motion(s, ptr[i], src, 0, 0,
3109 src_x, src_y,
3110 s->width, s->height, s->linesize,
3111 s->h_edge_pos, s->v_edge_pos,
3112 8, 8, pix_op,
3113 mv[i][0], mv[i][1]);
3114 }
3115 }
3116
3117 put_obmc(dest, ptr, s->linesize);
3118 }
3119
3120 static inline void qpel_motion(MpegEncContext *s,
3121 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3122 int field_based, int bottom_field, int field_select,
3123 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3124 qpel_mc_func (*qpix_op)[16],
3125 int motion_x, int motion_y, int h)
3126 {
3127 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3128 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3129
3130 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3131 src_x = s->mb_x * 16 + (motion_x >> 2);
3132 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3133
3134 v_edge_pos = s->v_edge_pos >> field_based;
3135 linesize = s->linesize << field_based;
3136 uvlinesize = s->uvlinesize << field_based;
3137
3138 if(field_based){
3139 mx= motion_x/2;
3140 my= motion_y>>1;
3141 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3142 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3143 mx= (motion_x>>1) + rtab[motion_x&7];
3144 my= (motion_y>>1) + rtab[motion_y&7];
3145 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3146 mx= (motion_x>>1)|(motion_x&1);
3147 my= (motion_y>>1)|(motion_y&1);
3148 }else{
3149 mx= motion_x/2;
3150 my= motion_y/2;
3151 }
3152 mx= (mx>>1)|(mx&1);
3153 my= (my>>1)|(my&1);
3154
3155 uvdxy= (mx&1) | ((my&1)<<1);
3156 mx>>=1;
3157 my>>=1;
3158
3159 uvsrc_x = s->mb_x * 8