e0b5d0ec6e27c5b30724af291476f28b1b23b5ae
[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)*2*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 default edge pos, will be overriden in decode_header if needed */
625 s->h_edge_pos= s->mb_width*16;
626 s->v_edge_pos= s->mb_height*16;
627
628 s->mb_num = s->mb_width * s->mb_height;
629
630 s->block_wrap[0]=
631 s->block_wrap[1]=
632 s->block_wrap[2]=
633 s->block_wrap[3]= s->b8_stride;
634 s->block_wrap[4]=
635 s->block_wrap[5]= s->mb_stride;
636
637 y_size = s->b8_stride * (2 * s->mb_height + 1);
638 c_size = s->mb_stride * (s->mb_height + 1);
639 yc_size = y_size + 2 * c_size;
640
641 /* convert fourcc to upper case */
642 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
643 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
644 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
645 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
646
647 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
648 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
649 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
650 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
651
652 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
653
654 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
655 for(y=0; y<s->mb_height; y++){
656 for(x=0; x<s->mb_width; x++){
657 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
658 }
659 }
660 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
661
662 if (s->encoding) {
663 /* Allocate MV tables */
664 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
665 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
666 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
667 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
668 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
669 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
670 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
671 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
672 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
673 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
674 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
675 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
676
677 if(s->msmpeg4_version){
678 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
679 }
680 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
681
682 /* Allocate MB type table */
683 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
684
685 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
686
687 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
688 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
689 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
690 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
691 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
692 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
693
694 if(s->avctx->noise_reduction){
695 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
696 }
697 }
698 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
699
700 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
701
702 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
703 /* interlaced direct mode decoding tables */
704 for(i=0; i<2; i++){
705 int j, k;
706 for(j=0; j<2; j++){
707 for(k=0; k<2; k++){
708 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
709 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
710 }
711 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
712 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
713 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
714 }
715 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
716 }
717 }
718 if (s->out_format == FMT_H263) {
719 /* ac values */
720 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
721 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
722 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
723 s->ac_val[2] = s->ac_val[1] + c_size;
724
725 /* cbp values */
726 CHECKED_ALLOCZ(s->coded_block_base, y_size);
727 s->coded_block= s->coded_block_base + s->b8_stride + 1;
728
729 /* divx501 bitstream reorder buffer */
730 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
731
732 /* cbp, ac_pred, pred_dir */
733 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
734 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
735 }
736
737 if (s->h263_pred || s->h263_plus || !s->encoding) {
738 /* dc values */
739 //MN: we need these for error resilience of intra-frames
740 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
741 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
742 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
743 s->dc_val[2] = s->dc_val[1] + c_size;
744 for(i=0;i<yc_size;i++)
745 s->dc_val_base[i] = 1024;
746 }
747
748 /* which mb is a intra block */
749 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
750 memset(s->mbintra_table, 1, mb_array_size);
751
752 /* init macroblock skip table */
753 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
754 //Note the +1 is for a quicker mpeg4 slice_end detection
755 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
756
757 s->parse_context.state= -1;
758 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
759 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
760 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
761 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
762 }
763
764 s->context_initialized = 1;
765
766 s->thread_context[0]= s;
767 for(i=1; i<s->avctx->thread_count; i++){
768 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
769 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
770 }
771
772 for(i=0; i<s->avctx->thread_count; i++){
773 if(init_duplicate_context(s->thread_context[i], s) < 0)
774 goto fail;
775 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
776 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
777 }
778
779 return 0;
780 fail:
781 MPV_common_end(s);
782 return -1;
783 }
784
785 /* init common structure for both encoder and decoder */
786 void MPV_common_end(MpegEncContext *s)
787 {
788 int i, j, k;
789
790 for(i=0; i<s->avctx->thread_count; i++){
791 free_duplicate_context(s->thread_context[i]);
792 }
793 for(i=1; i<s->avctx->thread_count; i++){
794 av_freep(&s->thread_context[i]);
795 }
796
797 av_freep(&s->parse_context.buffer);
798 s->parse_context.buffer_size=0;
799
800 av_freep(&s->mb_type);
801 av_freep(&s->p_mv_table_base);
802 av_freep(&s->b_forw_mv_table_base);
803 av_freep(&s->b_back_mv_table_base);
804 av_freep(&s->b_bidir_forw_mv_table_base);
805 av_freep(&s->b_bidir_back_mv_table_base);
806 av_freep(&s->b_direct_mv_table_base);
807 s->p_mv_table= NULL;
808 s->b_forw_mv_table= NULL;
809 s->b_back_mv_table= NULL;
810 s->b_bidir_forw_mv_table= NULL;
811 s->b_bidir_back_mv_table= NULL;
812 s->b_direct_mv_table= NULL;
813 for(i=0; i<2; i++){
814 for(j=0; j<2; j++){
815 for(k=0; k<2; k++){
816 av_freep(&s->b_field_mv_table_base[i][j][k]);
817 s->b_field_mv_table[i][j][k]=NULL;
818 }
819 av_freep(&s->b_field_select_table[i][j]);
820 av_freep(&s->p_field_mv_table_base[i][j]);
821 s->p_field_mv_table[i][j]=NULL;
822 }
823 av_freep(&s->p_field_select_table[i]);
824 }
825
826 av_freep(&s->dc_val_base);
827 av_freep(&s->ac_val_base);
828 av_freep(&s->coded_block_base);
829 av_freep(&s->mbintra_table);
830 av_freep(&s->cbp_table);
831 av_freep(&s->pred_dir_table);
832
833 av_freep(&s->mbskip_table);
834 av_freep(&s->prev_pict_types);
835 av_freep(&s->bitstream_buffer);
836 av_freep(&s->avctx->stats_out);
837 av_freep(&s->ac_stats);
838 av_freep(&s->error_status_table);
839 av_freep(&s->mb_index2xy);
840 av_freep(&s->lambda_table);
841 av_freep(&s->q_intra_matrix);
842 av_freep(&s->q_inter_matrix);
843 av_freep(&s->q_intra_matrix16);
844 av_freep(&s->q_inter_matrix16);
845 av_freep(&s->input_picture);
846 av_freep(&s->reordered_input_picture);
847 av_freep(&s->dct_offset);
848
849 if(s->picture){
850 for(i=0; i<MAX_PICTURE_COUNT; i++){
851 free_picture(s, &s->picture[i]);
852 }
853 }
854 av_freep(&s->picture);
855 s->context_initialized = 0;
856 s->last_picture_ptr=
857 s->next_picture_ptr=
858 s->current_picture_ptr= NULL;
859
860 for(i=0; i<3; i++)
861 av_freep(&s->visualization_buffer[i]);
862 }
863
864 #ifdef CONFIG_ENCODERS
865
866 /* init video encoder */
867 int MPV_encode_init(AVCodecContext *avctx)
868 {
869 MpegEncContext *s = avctx->priv_data;
870 int i, dummy;
871 int chroma_h_shift, chroma_v_shift;
872
873 MPV_encode_defaults(s);
874
875 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
876
877 s->bit_rate = avctx->bit_rate;
878 s->width = avctx->width;
879 s->height = avctx->height;
880 if(avctx->gop_size > 600){
881 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
882 avctx->gop_size=600;
883 }
884 s->gop_size = avctx->gop_size;
885 s->avctx = avctx;
886 s->flags= avctx->flags;
887 s->flags2= avctx->flags2;
888 s->max_b_frames= avctx->max_b_frames;
889 s->codec_id= avctx->codec->id;
890 s->luma_elim_threshold = avctx->luma_elim_threshold;
891 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
892 s->strict_std_compliance= avctx->strict_std_compliance;
893 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
894 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
895 s->mpeg_quant= avctx->mpeg_quant;
896 s->rtp_mode= !!avctx->rtp_payload_size;
897 s->intra_dc_precision= avctx->intra_dc_precision;
898
899 if (s->gop_size <= 1) {
900 s->intra_only = 1;
901 s->gop_size = 12;
902 } else {
903 s->intra_only = 0;
904 }
905
906 s->me_method = avctx->me_method;
907
908 /* Fixed QSCALE */
909 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
910
911 s->adaptive_quant= ( s->avctx->lumi_masking
912 || s->avctx->dark_masking
913 || s->avctx->temporal_cplx_masking
914 || s->avctx->spatial_cplx_masking
915 || s->avctx->p_masking
916 || (s->flags&CODEC_FLAG_QP_RD))
917 && !s->fixed_qscale;
918
919 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
920 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
921 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
922
923 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
924 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
925 return -1;
926 }
927
928 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
929 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
930 }
931
932 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
933 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
934 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
935
936 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");
937 }
938
939 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
940 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
941 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
942 return -1;
943 }
944
945 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
946 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
947 return -1;
948 }
949
950 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
951 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
952 return -1;
953 }
954
955 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
956 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
957 return -1;
958 }
959
960 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
961 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
962 return -1;
963 }
964
965 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
966 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
967 return -1;
968 }
969
970 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
971 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
972 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
973 return -1;
974 }
975
976 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
977 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
978 return -1;
979 }
980
981 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
982 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
983 return -1;
984 }
985
986 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
987 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
988 return -1;
989 }
990
991 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
992 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
993 return -1;
994 }
995
996 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
997 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
998 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
999 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1000 return -1;
1001 }
1002
1003 if(s->avctx->thread_count > 1)
1004 s->rtp_mode= 1;
1005
1006 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1007 if(i > 1){
1008 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1009 avctx->frame_rate /= i;
1010 avctx->frame_rate_base /= i;
1011 // return -1;
1012 }
1013
1014 if(s->codec_id==CODEC_ID_MJPEG){
1015 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1016 s->inter_quant_bias= 0;
1017 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1018 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1019 s->inter_quant_bias= 0;
1020 }else{
1021 s->intra_quant_bias=0;
1022 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1023 }
1024
1025 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1026 s->intra_quant_bias= avctx->intra_quant_bias;
1027 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1028 s->inter_quant_bias= avctx->inter_quant_bias;
1029
1030 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1031
1032 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1033 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1034
1035 switch(avctx->codec->id) {
1036 case CODEC_ID_MPEG1VIDEO:
1037 s->out_format = FMT_MPEG1;
1038 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1039 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1040 break;
1041 case CODEC_ID_MPEG2VIDEO:
1042 s->out_format = FMT_MPEG1;
1043 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1044 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1045 s->rtp_mode= 1;
1046 break;
1047 case CODEC_ID_LJPEG:
1048 case CODEC_ID_MJPEG:
1049 s->out_format = FMT_MJPEG;
1050 s->intra_only = 1; /* force intra only for jpeg */
1051 s->mjpeg_write_tables = 1; /* write all tables */
1052 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1053 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1054 s->mjpeg_vsample[1] = 1;
1055 s->mjpeg_vsample[2] = 1;
1056 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1057 s->mjpeg_hsample[1] = 1;
1058 s->mjpeg_hsample[2] = 1;
1059 if (mjpeg_init(s) < 0)
1060 return -1;
1061 avctx->delay=0;
1062 s->low_delay=1;
1063 break;
1064 #ifdef CONFIG_RISKY
1065 case CODEC_ID_H263:
1066 if (h263_get_picture_format(s->width, s->height) == 7) {
1067 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1068 return -1;
1069 }
1070 s->out_format = FMT_H263;
1071 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1072 avctx->delay=0;
1073 s->low_delay=1;
1074 break;
1075 case CODEC_ID_H263P:
1076 s->out_format = FMT_H263;
1077 s->h263_plus = 1;
1078 /* Fx */
1079 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1080 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1081 s->modified_quant= s->h263_aic;
1082 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1083 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1084 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1085 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1086 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1087
1088 /* /Fx */
1089 /* These are just to be sure */
1090 avctx->delay=0;
1091 s->low_delay=1;
1092 break;
1093 case CODEC_ID_FLV1:
1094 s->out_format = FMT_H263;
1095 s->h263_flv = 2; /* format = 1; 11-bit codes */
1096 s->unrestricted_mv = 1;
1097 s->rtp_mode=0; /* don't allow GOB */
1098 avctx->delay=0;
1099 s->low_delay=1;
1100 break;
1101 case CODEC_ID_RV10:
1102 s->out_format = FMT_H263;
1103 avctx->delay=0;
1104 s->low_delay=1;
1105 break;
1106 case CODEC_ID_MPEG4:
1107 s->out_format = FMT_H263;
1108 s->h263_pred = 1;
1109 s->unrestricted_mv = 1;
1110 s->low_delay= s->max_b_frames ? 0 : 1;
1111 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1112 break;
1113 case CODEC_ID_MSMPEG4V1:
1114 s->out_format = FMT_H263;
1115 s->h263_msmpeg4 = 1;
1116 s->h263_pred = 1;
1117 s->unrestricted_mv = 1;
1118 s->msmpeg4_version= 1;
1119 avctx->delay=0;
1120 s->low_delay=1;
1121 break;
1122 case CODEC_ID_MSMPEG4V2:
1123 s->out_format = FMT_H263;
1124 s->h263_msmpeg4 = 1;
1125 s->h263_pred = 1;
1126 s->unrestricted_mv = 1;
1127 s->msmpeg4_version= 2;
1128 avctx->delay=0;
1129 s->low_delay=1;
1130 break;
1131 case CODEC_ID_MSMPEG4V3:
1132 s->out_format = FMT_H263;
1133 s->h263_msmpeg4 = 1;
1134 s->h263_pred = 1;
1135 s->unrestricted_mv = 1;
1136 s->msmpeg4_version= 3;
1137 s->flipflop_rounding=1;
1138 avctx->delay=0;
1139 s->low_delay=1;
1140 break;
1141 case CODEC_ID_WMV1:
1142 s->out_format = FMT_H263;
1143 s->h263_msmpeg4 = 1;
1144 s->h263_pred = 1;
1145 s->unrestricted_mv = 1;
1146 s->msmpeg4_version= 4;
1147 s->flipflop_rounding=1;
1148 avctx->delay=0;
1149 s->low_delay=1;
1150 break;
1151 case CODEC_ID_WMV2:
1152 s->out_format = FMT_H263;
1153 s->h263_msmpeg4 = 1;
1154 s->h263_pred = 1;
1155 s->unrestricted_mv = 1;
1156 s->msmpeg4_version= 5;
1157 s->flipflop_rounding=1;
1158 avctx->delay=0;
1159 s->low_delay=1;
1160 break;
1161 #endif
1162 default:
1163 return -1;
1164 }
1165
1166 avctx->has_b_frames= !s->low_delay;
1167
1168 s->encoding = 1;
1169
1170 /* init */
1171 if (MPV_common_init(s) < 0)
1172 return -1;
1173
1174 if(s->modified_quant)
1175 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1176 s->progressive_frame=
1177 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1178 s->quant_precision=5;
1179
1180 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1181
1182 #ifdef CONFIG_ENCODERS
1183 #ifdef CONFIG_RISKY
1184 if (s->out_format == FMT_H263)
1185 h263_encode_init(s);
1186 if(s->msmpeg4_version)
1187 ff_msmpeg4_encode_init(s);
1188 #endif
1189 if (s->out_format == FMT_MPEG1)
1190 ff_mpeg1_encode_init(s);
1191 #endif
1192
1193 /* init q matrix */
1194 for(i=0;i<64;i++) {
1195 int j= s->dsp.idct_permutation[i];
1196 #ifdef CONFIG_RISKY
1197 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1198 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1199 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1200 }else if(s->out_format == FMT_H263){
1201 s->intra_matrix[j] =
1202 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1203 }else
1204 #endif
1205 { /* mpeg1/2 */
1206 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1207 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1208 }
1209 if(s->avctx->intra_matrix)
1210 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1211 if(s->avctx->inter_matrix)
1212 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1213 }
1214
1215 /* precompute matrix */
1216 /* for mjpeg, we do include qscale in the matrix */
1217 if (s->out_format != FMT_MJPEG) {
1218 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1219 s->intra_matrix, s->intra_quant_bias, 1, 31);
1220 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1221 s->inter_matrix, s->inter_quant_bias, 1, 31);
1222 }
1223
1224 if(ff_rate_control_init(s) < 0)
1225 return -1;
1226
1227 return 0;
1228 }
1229
1230 int MPV_encode_end(AVCodecContext *avctx)
1231 {
1232 MpegEncContext *s = avctx->priv_data;
1233
1234 #ifdef STATS
1235 print_stats();
1236 #endif
1237
1238 ff_rate_control_uninit(s);
1239
1240 MPV_common_end(s);
1241 if (s->out_format == FMT_MJPEG)
1242 mjpeg_close(s);
1243
1244 av_freep(&avctx->extradata);
1245
1246 return 0;
1247 }
1248
1249 #endif //CONFIG_ENCODERS
1250
1251 void init_rl(RLTable *rl)
1252 {
1253 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1254 uint8_t index_run[MAX_RUN+1];
1255 int last, run, level, start, end, i;
1256
1257 /* compute max_level[], max_run[] and index_run[] */
1258 for(last=0;last<2;last++) {
1259 if (last == 0) {
1260 start = 0;
1261 end = rl->last;
1262 } else {
1263 start = rl->last;
1264 end = rl->n;
1265 }
1266
1267 memset(max_level, 0, MAX_RUN + 1);
1268 memset(max_run, 0, MAX_LEVEL + 1);
1269 memset(index_run, rl->n, MAX_RUN + 1);
1270 for(i=start;i<end;i++) {
1271 run = rl->table_run[i];
1272 level = rl->table_level[i];
1273 if (index_run[run] == rl->n)
1274 index_run[run] = i;
1275 if (level > max_level[run])
1276 max_level[run] = level;
1277 if (run > max_run[level])
1278 max_run[level] = run;
1279 }
1280 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1281 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1282 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1283 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1284 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1285 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1286 }
1287 }
1288
1289 /* draw the edges of width 'w' of an image of size width, height */
1290 //FIXME check that this is ok for mpeg4 interlaced
1291 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1292 {
1293 uint8_t *ptr, *last_line;
1294 int i;
1295
1296 last_line = buf + (height - 1) * wrap;
1297 for(i=0;i<w;i++) {
1298 /* top and bottom */
1299 memcpy(buf - (i + 1) * wrap, buf, width);
1300 memcpy(last_line + (i + 1) * wrap, last_line, width);
1301 }
1302 /* left and right */
1303 ptr = buf;
1304 for(i=0;i<height;i++) {
1305 memset(ptr - w, ptr[0], w);
1306 memset(ptr + width, ptr[width-1], w);
1307 ptr += wrap;
1308 }
1309 /* corners */
1310 for(i=0;i<w;i++) {
1311 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1312 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1313 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1314 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1315 }
1316 }
1317
1318 int ff_find_unused_picture(MpegEncContext *s, int shared){
1319 int i;
1320
1321 if(shared){
1322 for(i=0; i<MAX_PICTURE_COUNT; i++){
1323 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1324 }
1325 }else{
1326 for(i=0; i<MAX_PICTURE_COUNT; i++){
1327 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1328 }
1329 for(i=0; i<MAX_PICTURE_COUNT; i++){
1330 if(s->picture[i].data[0]==NULL) return i;
1331 }
1332 }
1333
1334 assert(0);
1335 return -1;
1336 }
1337
1338 static void update_noise_reduction(MpegEncContext *s){
1339 int intra, i;
1340
1341 for(intra=0; intra<2; intra++){
1342 if(s->dct_count[intra] > (1<<16)){
1343 for(i=0; i<64; i++){
1344 s->dct_error_sum[intra][i] >>=1;
1345 }
1346 s->dct_count[intra] >>= 1;
1347 }
1348
1349 for(i=0; i<64; i++){
1350 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);
1351 }
1352 }
1353 }
1354
1355 /**
1356 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1357 */
1358 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1359 {
1360 int i;
1361 AVFrame *pic;
1362 s->mb_skiped = 0;
1363
1364 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1365
1366 /* mark&release old frames */
1367 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1368 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1369
1370 /* release forgotten pictures */
1371 /* if(mpeg124/h263) */
1372 if(!s->encoding){
1373 for(i=0; i<MAX_PICTURE_COUNT; i++){
1374 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1375 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1376 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1377 }
1378 }
1379 }
1380 }
1381 alloc:
1382 if(!s->encoding){
1383 /* release non refernce frames */
1384 for(i=0; i<MAX_PICTURE_COUNT; i++){
1385 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1386 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1387 }
1388 }
1389
1390 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1391 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1392 else{
1393 i= ff_find_unused_picture(s, 0);
1394 pic= (AVFrame*)&s->picture[i];
1395 }
1396
1397 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1398
1399 pic->coded_picture_number= s->coded_picture_number++;
1400
1401 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1402 return -1;
1403
1404 s->current_picture_ptr= (Picture*)pic;
1405 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1406 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1407 }
1408
1409 s->current_picture_ptr->pict_type= s->pict_type;
1410 // if(s->flags && CODEC_FLAG_QSCALE)
1411 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1412 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1413
1414 copy_picture(&s->current_picture, s->current_picture_ptr);
1415
1416 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1417 if (s->pict_type != B_TYPE) {
1418 s->last_picture_ptr= s->next_picture_ptr;
1419 if(!s->dropable)
1420 s->next_picture_ptr= s->current_picture_ptr;
1421 }
1422 /* 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,
1423 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1424 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1425 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1426 s->pict_type, s->dropable);*/
1427
1428 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1429 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1430
1431 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1432 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1433 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1434 goto alloc;
1435 }
1436
1437 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1438
1439 if(s->picture_structure!=PICT_FRAME){
1440 int i;
1441 for(i=0; i<4; i++){
1442 if(s->picture_structure == PICT_BOTTOM_FIELD){
1443 s->current_picture.data[i] += s->current_picture.linesize[i];
1444 }
1445 s->current_picture.linesize[i] *= 2;
1446 s->last_picture.linesize[i] *=2;
1447 s->next_picture.linesize[i] *=2;
1448 }
1449 }
1450 }
1451
1452 s->hurry_up= s->avctx->hurry_up;
1453 s->error_resilience= avctx->error_resilience;
1454
1455 /* set dequantizer, we cant do it during init as it might change for mpeg4
1456 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1457 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1458 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1459 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1460 }else if(s->out_format == FMT_H263){
1461 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1462 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1463 }else if(s->out_format == FMT_H261){
1464 s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1465 s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1466 }else{
1467 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1468 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1469 }
1470
1471 if(s->dct_error_sum){
1472 assert(s->avctx->noise_reduction && s->encoding);
1473
1474 update_noise_reduction(s);
1475 }
1476
1477 #ifdef HAVE_XVMC
1478 if(s->avctx->xvmc_acceleration)
1479 return XVMC_field_start(s, avctx);
1480 #endif
1481 return 0;
1482 }
1483
1484 /* generic function for encode/decode called after a frame has been coded/decoded */
1485 void MPV_frame_end(MpegEncContext *s)
1486 {
1487 int i;
1488 /* draw edge for correct motion prediction if outside */
1489 #ifdef HAVE_XVMC
1490 //just to make sure that all data is rendered.
1491 if(s->avctx->xvmc_acceleration){
1492 XVMC_field_end(s);
1493 }else
1494 #endif
1495 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1496 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1497 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1498 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1499 }
1500 emms_c();
1501
1502 s->last_pict_type = s->pict_type;
1503 if(s->pict_type!=B_TYPE){
1504 s->last_non_b_pict_type= s->pict_type;
1505 }
1506 #if 0
1507 /* copy back current_picture variables */
1508 for(i=0; i<MAX_PICTURE_COUNT; i++){
1509 if(s->picture[i].data[0] == s->current_picture.data[0]){
1510 s->picture[i]= s->current_picture;
1511 break;
1512 }
1513 }
1514 assert(i<MAX_PICTURE_COUNT);
1515 #endif
1516
1517 if(s->encoding){
1518 /* release non refernce frames */
1519 for(i=0; i<MAX_PICTURE_COUNT; i++){
1520 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1521 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1522 }
1523 }
1524 }
1525 // clear copies, to avoid confusion
1526 #if 0
1527 memset(&s->last_picture, 0, sizeof(Picture));
1528 memset(&s->next_picture, 0, sizeof(Picture));
1529 memset(&s->current_picture, 0, sizeof(Picture));
1530 #endif
1531 }
1532
1533 /**
1534 * draws an line from (ex, ey) -> (sx, sy).
1535 * @param w width of the image
1536 * @param h height of the image
1537 * @param stride stride/linesize of the image
1538 * @param color color of the arrow
1539 */
1540 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1541 int t, x, y, fr, f;
1542
1543 sx= clip(sx, 0, w-1);
1544 sy= clip(sy, 0, h-1);
1545 ex= clip(ex, 0, w-1);
1546 ey= clip(ey, 0, h-1);
1547
1548 buf[sy*stride + sx]+= color;
1549
1550 if(ABS(ex - sx) > ABS(ey - sy)){
1551 if(sx > ex){
1552 t=sx; sx=ex; ex=t;
1553 t=sy; sy=ey; ey=t;
1554 }
1555 buf+= sx + sy*stride;
1556 ex-= sx;
1557 f= ((ey-sy)<<16)/ex;
1558 for(x= 0; x <= ex; x++){
1559 y = (x*f)>>16;
1560 fr= (x*f)&0xFFFF;
1561 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1562 buf[(y+1)*stride + x]+= (color* fr )>>16;
1563 }
1564 }else{
1565 if(sy > ey){
1566 t=sx; sx=ex; ex=t;
1567 t=sy; sy=ey; ey=t;
1568 }
1569 buf+= sx + sy*stride;
1570 ey-= sy;
1571 if(ey) f= ((ex-sx)<<16)/ey;
1572 else f= 0;
1573 for(y= 0; y <= ey; y++){
1574 x = (y*f)>>16;
1575 fr= (y*f)&0xFFFF;
1576 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1577 buf[y*stride + x+1]+= (color* fr )>>16;;
1578 }
1579 }
1580 }
1581
1582 /**
1583 * draws an arrow from (ex, ey) -> (sx, sy).
1584 * @param w width of the image
1585 * @param h height of the image
1586 * @param stride stride/linesize of the image
1587 * @param color color of the arrow
1588 */
1589 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1590 int dx,dy;
1591
1592 sx= clip(sx, -100, w+100);
1593 sy= clip(sy, -100, h+100);
1594 ex= clip(ex, -100, w+100);
1595 ey= clip(ey, -100, h+100);
1596
1597 dx= ex - sx;
1598 dy= ey - sy;
1599
1600 if(dx*dx + dy*dy > 3*3){
1601 int rx= dx + dy;
1602 int ry= -dx + dy;
1603 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1604
1605 //FIXME subpixel accuracy
1606 rx= ROUNDED_DIV(rx*3<<4, length);
1607 ry= ROUNDED_DIV(ry*3<<4, length);
1608
1609 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1610 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1611 }
1612 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1613 }
1614
1615 /**
1616 * prints debuging info for the given picture.
1617 */
1618 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1619
1620 if(!pict || !pict->mb_type) return;
1621
1622 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1623 int x,y;
1624
1625 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1626 switch (pict->pict_type) {
1627 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1628 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1629 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1630 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1631 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1632 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1633 }
1634 for(y=0; y<s->mb_height; y++){
1635 for(x=0; x<s->mb_width; x++){
1636 if(s->avctx->debug&FF_DEBUG_SKIP){
1637 int count= s->mbskip_table[x + y*s->mb_stride];
1638 if(count>9) count=9;
1639 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1640 }
1641 if(s->avctx->debug&FF_DEBUG_QP){
1642 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1643 }
1644 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1645 int mb_type= pict->mb_type[x + y*s->mb_stride];
1646 //Type & MV direction
1647 if(IS_PCM(mb_type))
1648 av_log(s->avctx, AV_LOG_DEBUG, "P");
1649 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1650 av_log(s->avctx, AV_LOG_DEBUG, "A");
1651 else if(IS_INTRA4x4(mb_type))
1652 av_log(s->avctx, AV_LOG_DEBUG, "i");
1653 else if(IS_INTRA16x16(mb_type))
1654 av_log(s->avctx, AV_LOG_DEBUG, "I");
1655 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1656 av_log(s->avctx, AV_LOG_DEBUG, "d");
1657 else if(IS_DIRECT(mb_type))
1658 av_log(s->avctx, AV_LOG_DEBUG, "D");
1659 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1660 av_log(s->avctx, AV_LOG_DEBUG, "g");
1661 else if(IS_GMC(mb_type))
1662 av_log(s->avctx, AV_LOG_DEBUG, "G");
1663 else if(IS_SKIP(mb_type))
1664 av_log(s->avctx, AV_LOG_DEBUG, "S");
1665 else if(!USES_LIST(mb_type, 1))
1666 av_log(s->avctx, AV_LOG_DEBUG, ">");
1667 else if(!USES_LIST(mb_type, 0))
1668 av_log(s->avctx, AV_LOG_DEBUG, "<");
1669 else{
1670 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1671 av_log(s->avctx, AV_LOG_DEBUG, "X");
1672 }
1673
1674 //segmentation
1675 if(IS_8X8(mb_type))
1676 av_log(s->avctx, AV_LOG_DEBUG, "+");
1677 else if(IS_16X8(mb_type))
1678 av_log(s->avctx, AV_LOG_DEBUG, "-");
1679 else if(IS_8X16(mb_type))
1680 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1681 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1682 av_log(s->avctx, AV_LOG_DEBUG, " ");
1683 else
1684 av_log(s->avctx, AV_LOG_DEBUG, "?");
1685
1686
1687 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1688 av_log(s->avctx, AV_LOG_DEBUG, "=");
1689 else
1690 av_log(s->avctx, AV_LOG_DEBUG, " ");
1691 }
1692 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1693 }
1694 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1695 }
1696 }
1697
1698 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1699 const int shift= 1 + s->quarter_sample;
1700 int mb_y;
1701 uint8_t *ptr;
1702 int i;
1703 int h_chroma_shift, v_chroma_shift;
1704 s->low_delay=0; //needed to see the vectors without trashing the buffers
1705
1706 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1707 for(i=0; i<3; i++){
1708 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*s->height:pict->linesize[i]*s->height >> v_chroma_shift);
1709 pict->data[i]= s->visualization_buffer[i];
1710 }
1711 pict->type= FF_BUFFER_TYPE_COPY;
1712 ptr= pict->data[0];
1713
1714 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1715 int mb_x;
1716 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1717 const int mb_index= mb_x + mb_y*s->mb_stride;
1718 if((s->avctx->debug_mv) && pict->motion_val){
1719 int type;
1720 for(type=0; type<3; type++){
1721 int direction = 0;
1722 switch (type) {
1723 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1724 continue;
1725 direction = 0;
1726 break;
1727 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1728 continue;
1729 direction = 0;
1730 break;
1731 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1732 continue;
1733 direction = 1;
1734 break;
1735 }
1736 if(!USES_LIST(pict->mb_type[mb_index], direction))
1737 continue;
1738
1739 //FIXME for h264
1740 if(IS_8X8(pict->mb_type[mb_index])){
1741 int i;
1742 for(i=0; i<4; i++){
1743 int sx= mb_x*16 + 4 + 8*(i&1);
1744 int sy= mb_y*16 + 4 + 8*(i>>1);
1745 int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1746 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1747 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1748 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1749 }
1750 }else if(IS_16X8(pict->mb_type[mb_index])){
1751 int i;
1752 for(i=0; i<2; i++){
1753 int sx=mb_x*16 + 8;
1754 int sy=mb_y*16 + 4 + 8*i;
1755 int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1756 int mx=(pict->motion_val[direction][xy][0]>>shift);
1757 int my=(pict->motion_val[direction][xy][1]>>shift);
1758
1759 if(IS_INTERLACED(pict->mb_type[mb_index]))
1760 my*=2;
1761
1762 draw_arrow(ptr, sx, sy, mx+sx, my+sy, s->width, s->height, s->linesize, 100);
1763 }
1764 }else{
1765 int sx= mb_x*16 + 8;
1766 int sy= mb_y*16 + 8;
1767 int xy= mb_x*2 + mb_y*2*s->b8_stride;
1768 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1769 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1770 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1771 }
1772 }
1773 }
1774 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1775 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1776 int y;
1777 for(y=0; y<8; y++){
1778 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1779 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1780 }
1781 }
1782 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1783 int mb_type= pict->mb_type[mb_index];
1784 uint64_t u,v;
1785 int y;
1786 #define COLOR(theta, r)\
1787 u= (int)(128 + r*cos(theta*3.141592/180));\
1788 v= (int)(128 + r*sin(theta*3.141592/180));
1789
1790
1791 u=v=128;
1792 if(IS_PCM(mb_type)){
1793 COLOR(120,48)
1794 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1795 COLOR(30,48)
1796 }else if(IS_INTRA4x4(mb_type)){
1797 COLOR(90,48)
1798 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1799 // COLOR(120,48)
1800 }else if(IS_DIRECT(mb_type)){
1801 COLOR(150,48)
1802 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1803 COLOR(170,48)
1804 }else if(IS_GMC(mb_type)){
1805 COLOR(190,48)
1806 }else if(IS_SKIP(mb_type)){
1807 // COLOR(180,48)
1808 }else if(!USES_LIST(mb_type, 1)){
1809 COLOR(240,48)
1810 }else if(!USES_LIST(mb_type, 0)){
1811 COLOR(0,48)
1812 }else{
1813 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1814 COLOR(300,48)
1815 }
1816
1817 u*= 0x0101010101010101ULL;
1818 v*= 0x0101010101010101ULL;
1819 for(y=0; y<8; y++){
1820 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1821 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1822 }
1823
1824 //segmentation
1825 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1826 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1827 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1828 }
1829 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1830 for(y=0; y<16; y++)
1831 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1832 }
1833
1834 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1835 // hmm
1836 }
1837 }
1838 s->mbskip_table[mb_index]=0;
1839 }
1840 }
1841 }
1842 }
1843
1844 #ifdef CONFIG_ENCODERS
1845
1846 static int get_sae(uint8_t *src, int ref, int stride){
1847 int x,y;
1848 int acc=0;
1849
1850 for(y=0; y<16; y++){
1851 for(x=0; x<16; x++){
1852 acc+= ABS(src[x+y*stride] - ref);
1853 }
1854 }
1855
1856 return acc;
1857 }
1858
1859 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1860 int x, y, w, h;
1861 int acc=0;
1862
1863 w= s->width &~15;
1864 h= s->height&~15;
1865
1866 for(y=0; y<h; y+=16){
1867 for(x=0; x<w; x+=16){
1868 int offset= x + y*stride;
1869 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1870 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1871 int sae = get_sae(src + offset, mean, stride);
1872
1873 acc+= sae + 500 < sad;
1874 }
1875 }
1876 return acc;
1877 }
1878
1879
1880 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1881 AVFrame *pic=NULL;
1882 int i;
1883 const int encoding_delay= s->max_b_frames;
1884 int direct=1;
1885
1886 if(pic_arg){
1887 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1888 if(pic_arg->linesize[0] != s->linesize) direct=0;
1889 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1890 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1891
1892 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1893
1894 if(direct){
1895 i= ff_find_unused_picture(s, 1);
1896
1897 pic= (AVFrame*)&s->picture[i];
1898 pic->reference= 3;
1899
1900 for(i=0; i<4; i++){
1901 pic->data[i]= pic_arg->data[i];
1902 pic->linesize[i]= pic_arg->linesize[i];
1903 }
1904 alloc_picture(s, (Picture*)pic, 1);
1905 }else{
1906 int offset= 16;
1907 i= ff_find_unused_picture(s, 0);
1908
1909 pic= (AVFrame*)&s->picture[i];
1910 pic->reference= 3;
1911
1912 alloc_picture(s, (Picture*)pic, 0);
1913
1914 if( pic->data[0] + offset == pic_arg->data[0]
1915 && pic->data[1] + offset == pic_arg->data[1]
1916 && pic->data[2] + offset == pic_arg->data[2]){
1917 // empty
1918 }else{
1919 int h_chroma_shift, v_chroma_shift;
1920 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1921
1922 for(i=0; i<3; i++){
1923 int src_stride= pic_arg->linesize[i];
1924 int dst_stride= i ? s->uvlinesize : s->linesize;
1925 int h_shift= i ? h_chroma_shift : 0;
1926 int v_shift= i ? v_chroma_shift : 0;
1927 int w= s->width >>h_shift;
1928 int h= s->height>>v_shift;
1929 uint8_t *src= pic_arg->data[i];
1930 uint8_t *dst= pic->data[i] + offset;
1931
1932 if(src_stride==dst_stride)
1933 memcpy(dst, src, src_stride*h);
1934 else{
1935 while(h--){
1936 memcpy(dst, src, w);
1937 dst += dst_stride;
1938 src += src_stride;
1939 }
1940 }
1941 }
1942 }
1943 }
1944 copy_picture_attributes(s, pic, pic_arg);
1945
1946 pic->display_picture_number= s->input_picture_number++;
1947 if(pic->pts != AV_NOPTS_VALUE){
1948 s->user_specified_pts= pic->pts;
1949 }else{
1950 if(s->user_specified_pts){
1951 pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1952 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1953 }else{
1954 pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1955 }
1956 }
1957 }
1958
1959 /* shift buffer entries */
1960 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1961 s->input_picture[i-1]= s->input_picture[i];
1962
1963 s->input_picture[encoding_delay]= (Picture*)pic;
1964
1965 return 0;
1966 }
1967
1968 static void select_input_picture(MpegEncContext *s){
1969 int i;
1970
1971 for(i=1; i<MAX_PICTURE_COUNT; i++)
1972 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1973 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1974
1975 /* set next picture types & ordering */
1976 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1977 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1978 s->reordered_input_picture[0]= s->input_picture[0];
1979 s->reordered_input_picture[0]->pict_type= I_TYPE;
1980 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
1981 }else{
1982 int b_frames;
1983
1984 if(s->flags&CODEC_FLAG_PASS2){
1985 for(i=0; i<s->max_b_frames+1; i++){
1986 int pict_num= s->input_picture[0]->display_picture_number + i;
1987 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1988 s->input_picture[i]->pict_type= pict_type;
1989
1990 if(i + 1 >= s->rc_context.num_entries) break;
1991 }
1992 }
1993
1994 if(s->input_picture[0]->pict_type){
1995 /* user selected pict_type */
1996 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1997 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1998 }
1999
2000 if(b_frames > s->max_b_frames){
2001 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2002 b_frames = s->max_b_frames;
2003 }
2004 }else if(s->avctx->b_frame_strategy==0){
2005 b_frames= s->max_b_frames;
2006 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2007 }else if(s->avctx->b_frame_strategy==1){
2008 for(i=1; i<s->max_b_frames+1; i++){
2009 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2010 s->input_picture[i]->b_frame_score=
2011 get_intra_count(s, s->input_picture[i ]->data[0],
2012 s->input_picture[i-1]->data[0], s->linesize) + 1;
2013 }
2014 }
2015 for(i=0; i<s->max_b_frames; i++){
2016 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2017 }
2018
2019 b_frames= FFMAX(0, i-1);
2020
2021 /* reset scores */
2022 for(i=0; i<b_frames+1; i++){
2023 s->input_picture[i]->b_frame_score=0;
2024 }
2025 }else{
2026 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2027 b_frames=0;
2028 }
2029
2030 emms_c();
2031 //static int b_count=0;
2032 //b_count+= b_frames;
2033 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2034 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2035 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2036 b_frames=0;
2037 s->input_picture[b_frames]->pict_type= I_TYPE;
2038 }
2039
2040 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2041 && b_frames
2042 && s->input_picture[b_frames]->pict_type== I_TYPE)
2043 b_frames--;
2044
2045 s->reordered_input_picture[0]= s->input_picture[b_frames];
2046 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2047 s->reordered_input_picture[0]->pict_type= P_TYPE;
2048 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2049 for(i=0; i<b_frames; i++){
2050 s->reordered_input_picture[i+1]= s->input_picture[i];
2051 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2052 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2053 }
2054 }
2055 }
2056
2057 if(s->reordered_input_picture[0]){
2058 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2059
2060 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2061
2062 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2063 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2064
2065 int i= ff_find_unused_picture(s, 0);
2066 Picture *pic= &s->picture[i];
2067
2068 /* mark us unused / free shared pic */
2069 for(i=0; i<4; i++)
2070 s->reordered_input_picture[0]->data[i]= NULL;
2071 s->reordered_input_picture[0]->type= 0;
2072
2073 pic->reference = s->reordered_input_picture[0]->reference;
2074
2075 alloc_picture(s, pic, 0);
2076
2077 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2078
2079 s->current_picture_ptr= pic;
2080 }else{
2081 // input is not a shared pix -> reuse buffer for current_pix
2082
2083 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2084 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2085
2086 s->current_picture_ptr= s->reordered_input_picture[0];
2087 for(i=0; i<4; i++){
2088 s->new_picture.data[i]+=16;
2089 }
2090 }
2091 copy_picture(&s->current_picture, s->current_picture_ptr);
2092
2093 s->picture_number= s->new_picture.display_picture_number;
2094 //printf("dpn:%d\n", s->picture_number);
2095 }else{
2096 memset(&s->new_picture, 0, sizeof(Picture));
2097 }
2098 }
2099
2100 int MPV_encode_picture(AVCodecContext *avctx,
2101 unsigned char *buf, int buf_size, void *data)
2102 {
2103 MpegEncContext *s = avctx->priv_data;
2104 AVFrame *pic_arg = data;
2105 int i, stuffing_count;
2106
2107 if(avctx->pix_fmt != PIX_FMT_YUV420P){
2108 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2109 return -1;
2110 }
2111
2112 for(i=0; i<avctx->thread_count; i++){
2113 int start_y= s->thread_context[i]->start_mb_y;
2114 int end_y= s->thread_context[i]-> end_mb_y;
2115 int h= s->mb_height;
2116 uint8_t *start= buf + buf_size*start_y/h;
2117 uint8_t *end = buf + buf_size* end_y/h;
2118
2119 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2120 }
2121
2122 s->picture_in_gop_number++;
2123
2124 load_input_picture(s, pic_arg);
2125
2126 select_input_picture(s);
2127
2128 /* output? */
2129 if(s->new_picture.data[0]){
2130 s->pict_type= s->new_picture.pict_type;
2131 //emms_c();
2132 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2133 MPV_frame_start(s, avctx);
2134
2135 encode_picture(s, s->picture_number);
2136
2137 avctx->real_pict_num = s->picture_number;
2138 avctx->header_bits = s->header_bits;
2139 avctx->mv_bits = s->mv_bits;
2140 avctx->misc_bits = s->misc_bits;
2141 avctx->i_tex_bits = s->i_tex_bits;
2142 avctx->p_tex_bits = s->p_tex_bits;
2143 avctx->i_count = s->i_count;
2144 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2145 avctx->skip_count = s->skip_count;
2146
2147 MPV_frame_end(s);
2148
2149 if (s->out_format == FMT_MJPEG)
2150 mjpeg_picture_trailer(s);
2151
2152 if(s->flags&CODEC_FLAG_PASS1)
2153 ff_write_pass1_stats(s);
2154
2155 for(i=0; i<4; i++){
2156 avctx->error[i] += s->current_picture_ptr->error[i];
2157 }
2158
2159 flush_put_bits(&s->pb);
2160 s->frame_bits = put_bits_count(&s->pb);
2161
2162 stuffing_count= ff_vbv_update(s, s->frame_bits);
2163 if(stuffing_count){
2164 switch(s->codec_id){
2165 case CODEC_ID_MPEG1VIDEO:
2166 case CODEC_ID_MPEG2VIDEO:
2167 while(stuffing_count--){
2168 put_bits(&s->pb, 8, 0);
2169 }
2170 break;
2171 case CODEC_ID_MPEG4:
2172 put_bits(&s->pb, 16, 0);
2173 put_bits(&s->pb, 16, 0x1C3);
2174 stuffing_count -= 4;
2175 while(stuffing_count--){
2176 put_bits(&s->pb, 8, 0xFF);
2177 }
2178 break;
2179 default:
2180 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2181 }
2182 flush_put_bits(&s->pb);
2183 s->frame_bits = put_bits_count(&s->pb);
2184 }
2185
2186 /* update mpeg1/2 vbv_delay for CBR */
2187 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2188 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2189 int vbv_delay;
2190
2191 assert(s->repeat_first_field==0);
2192
2193 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2194 assert(vbv_delay < 0xFFFF);
2195
2196 s->vbv_delay_ptr[0] &= 0xF8;
2197 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2198 s->vbv_delay_ptr[1] = vbv_delay>>5;
2199 s->vbv_delay_ptr[2] &= 0x07;
2200 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2201 }
2202 s->total_bits += s->frame_bits;
2203 avctx->frame_bits = s->frame_bits;
2204 }else{
2205 assert((pbBufPtr(&s->pb) == s->pb.buf));
2206 s->frame_bits=0;
2207 }
2208 assert((s->frame_bits&7)==0);
2209
2210 return s->frame_bits/8;
2211 }
2212
2213 #endif //CONFIG_ENCODERS
2214
2215 static inline void gmc1_motion(MpegEncContext *s,
2216 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2217 uint8_t **ref_picture)
2218 {
2219 uint8_t *ptr;
2220 int offset, src_x, src_y, linesize, uvlinesize;
2221 int motion_x, motion_y;
2222 int emu=0;
2223
2224 motion_x= s->sprite_offset[0][0];
2225 motion_y= s->sprite_offset[0][1];
2226 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2227 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2228 motion_x<<=(3-s->sprite_warping_accuracy);
2229 motion_y<<=(3-s->sprite_warping_accuracy);
2230 src_x = clip(src_x, -16, s->width);
2231 if (src_x == s->width)
2232 motion_x =0;
2233 src_y = clip(src_y, -16, s->height);
2234 if (src_y == s->height)
2235 motion_y =0;
2236
2237 linesize = s->linesize;
2238 uvlinesize = s->uvlinesize;
2239
2240 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2241
2242 if(s->flags&CODEC_FLAG_EMU_EDGE){
2243 if( (unsigned)src_x >= s->h_edge_pos - 17
2244 || (unsigned)src_y >= s->v_edge_pos - 17){
2245 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2246 ptr= s->edge_emu_buffer;
2247 }
2248 }
2249
2250 if((motion_x|motion_y)&7){
2251 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2252 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2253 }else{
2254 int dxy;
2255
2256 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2257 if (s->no_rounding){
2258 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2259 }else{
2260 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2261 }
2262 }
2263
2264 if(s->flags&CODEC_FLAG_GRAY) return;
2265
2266 motion_x= s->sprite_offset[1][0];
2267 motion_y= s->sprite_offset[1][1];
2268 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2269 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2270 motion_x<<=(3-s->sprite_warping_accuracy);
2271 motion_y<<=(3-s->sprite_warping_accuracy);
2272 src_x = clip(src_x, -8, s->width>>1);
2273 if (src_x == s->width>>1)
2274 motion_x =0;
2275 src_y = clip(src_y, -8, s->height>>1);
2276 if (src_y == s->height>>1)
2277 motion_y =0;
2278
2279 offset = (src_y * uvlinesize) + src_x;
2280 ptr = ref_picture[1] + offset;
2281 if(s->flags&CODEC_FLAG_EMU_EDGE){
2282 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2283 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2284 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);
2285 ptr= s->edge_emu_buffer;
2286 emu=1;
2287 }
2288 }
2289 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2290
2291 ptr = ref_picture[2] + offset;
2292 if(emu){
2293 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);
2294 ptr= s->edge_emu_buffer;
2295 }
2296 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2297
2298 return;
2299 }
2300
2301 static inline void gmc_motion(MpegEncContext *s,
2302 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2303 uint8_t **ref_picture)
2304 {
2305 uint8_t *ptr;
2306 int linesize, uvlinesize;
2307 const int a= s->sprite_warping_accuracy;
2308 int ox, oy;
2309
2310 linesize = s->linesize;
2311 uvlinesize = s->uvlinesize;
2312
2313 ptr = ref_picture[0];
2314
2315 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2316 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2317
2318 s->dsp.gmc(dest_y, ptr, linesize, 16,
2319 ox,
2320 oy,
2321 s->sprite_delta[0][0], s->sprite_delta[0][1],
2322 s->sprite_delta[1][0], s->sprite_delta[1][1],
2323 a+1, (1<<(2*a+1)) - s->no_rounding,
2324 s->h_edge_pos, s->v_edge_pos);
2325 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2326 ox + s->sprite_delta[0][0]*8,
2327 oy + s->sprite_delta[1][0]*8,
2328 s->sprite_delta[0][0], s->sprite_delta[0][1],
2329 s->sprite_delta[1][0], s->sprite_delta[1][1],
2330 a+1, (1<<(2*a+1)) - s->no_rounding,
2331 s->h_edge_pos, s->v_edge_pos);
2332
2333 if(s->flags&CODEC_FLAG_GRAY) return;
2334
2335 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2336 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2337
2338 ptr = ref_picture[1];
2339 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2340 ox,
2341 oy,
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>>1, s->v_edge_pos>>1);
2346
2347 ptr = ref_picture[2];
2348 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2349 ox,
2350 oy,
2351 s->sprite_delta[0][0], s->sprite_delta[0][1],
2352 s->sprite_delta[1][0], s->sprite_delta[1][1],
2353 a+1, (1<<(2*a+1)) - s->no_rounding,
2354 s->h_edge_pos>>1, s->v_edge_pos>>1);
2355 }
2356
2357 /**
2358 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2359 * @param buf destination buffer
2360 * @param src source buffer
2361 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2362 * @param block_w width of block
2363 * @param block_h height of block
2364 * @param src_x x coordinate of the top left sample of the block in the source buffer
2365 * @param src_y y coordinate of the top left sample of the block in the source buffer
2366 * @param w width of the source buffer
2367 * @param h height of the source buffer
2368 */
2369 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2370 int src_x, int src_y, int w, int h){
2371 int x, y;
2372 int start_y, start_x, end_y, end_x;
2373
2374 if(src_y>= h){
2375 src+= (h-1-src_y)*linesize;
2376 src_y=h-1;
2377 }else if(src_y<=-block_h){
2378 src+= (1-block_h-src_y)*linesize;
2379 src_y=1-block_h;
2380 }
2381 if(src_x>= w){
2382 src+= (w-1-src_x);
2383 src_x=w-1;
2384 }else if(src_x<=-block_w){
2385 src+= (1-block_w-src_x);
2386 src_x=1-block_w;
2387 }
2388
2389 start_y= FFMAX(0, -src_y);
2390 start_x= FFMAX(0, -src_x);
2391 end_y= FFMIN(block_h, h-src_y);
2392 end_x= FFMIN(block_w, w-src_x);
2393
2394 // copy existing part
2395 for(y=start_y; y<end_y; y++){
2396 for(x=start_x; x<end_x; x++){
2397 buf[x + y*linesize]= src[x + y*linesize];
2398 }
2399 }
2400
2401 //top
2402 for(y=0; y<start_y; y++){
2403 for(x=start_x; x<end_x; x++){
2404 buf[x + y*linesize]= buf[x + start_y*linesize];
2405 }
2406 }
2407
2408 //bottom
2409 for(y=end_y; y<block_h; y++){
2410 for(x=start_x; x<end_x; x++){
2411 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2412 }
2413 }
2414
2415 for(y=0; y<block_h; y++){
2416 //left
2417 for(x=0; x<start_x; x++){
2418 buf[x + y*linesize]= buf[start_x + y*linesize];
2419 }
2420
2421 //right
2422 for(x=end_x; x<block_w; x++){
2423 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2424 }
2425 }
2426 }
2427
2428 static inline int hpel_motion(MpegEncContext *s,
2429 uint8_t *dest, uint8_t *src,
2430 int field_based, int field_select,
2431 int src_x, int src_y,
2432 int width, int height, int stride,
2433 int h_edge_pos, int v_edge_pos,
2434 int w, int h, op_pixels_func *pix_op,
2435 int motion_x, int motion_y)
2436 {
2437 int dxy;
2438 int emu=0;
2439
2440 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2441 src_x += motion_x >> 1;
2442 src_y += motion_y >> 1;
2443
2444 /* WARNING: do no forget half pels */
2445 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2446 if (src_x == width)
2447 dxy &= ~1;
2448 src_y = clip(src_y, -16, height);
2449 if (src_y == height)
2450 dxy &= ~2;
2451 src += src_y * stride + src_x;
2452
2453 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2454 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2455 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2456 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2457 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2458 src= s->edge_emu_buffer;
2459 emu=1;
2460 }
2461 }
2462 if(field_select)
2463 src += s->linesize;
2464 pix_op[dxy](dest, src, stride, h);
2465 return emu;
2466 }
2467
2468 /* apply one mpeg motion vector to the three components */
2469 static inline void mpeg_motion(MpegEncContext *s,
2470 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2471 int field_based, int bottom_field, int field_select,
2472 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2473 int motion_x, int motion_y, int h)
2474 {
2475 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2476 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2477
2478 #if 0
2479 if(s->quarter_sample)
2480 {
2481 motion_x>>=1;
2482 motion_y>>=1;
2483 }
2484 #endif
2485
2486 v_edge_pos = s->v_edge_pos >> field_based;
2487 linesize = s->current_picture.linesize[0] << field_based;
2488 uvlinesize = s->current_picture.linesize[1] << field_based;
2489
2490 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2491 src_x = s->mb_x* 16 + (motion_x >> 1);
2492 src_y = s->mb_y*(16>>field_based) + (motion_y >> 1);
2493
2494 if (s->out_format == FMT_H263) {
2495 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2496 mx = (motion_x>>1)|(motion_x&1);
2497 my = motion_y >>1;
2498 uvdxy = ((my & 1) << 1) | (mx & 1);
2499 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2500 uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2501 }else{
2502 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2503 uvsrc_x = src_x>>1;
2504 uvsrc_y = src_y>>1;
2505 }
2506 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2507 mx = motion_x / 4;
2508 my = motion_y / 4;
2509 uvdxy = 0;
2510 uvsrc_x = s->mb_x*8 + mx;
2511 uvsrc_y = s->mb_y*8 + my;
2512 } else {
2513 mx = motion_x / 2;
2514 my = motion_y / 2;
2515 uvdxy = ((my & 1) << 1) | (mx & 1);
2516 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2517 uvsrc_y = s->mb_y*(8>>field_based) + (my >> 1);
2518 }
2519
2520 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2521 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2522 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2523
2524 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2525 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2526 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2527 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2528 ptr_y = s->edge_emu_buffer;
2529 if(!(s->flags&CODEC_FLAG_GRAY)){
2530 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2531 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2532 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2533 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2534 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2535 ptr_cb= uvbuf;
2536 ptr_cr= uvbuf+16;
2537 }
2538 }
2539
2540 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2541 dest_y += s->linesize;
2542 dest_cb+= s->uvlinesize;
2543 dest_cr+= s->uvlinesize;
2544 }
2545
2546 if(field_select){
2547 ptr_y += s->linesize;
2548 ptr_cb+= s->uvlinesize;
2549 ptr_cr+= s->uvlinesize;
2550 }
2551
2552 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2553
2554 if(!(s->flags&CODEC_FLAG_GRAY)){
2555 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2556 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2557 }
2558 }
2559 //FIXME move to dsputil, avg variant, 16x16 version
2560 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2561 int x;
2562 uint8_t * const top = src[1];
2563 uint8_t * const left = src[2];
2564 uint8_t * const mid = src[0];
2565 uint8_t * const right = src[3];
2566 uint8_t * const bottom= src[4];
2567 #define OBMC_FILTER(x, t, l, m, r, b)\
2568 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2569 #define OBMC_FILTER4(x, t, l, m, r, b)\
2570 OBMC_FILTER(x , t, l, m, r, b);\
2571 OBMC_FILTER(x+1 , t, l, m, r, b);\
2572 OBMC_FILTER(x +stride, t, l, m, r, b);\
2573 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2574
2575 x=0;
2576 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2577 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2578 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2579 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2580 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2581 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2582 x+= stride;
2583 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2584 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2585 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2586 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2587 x+= stride;
2588 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2589 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2590 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2591 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2592 x+= 2*stride;
2593 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2594 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2595 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2596 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2597 x+= 2*stride;
2598 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2599 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2600 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2601 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2602 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2603 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2604 x+= stride;
2605 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2606 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2607 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2608 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2609 }
2610
2611 /* obmc for 1 8x8 luma block */
2612 static inline void obmc_motion(MpegEncContext *s,
2613 uint8_t *dest, uint8_t *src,
2614 int src_x, int src_y,
2615 op_pixels_func *pix_op,
2616 int16_t mv[5][2]/* mid top left right bottom*/)
2617 #define MID 0
2618 {
2619 int i;
2620 uint8_t *ptr[5];
2621
2622 assert(s->quarter_sample==0);
2623
2624 for(i=0; i<5; i++){
2625 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2626 ptr[i]= ptr[MID];
2627 }else{
2628 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2629 hpel_motion(s, ptr[i], src, 0, 0,
2630 src_x, src_y,
2631 s->width, s->height, s->linesize,
2632 s->h_edge_pos, s->v_edge_pos,
2633 8, 8, pix_op,
2634 mv[i][0], mv[i][1]);
2635 }
2636 }
2637
2638 put_obmc(dest, ptr, s->linesize);
2639 }
2640
2641 static inline void qpel_motion(MpegEncContext *s,
2642 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2643 int field_based, int bottom_field, int field_select,
2644 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2645 qpel_mc_func (*qpix_op)[16],
2646 int motion_x, int motion_y, int h)
2647 {
2648 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2649 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2650
2651 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2652 src_x = s->mb_x * 16 + (motion_x >> 2);
2653 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2654
2655 v_edge_pos = s->v_edge_pos >> field_based;
2656 linesize = s->linesize << field_based;
2657 uvlinesize = s->uvlinesize << field_based;
2658
2659 if(field_based){
2660 mx= motion_x/2;
2661 my= motion_y>>1;
2662 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2663 static const int rtab[8]= {0,0,1,1,0,0,0,1};
2664 mx= (motion_x>>1) + rtab[motion_x&7];
2665 my= (motion_y>>1) + rtab[motion_y&7];
2666 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2667 mx= (motion_x>>1)|(motion_x&1);
2668 my= (motion_y>>1)|(motion_y&1);
2669 }else{
2670 mx= motion_x/2;
2671 my= motion_y/2;
2672 }
2673 mx= (mx>>1)|(mx&1);
2674 my= (my>>1)|(my&1);
2675
2676 uvdxy= (mx&1) | ((my&1)<<1);
2677 mx>>=1;
2678 my>>=1;
2679
2680 uvsrc_x = s->mb_x * 8 + mx;
2681 uvsrc_y = s->mb_y * (8 >> field_based) + my;
2682
2683 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2684 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2685 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2686
2687 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
2688 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
2689 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2690 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2691 ptr_y= s->edge_emu_buffer;
2692 if(!(s->flags&CODEC_FLAG_GRAY)){
2693 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2694 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
2695 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2696 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
2697 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2698 ptr_cb= uvbuf;
2699 ptr_cr= uvbuf + 16;
2700 }
2701 }
2702
2703 if(!field_based)
2704 qpix_op[0][dxy](dest_y, ptr_y, linesize);
2705 else{
2706 if(bottom_field){
2707 dest_y += s->linesize;
2708 dest_cb+= s->uvlinesize;
2709 dest_cr+= s->uvlinesize;
2710 }
2711
2712 if(field_select){
2713 ptr_y += s->linesize;
2714 ptr_cb += s->uvlinesize;
2715 ptr_cr += s->uvlinesize;
2716 }
2717 //damn interlaced mode
2718 //FIXME boundary mirroring is not exactly correct here
2719 qpix_op[1][dxy](dest_y , ptr_y , linesize);
2720 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2721 }
2722 if(!(s->flags&CODEC_FLAG_GRAY)){
2723 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2724 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2725 }
2726 }
2727
2728 inline int ff_h263_round_chroma(int x){
2729 if (x >= 0)
2730 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2731 else {
2732 x = -x;
2733 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2734 }
2735 }
2736
2737 /**
2738 * h263 chorma 4mv motion compensation.
2739 */
2740 static inline void chroma_4mv_motion(MpegEncContext *s,
2741 uint8_t *dest_cb, uint8_t *dest_cr,
2742 uint8_t **ref_picture,
2743 op_pixels_func *pix_op,
2744 int mx, int my){
2745 int dxy, emu=0, src_x, src_y, offset;
2746 uint8_t *ptr;
2747
2748 /* In case of 8X8, we construct a single chroma motion vector
2749 with a special rounding */
2750 mx= ff_h263_round_chroma(mx);
2751 my= ff_h263_round_chroma(my);
2752
2753 dxy = ((my & 1) << 1) | (mx & 1);
2754 mx >>= 1;
2755 my >>= 1;
2756
2757 src_x = s->mb_x * 8 + mx;
2758 src_y = s->mb_y * 8 + my;
2759 src_x = clip(src_x, -8, s->width/2);
2760 if (src_x == s->width/2)
2761 dxy &= ~1;
2762 src_y = clip(src_y, -8, s->height/2);
2763 if (src_y == s->height/2)
2764 dxy &= ~2;
2765
2766 offset = (src_y * (s->uvlinesize)) + src_x;
2767 ptr = ref_picture[1] + offset;
2768 if(s->flags&CODEC_FLAG_EMU_EDGE){
2769 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2770 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2771 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2772 ptr= s->edge_emu_buffer;
2773 emu=1;
2774 }
2775 }
2776 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2777
2778 ptr = ref_picture[2] + offset;
2779 if(emu){
2780 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2781 ptr= s->edge_emu_buffer;
2782 }
2783 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2784 }
2785
2786 /**
2787 * motion compesation of a single macroblock