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