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>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
41 #ifdef CONFIG_ENCODERS
42 static int 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_intra_bitexact(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
59 #ifdef CONFIG_ENCODERS
60 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
61 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
62 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
63 static int sse_mb(MpegEncContext *s);
64 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
65 #endif //CONFIG_ENCODERS
68 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
69 extern void XVMC_field_end(MpegEncContext *s);
70 extern void XVMC_decode_mb(MpegEncContext *s);
73 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
76 /* enable all paranoid tests for rounding, overflows, etc... */
82 /* for jpeg fast DCT */
85 static const uint16_t aanscales[64] = {
86 /* precomputed values scaled up by 14 bits */
87 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
88 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
89 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
90 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
91 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
92 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
93 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
94 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
97 static const uint8_t h263_chroma_roundtab[16] = {
98 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
99 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
102 static const uint8_t ff_default_chroma_qscale_table[32]={
103 // 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
104 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 #ifdef CONFIG_ENCODERS
108 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
109 static uint8_t default_fcode_tab[MAX_MV*2+1];
111 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
113 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
114 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
119 for(qscale=qmin; qscale<=qmax; qscale++){
121 if (dsp->fdct == ff_jpeg_fdct_islow
122 #ifdef FAAN_POSTSCALE
123 || dsp->fdct == ff_faandct
127 const int j= dsp->idct_permutation[i];
128 /* 16 <= qscale * quant_matrix[i] <= 7905 */
129 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
130 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
131 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
133 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
134 (qscale * quant_matrix[j]));
136 } else if (dsp->fdct == fdct_ifast
137 #ifndef FAAN_POSTSCALE
138 || dsp->fdct == ff_faandct
142 const int j= dsp->idct_permutation[i];
143 /* 16 <= qscale * quant_matrix[i] <= 7905 */
144 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
145 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
146 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
148 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
149 (aanscales[i] * qscale * quant_matrix[j]));
153 const int j= dsp->idct_permutation[i];
154 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
155 So 16 <= qscale * quant_matrix[i] <= 7905
156 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
157 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
159 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
160 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
161 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
163 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
164 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
168 for(i=intra; i<64; i++){
170 if (dsp->fdct == fdct_ifast
171 #ifndef FAAN_POSTSCALE
172 || dsp->fdct == ff_faandct
175 max= (8191LL*aanscales[i]) >> 14;
177 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
183 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
187 static inline void update_qscale(MpegEncContext *s){
188 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
189 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
191 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
193 #endif //CONFIG_ENCODERS
195 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
199 st->scantable= src_scantable;
203 j = src_scantable[i];
204 st->permutated[i] = permutation[j];
213 j = st->permutated[i];
215 st->raster_end[i]= end;
219 #ifdef CONFIG_ENCODERS
220 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
226 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
231 #endif //CONFIG_ENCODERS
233 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
241 uint32_t tmp= *state << 8;
242 *state= tmp + *(p++);
243 if(tmp == 0x100 || p==end)
248 if (p[-1] > 1 ) p+= 3;
249 else if(p[-2] ) p+= 2;
250 else if(p[-3]|(p[-1]-1)) p++;
258 *state= be2me_32(unaligned32(p));
263 /* init common dct for both encoder and decoder */
264 int DCT_common_init(MpegEncContext *s)
266 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
267 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
268 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
269 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
270 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
271 if(s->flags & CODEC_FLAG_BITEXACT)
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
273 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
275 #ifdef CONFIG_ENCODERS
276 s->dct_quantize= dct_quantize_c;
277 s->denoise_dct= denoise_dct_c;
278 #endif //CONFIG_ENCODERS
280 #if defined(HAVE_MMX)
281 MPV_common_init_mmx(s);
282 #elif defined(ARCH_ALPHA)
283 MPV_common_init_axp(s);
284 #elif defined(HAVE_MLIB)
285 MPV_common_init_mlib(s);
286 #elif defined(HAVE_MMI)
287 MPV_common_init_mmi(s);
288 #elif defined(ARCH_ARMV4L)
289 MPV_common_init_armv4l(s);
290 #elif defined(ARCH_POWERPC)
291 MPV_common_init_ppc(s);
292 #elif defined(ARCH_BFIN)
293 MPV_common_init_bfin(s);
296 #ifdef CONFIG_ENCODERS
297 s->fast_dct_quantize= s->dct_quantize;
299 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
300 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
303 #endif //CONFIG_ENCODERS
305 /* load & permutate scantables
306 note: only wmv uses different ones
308 if(s->alternate_scan){
309 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
310 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
312 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
313 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
316 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
321 static void copy_picture(Picture *dst, Picture *src){
323 dst->type= FF_BUFFER_TYPE_COPY;
326 #ifdef CONFIG_ENCODERS
327 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
330 dst->pict_type = src->pict_type;
331 dst->quality = src->quality;
332 dst->coded_picture_number = src->coded_picture_number;
333 dst->display_picture_number = src->display_picture_number;
334 // dst->reference = src->reference;
336 dst->interlaced_frame = src->interlaced_frame;
337 dst->top_field_first = src->top_field_first;
339 if(s->avctx->me_threshold){
340 if(!src->motion_val[0])
341 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
343 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
344 if(!src->ref_index[0])
345 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
346 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
347 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
348 src->motion_subsample_log2, dst->motion_subsample_log2);
350 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
353 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
354 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
356 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
357 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
359 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
360 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
368 * allocates a Picture
369 * The pixels are allocated/set by calling get_buffer() if shared=0
371 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
372 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
373 const int mb_array_size= s->mb_stride*s->mb_height;
374 const int b8_array_size= s->b8_stride*s->mb_height*2;
375 const int b4_array_size= s->b4_stride*s->mb_height*4;
379 assert(pic->data[0]);
380 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
381 pic->type= FF_BUFFER_TYPE_SHARED;
385 assert(!pic->data[0]);
387 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
389 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
390 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
394 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
399 if(pic->linesize[1] != pic->linesize[2]){
400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
404 s->linesize = pic->linesize[0];
405 s->uvlinesize= pic->linesize[1];
408 if(pic->qscale_table==NULL){
410 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
411 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
412 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
415 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
416 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
417 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
418 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
419 if(s->out_format == FMT_H264){
421 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
422 pic->motion_val[i]= pic->motion_val_base[i]+4;
423 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
425 pic->motion_subsample_log2= 2;
426 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
428 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
429 pic->motion_val[i]= pic->motion_val_base[i]+4;
430 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
432 pic->motion_subsample_log2= 3;
434 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
435 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
437 pic->qstride= s->mb_stride;
438 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
441 /* It might be nicer if the application would keep track of these
442 * but it would require an API change. */
443 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
444 s->prev_pict_types[0]= s->pict_type;
445 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
446 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
449 fail: //for the CHECKED_ALLOCZ macro
454 * deallocates a picture
456 static void free_picture(MpegEncContext *s, Picture *pic){
459 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
460 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
463 av_freep(&pic->mb_var);
464 av_freep(&pic->mc_mb_var);
465 av_freep(&pic->mb_mean);
466 av_freep(&pic->mbskip_table);
467 av_freep(&pic->qscale_table);
468 av_freep(&pic->mb_type_base);
469 av_freep(&pic->dct_coeff);
470 av_freep(&pic->pan_scan);
473 av_freep(&pic->motion_val_base[i]);
474 av_freep(&pic->ref_index[i]);
477 if(pic->type == FF_BUFFER_TYPE_SHARED){
486 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
489 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
490 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
491 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
493 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
494 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
495 s->rd_scratchpad= s->me.scratchpad;
496 s->b_scratchpad= s->me.scratchpad;
497 s->obmc_scratchpad= s->me.scratchpad + 16;
499 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
500 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
501 if(s->avctx->noise_reduction){
502 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
505 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
506 s->block= s->blocks[0];
509 s->pblocks[i] = (short *)(&s->block[i]);
513 return -1; //free() through MPV_common_end()
516 static void free_duplicate_context(MpegEncContext *s){
519 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
520 av_freep(&s->me.scratchpad);
523 s->obmc_scratchpad= NULL;
525 av_freep(&s->dct_error_sum);
526 av_freep(&s->me.map);
527 av_freep(&s->me.score_map);
528 av_freep(&s->blocks);
532 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
533 #define COPY(a) bak->a= src->a
534 COPY(allocated_edge_emu_buffer);
535 COPY(edge_emu_buffer);
539 COPY(obmc_scratchpad);
546 COPY(me.map_generation);
554 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
557 //FIXME copy only needed parts
559 backup_duplicate_context(&bak, dst);
560 memcpy(dst, src, sizeof(MpegEncContext));
561 backup_duplicate_context(dst, &bak);
563 dst->pblocks[i] = (short *)(&dst->block[i]);
565 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
568 #ifdef CONFIG_ENCODERS
569 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
570 #define COPY(a) dst->a= src->a
572 COPY(current_picture);
578 COPY(picture_in_gop_number);
579 COPY(gop_picture_number);
580 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
581 COPY(progressive_frame); //FIXME don't set in encode_header
582 COPY(partitioned_frame); //FIXME don't set in encode_header
588 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
589 * the changed fields will not depend upon the prior state of the MpegEncContext.
591 static void MPV_common_defaults(MpegEncContext *s){
593 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
594 s->chroma_qscale_table= ff_default_chroma_qscale_table;
595 s->progressive_frame= 1;
596 s->progressive_sequence= 1;
597 s->picture_structure= PICT_FRAME;
599 s->coded_picture_number = 0;
600 s->picture_number = 0;
601 s->input_picture_number = 0;
603 s->picture_in_gop_number = 0;
610 * sets the given MpegEncContext to defaults for decoding.
611 * the changed fields will not depend upon the prior state of the MpegEncContext.
613 void MPV_decode_defaults(MpegEncContext *s){
614 MPV_common_defaults(s);
618 * sets the given MpegEncContext to defaults for encoding.
619 * the changed fields will not depend upon the prior state of the MpegEncContext.
622 #ifdef CONFIG_ENCODERS
623 static void MPV_encode_defaults(MpegEncContext *s){
625 MPV_common_defaults(s);
627 for(i=-16; i<16; i++){
628 default_fcode_tab[i + MAX_MV]= 1;
630 s->me.mv_penalty= default_mv_penalty;
631 s->fcode_tab= default_fcode_tab;
633 #endif //CONFIG_ENCODERS
636 * init common structure for both encoder and decoder.
637 * this assumes that some variables like width/height are already set
639 int MPV_common_init(MpegEncContext *s)
641 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
643 s->mb_height = (s->height + 15) / 16;
645 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
646 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
650 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
653 dsputil_init(&s->dsp, s->avctx);
656 s->flags= s->avctx->flags;
657 s->flags2= s->avctx->flags2;
659 s->mb_width = (s->width + 15) / 16;
660 s->mb_stride = s->mb_width + 1;
661 s->b8_stride = s->mb_width*2 + 1;
662 s->b4_stride = s->mb_width*4 + 1;
663 mb_array_size= s->mb_height * s->mb_stride;
664 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
666 /* set chroma shifts */
667 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
668 &(s->chroma_y_shift) );
670 /* set default edge pos, will be overriden in decode_header if needed */
671 s->h_edge_pos= s->mb_width*16;
672 s->v_edge_pos= s->mb_height*16;
674 s->mb_num = s->mb_width * s->mb_height;
679 s->block_wrap[3]= s->b8_stride;
681 s->block_wrap[5]= s->mb_stride;
683 y_size = s->b8_stride * (2 * s->mb_height + 1);
684 c_size = s->mb_stride * (s->mb_height + 1);
685 yc_size = y_size + 2 * c_size;
687 /* convert fourcc to upper case */
688 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
689 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
690 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
691 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
693 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
694 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
695 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
696 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
698 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
700 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
701 for(y=0; y<s->mb_height; y++){
702 for(x=0; x<s->mb_width; x++){
703 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
706 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
709 /* Allocate MV tables */
710 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
711 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
712 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
713 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
714 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
715 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
716 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
717 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
718 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
719 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
720 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
721 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
723 if(s->msmpeg4_version){
724 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
726 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
728 /* Allocate MB type table */
729 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
731 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
733 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
734 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
735 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
736 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
737 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
738 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
740 if(s->avctx->noise_reduction){
741 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
744 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
746 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
748 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
749 /* interlaced direct mode decoding tables */
754 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
755 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
757 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
758 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
759 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
761 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
764 if (s->out_format == FMT_H263) {
766 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
767 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
768 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
769 s->ac_val[2] = s->ac_val[1] + c_size;
772 CHECKED_ALLOCZ(s->coded_block_base, y_size);
773 s->coded_block= s->coded_block_base + s->b8_stride + 1;
775 /* cbp, ac_pred, pred_dir */
776 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
777 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
780 if (s->h263_pred || s->h263_plus || !s->encoding) {
782 //MN: we need these for error resilience of intra-frames
783 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
784 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
785 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
786 s->dc_val[2] = s->dc_val[1] + c_size;
787 for(i=0;i<yc_size;i++)
788 s->dc_val_base[i] = 1024;
791 /* which mb is a intra block */
792 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
793 memset(s->mbintra_table, 1, mb_array_size);
795 /* init macroblock skip table */
796 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
797 //Note the +1 is for a quicker mpeg4 slice_end detection
798 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
800 s->parse_context.state= -1;
801 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
802 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
803 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
804 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
807 s->context_initialized = 1;
809 s->thread_context[0]= s;
810 for(i=1; i<s->avctx->thread_count; i++){
811 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
812 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
815 for(i=0; i<s->avctx->thread_count; i++){
816 if(init_duplicate_context(s->thread_context[i], s) < 0)
818 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
819 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
828 /* init common structure for both encoder and decoder */
829 void MPV_common_end(MpegEncContext *s)
833 for(i=0; i<s->avctx->thread_count; i++){
834 free_duplicate_context(s->thread_context[i]);
836 for(i=1; i<s->avctx->thread_count; i++){
837 av_freep(&s->thread_context[i]);
840 av_freep(&s->parse_context.buffer);
841 s->parse_context.buffer_size=0;
843 av_freep(&s->mb_type);
844 av_freep(&s->p_mv_table_base);
845 av_freep(&s->b_forw_mv_table_base);
846 av_freep(&s->b_back_mv_table_base);
847 av_freep(&s->b_bidir_forw_mv_table_base);
848 av_freep(&s->b_bidir_back_mv_table_base);
849 av_freep(&s->b_direct_mv_table_base);
851 s->b_forw_mv_table= NULL;
852 s->b_back_mv_table= NULL;
853 s->b_bidir_forw_mv_table= NULL;
854 s->b_bidir_back_mv_table= NULL;
855 s->b_direct_mv_table= NULL;
859 av_freep(&s->b_field_mv_table_base[i][j][k]);
860 s->b_field_mv_table[i][j][k]=NULL;
862 av_freep(&s->b_field_select_table[i][j]);
863 av_freep(&s->p_field_mv_table_base[i][j]);
864 s->p_field_mv_table[i][j]=NULL;
866 av_freep(&s->p_field_select_table[i]);
869 av_freep(&s->dc_val_base);
870 av_freep(&s->ac_val_base);
871 av_freep(&s->coded_block_base);
872 av_freep(&s->mbintra_table);
873 av_freep(&s->cbp_table);
874 av_freep(&s->pred_dir_table);
876 av_freep(&s->mbskip_table);
877 av_freep(&s->prev_pict_types);
878 av_freep(&s->bitstream_buffer);
879 s->allocated_bitstream_buffer_size=0;
881 av_freep(&s->avctx->stats_out);
882 av_freep(&s->ac_stats);
883 av_freep(&s->error_status_table);
884 av_freep(&s->mb_index2xy);
885 av_freep(&s->lambda_table);
886 av_freep(&s->q_intra_matrix);
887 av_freep(&s->q_inter_matrix);
888 av_freep(&s->q_intra_matrix16);
889 av_freep(&s->q_inter_matrix16);
890 av_freep(&s->input_picture);
891 av_freep(&s->reordered_input_picture);
892 av_freep(&s->dct_offset);
895 for(i=0; i<MAX_PICTURE_COUNT; i++){
896 free_picture(s, &s->picture[i]);
899 av_freep(&s->picture);
900 s->context_initialized = 0;
903 s->current_picture_ptr= NULL;
904 s->linesize= s->uvlinesize= 0;
907 av_freep(&s->visualization_buffer[i]);
909 avcodec_default_free_buffers(s->avctx);
912 #ifdef CONFIG_ENCODERS
914 /* init video encoder */
915 int MPV_encode_init(AVCodecContext *avctx)
917 MpegEncContext *s = avctx->priv_data;
919 int chroma_h_shift, chroma_v_shift;
921 MPV_encode_defaults(s);
923 switch (avctx->codec_id) {
924 case CODEC_ID_MPEG2VIDEO:
925 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
926 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
932 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
933 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
934 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
939 if(avctx->pix_fmt != PIX_FMT_YUV420P){
940 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
945 switch (avctx->pix_fmt) {
946 case PIX_FMT_YUVJ422P:
947 case PIX_FMT_YUV422P:
948 s->chroma_format = CHROMA_422;
950 case PIX_FMT_YUVJ420P:
951 case PIX_FMT_YUV420P:
953 s->chroma_format = CHROMA_420;
957 s->bit_rate = avctx->bit_rate;
958 s->width = avctx->width;
959 s->height = avctx->height;
960 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
961 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
964 s->gop_size = avctx->gop_size;
966 s->flags= avctx->flags;
967 s->flags2= avctx->flags2;
968 s->max_b_frames= avctx->max_b_frames;
969 s->codec_id= avctx->codec->id;
970 s->luma_elim_threshold = avctx->luma_elim_threshold;
971 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
972 s->strict_std_compliance= avctx->strict_std_compliance;
973 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
974 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
975 s->mpeg_quant= avctx->mpeg_quant;
976 s->rtp_mode= !!avctx->rtp_payload_size;
977 s->intra_dc_precision= avctx->intra_dc_precision;
978 s->user_specified_pts = AV_NOPTS_VALUE;
980 if (s->gop_size <= 1) {
987 s->me_method = avctx->me_method;
990 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
992 s->adaptive_quant= ( s->avctx->lumi_masking
993 || s->avctx->dark_masking
994 || s->avctx->temporal_cplx_masking
995 || s->avctx->spatial_cplx_masking
996 || s->avctx->p_masking
997 || s->avctx->border_masking
998 || (s->flags&CODEC_FLAG_QP_RD))
1001 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1002 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1003 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1004 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1005 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
1007 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1008 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1012 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1013 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1016 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1017 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
1021 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1022 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1026 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){
1027 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
1031 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){
1032 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n");
1036 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1037 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1038 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1040 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");
1043 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1044 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1045 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1049 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1050 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1054 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1055 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1059 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1060 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1064 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1065 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1069 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1070 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1074 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1075 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1076 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1080 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1081 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1085 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1086 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1090 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1091 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1095 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1096 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
1100 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1101 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1105 if(s->flags & CODEC_FLAG_LOW_DELAY){
1106 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1107 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1110 if (s->max_b_frames != 0){
1111 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1116 if(s->q_scale_type == 1){
1117 if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1118 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1121 if(avctx->qmax > 12){
1122 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1127 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1128 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1129 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1130 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1134 if(s->avctx->thread_count > 1)
1137 if(!avctx->time_base.den || !avctx->time_base.num){
1138 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1142 i= (INT_MAX/2+128)>>8;
1143 if(avctx->me_threshold >= i){
1144 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1147 if(avctx->mb_threshold >= i){
1148 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1152 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1153 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1154 avctx->b_frame_strategy = 0;
1157 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1159 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1160 avctx->time_base.den /= i;
1161 avctx->time_base.num /= i;
1165 if(s->codec_id==CODEC_ID_MJPEG){
1166 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1167 s->inter_quant_bias= 0;
1168 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1169 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1170 s->inter_quant_bias= 0;
1172 s->intra_quant_bias=0;
1173 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1176 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1177 s->intra_quant_bias= avctx->intra_quant_bias;
1178 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1179 s->inter_quant_bias= avctx->inter_quant_bias;
1181 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1183 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1184 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1187 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1189 switch(avctx->codec->id) {
1190 case CODEC_ID_MPEG1VIDEO:
1191 s->out_format = FMT_MPEG1;
1192 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1193 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1195 case CODEC_ID_MPEG2VIDEO:
1196 s->out_format = FMT_MPEG1;
1197 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1198 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1201 case CODEC_ID_LJPEG:
1202 case CODEC_ID_MJPEG:
1203 s->out_format = FMT_MJPEG;
1204 s->intra_only = 1; /* force intra only for jpeg */
1205 s->mjpeg_vsample[0] = 2;
1206 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1207 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1208 s->mjpeg_hsample[0] = 2;
1209 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1210 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1211 if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER)
1212 || ff_mjpeg_encode_init(s) < 0)
1218 if (!ENABLE_H261_ENCODER) return -1;
1219 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1220 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
1223 s->out_format = FMT_H261;
1228 if (h263_get_picture_format(s->width, s->height) == 7) {
1229 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
1232 s->out_format = FMT_H263;
1233 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1237 case CODEC_ID_H263P:
1238 s->out_format = FMT_H263;
1241 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1242 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1243 s->modified_quant= s->h263_aic;
1244 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1245 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1246 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1247 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1248 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1251 /* These are just to be sure */
1256 s->out_format = FMT_H263;
1257 s->h263_flv = 2; /* format = 1; 11-bit codes */
1258 s->unrestricted_mv = 1;
1259 s->rtp_mode=0; /* don't allow GOB */
1264 s->out_format = FMT_H263;
1269 s->out_format = FMT_H263;
1272 s->modified_quant=1;
1276 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1278 case CODEC_ID_MPEG4:
1279 s->out_format = FMT_H263;
1281 s->unrestricted_mv = 1;
1282 s->low_delay= s->max_b_frames ? 0 : 1;
1283 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1285 case CODEC_ID_MSMPEG4V1:
1286 s->out_format = FMT_H263;
1287 s->h263_msmpeg4 = 1;
1289 s->unrestricted_mv = 1;
1290 s->msmpeg4_version= 1;
1294 case CODEC_ID_MSMPEG4V2:
1295 s->out_format = FMT_H263;
1296 s->h263_msmpeg4 = 1;
1298 s->unrestricted_mv = 1;
1299 s->msmpeg4_version= 2;
1303 case CODEC_ID_MSMPEG4V3:
1304 s->out_format = FMT_H263;
1305 s->h263_msmpeg4 = 1;
1307 s->unrestricted_mv = 1;
1308 s->msmpeg4_version= 3;
1309 s->flipflop_rounding=1;
1314 s->out_format = FMT_H263;
1315 s->h263_msmpeg4 = 1;
1317 s->unrestricted_mv = 1;
1318 s->msmpeg4_version= 4;
1319 s->flipflop_rounding=1;
1324 s->out_format = FMT_H263;
1325 s->h263_msmpeg4 = 1;
1327 s->unrestricted_mv = 1;
1328 s->msmpeg4_version= 5;
1329 s->flipflop_rounding=1;
1337 avctx->has_b_frames= !s->low_delay;
1342 if (MPV_common_init(s) < 0)
1345 if(s->modified_quant)
1346 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1347 s->progressive_frame=
1348 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1349 s->quant_precision=5;
1351 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1352 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1354 if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
1355 ff_h261_encode_init(s);
1356 if (s->out_format == FMT_H263)
1357 h263_encode_init(s);
1358 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
1359 ff_msmpeg4_encode_init(s);
1360 if (s->out_format == FMT_MPEG1)
1361 ff_mpeg1_encode_init(s);
1365 int j= s->dsp.idct_permutation[i];
1366 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1367 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1368 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1369 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1370 s->intra_matrix[j] =
1371 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1374 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1375 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1377 if(s->avctx->intra_matrix)
1378 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1379 if(s->avctx->inter_matrix)
1380 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1383 /* precompute matrix */
1384 /* for mjpeg, we do include qscale in the matrix */
1385 if (s->out_format != FMT_MJPEG) {
1386 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1387 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1388 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1389 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1392 if(ff_rate_control_init(s) < 0)
1398 int MPV_encode_end(AVCodecContext *avctx)
1400 MpegEncContext *s = avctx->priv_data;
1402 ff_rate_control_uninit(s);
1405 if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG)
1406 ff_mjpeg_encode_close(s);
1408 av_freep(&avctx->extradata);
1413 #endif //CONFIG_ENCODERS
1415 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
1417 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1418 uint8_t index_run[MAX_RUN+1];
1419 int last, run, level, start, end, i;
1421 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1422 if(static_store && rl->max_level[0])
1425 /* compute max_level[], max_run[] and index_run[] */
1426 for(last=0;last<2;last++) {
1435 memset(max_level, 0, MAX_RUN + 1);
1436 memset(max_run, 0, MAX_LEVEL + 1);
1437 memset(index_run, rl->n, MAX_RUN + 1);
1438 for(i=start;i<end;i++) {
1439 run = rl->table_run[i];
1440 level = rl->table_level[i];
1441 if (index_run[run] == rl->n)
1443 if (level > max_level[run])
1444 max_level[run] = level;
1445 if (run > max_run[level])
1446 max_run[level] = run;
1449 rl->max_level[last] = static_store[last];
1451 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1452 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1454 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1456 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1457 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1459 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1461 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1462 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1466 /* draw the edges of width 'w' of an image of size width, height */
1467 //FIXME check that this is ok for mpeg4 interlaced
1468 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1470 uint8_t *ptr, *last_line;
1473 last_line = buf + (height - 1) * wrap;
1475 /* top and bottom */
1476 memcpy(buf - (i + 1) * wrap, buf, width);
1477 memcpy(last_line + (i + 1) * wrap, last_line, width);
1479 /* left and right */
1481 for(i=0;i<height;i++) {
1482 memset(ptr - w, ptr[0], w);
1483 memset(ptr + width, ptr[width-1], w);
1488 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1489 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1490 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1491 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1495 int ff_find_unused_picture(MpegEncContext *s, int shared){
1499 for(i=0; i<MAX_PICTURE_COUNT; i++){
1500 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1503 for(i=0; i<MAX_PICTURE_COUNT; i++){
1504 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1506 for(i=0; i<MAX_PICTURE_COUNT; i++){
1507 if(s->picture[i].data[0]==NULL) return i;
1515 static void update_noise_reduction(MpegEncContext *s){
1518 for(intra=0; intra<2; intra++){
1519 if(s->dct_count[intra] > (1<<16)){
1520 for(i=0; i<64; i++){
1521 s->dct_error_sum[intra][i] >>=1;
1523 s->dct_count[intra] >>= 1;
1526 for(i=0; i<64; i++){
1527 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);
1533 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1535 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1541 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1543 /* mark&release old frames */
1544 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1545 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1546 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1548 /* release forgotten pictures */
1549 /* if(mpeg124/h263) */
1551 for(i=0; i<MAX_PICTURE_COUNT; i++){
1552 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1553 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1554 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1562 /* release non reference frames */
1563 for(i=0; i<MAX_PICTURE_COUNT; i++){
1564 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1565 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1569 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1570 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1572 i= ff_find_unused_picture(s, 0);
1573 pic= (AVFrame*)&s->picture[i];
1576 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1577 && !s->dropable ? 3 : 0;
1579 pic->coded_picture_number= s->coded_picture_number++;
1581 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1584 s->current_picture_ptr= (Picture*)pic;
1585 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1586 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1589 s->current_picture_ptr->pict_type= s->pict_type;
1590 // if(s->flags && CODEC_FLAG_QSCALE)
1591 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1592 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1594 copy_picture(&s->current_picture, s->current_picture_ptr);
1596 if (s->pict_type != B_TYPE) {
1597 s->last_picture_ptr= s->next_picture_ptr;
1599 s->next_picture_ptr= s->current_picture_ptr;
1601 /* 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,
1602 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1603 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1604 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1605 s->pict_type, s->dropable);*/
1607 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1608 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1610 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
1611 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1612 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1616 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1618 if(s->picture_structure!=PICT_FRAME){
1621 if(s->picture_structure == PICT_BOTTOM_FIELD){
1622 s->current_picture.data[i] += s->current_picture.linesize[i];
1624 s->current_picture.linesize[i] *= 2;
1625 s->last_picture.linesize[i] *=2;
1626 s->next_picture.linesize[i] *=2;
1630 s->hurry_up= s->avctx->hurry_up;
1631 s->error_resilience= avctx->error_resilience;
1633 /* set dequantizer, we can't do it during init as it might change for mpeg4
1634 and we can't do it in the header decode as init is not called for mpeg4 there yet */
1635 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1636 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1637 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1638 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1639 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1640 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1642 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1643 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1646 if(s->dct_error_sum){
1647 assert(s->avctx->noise_reduction && s->encoding);
1649 update_noise_reduction(s);
1653 if(s->avctx->xvmc_acceleration)
1654 return XVMC_field_start(s, avctx);
1659 /* generic function for encode/decode called after a frame has been coded/decoded */
1660 void MPV_frame_end(MpegEncContext *s)
1663 /* draw edge for correct motion prediction if outside */
1665 //just to make sure that all data is rendered.
1666 if(s->avctx->xvmc_acceleration){
1670 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1671 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1672 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1673 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1677 s->last_pict_type = s->pict_type;
1678 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1679 if(s->pict_type!=B_TYPE){
1680 s->last_non_b_pict_type= s->pict_type;
1683 /* copy back current_picture variables */
1684 for(i=0; i<MAX_PICTURE_COUNT; i++){
1685 if(s->picture[i].data[0] == s->current_picture.data[0]){
1686 s->picture[i]= s->current_picture;
1690 assert(i<MAX_PICTURE_COUNT);
1694 /* release non-reference frames */
1695 for(i=0; i<MAX_PICTURE_COUNT; i++){
1696 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1697 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1701 // clear copies, to avoid confusion
1703 memset(&s->last_picture, 0, sizeof(Picture));
1704 memset(&s->next_picture, 0, sizeof(Picture));
1705 memset(&s->current_picture, 0, sizeof(Picture));
1707 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1711 * draws an line from (ex, ey) -> (sx, sy).
1712 * @param w width of the image
1713 * @param h height of the image
1714 * @param stride stride/linesize of the image
1715 * @param color color of the arrow
1717 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1720 sx= av_clip(sx, 0, w-1);
1721 sy= av_clip(sy, 0, h-1);
1722 ex= av_clip(ex, 0, w-1);
1723 ey= av_clip(ey, 0, h-1);
1725 buf[sy*stride + sx]+= color;
1727 if(FFABS(ex - sx) > FFABS(ey - sy)){
1729 FFSWAP(int, sx, ex);
1730 FFSWAP(int, sy, ey);
1732 buf+= sx + sy*stride;
1734 f= ((ey-sy)<<16)/ex;
1735 for(x= 0; x <= ex; x++){
1738 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1739 buf[(y+1)*stride + x]+= (color* fr )>>16;
1743 FFSWAP(int, sx, ex);
1744 FFSWAP(int, sy, ey);
1746 buf+= sx + sy*stride;
1748 if(ey) f= ((ex-sx)<<16)/ey;
1750 for(y= 0; y <= ey; y++){
1753 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1754 buf[y*stride + x+1]+= (color* fr )>>16;;
1760 * draws an arrow from (ex, ey) -> (sx, sy).
1761 * @param w width of the image
1762 * @param h height of the image
1763 * @param stride stride/linesize of the image
1764 * @param color color of the arrow
1766 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1769 sx= av_clip(sx, -100, w+100);
1770 sy= av_clip(sy, -100, h+100);
1771 ex= av_clip(ex, -100, w+100);
1772 ey= av_clip(ey, -100, h+100);
1777 if(dx*dx + dy*dy > 3*3){
1780 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1782 //FIXME subpixel accuracy
1783 rx= ROUNDED_DIV(rx*3<<4, length);
1784 ry= ROUNDED_DIV(ry*3<<4, length);
1786 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1787 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1789 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1793 * prints debuging info for the given picture.
1795 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1797 if(!pict || !pict->mb_type) return;
1799 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1802 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1803 switch (pict->pict_type) {
1804 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1805 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1806 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1807 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1808 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1809 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1811 for(y=0; y<s->mb_height; y++){
1812 for(x=0; x<s->mb_width; x++){
1813 if(s->avctx->debug&FF_DEBUG_SKIP){
1814 int count= s->mbskip_table[x + y*s->mb_stride];
1815 if(count>9) count=9;
1816 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1818 if(s->avctx->debug&FF_DEBUG_QP){
1819 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1821 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1822 int mb_type= pict->mb_type[x + y*s->mb_stride];
1823 //Type & MV direction
1825 av_log(s->avctx, AV_LOG_DEBUG, "P");
1826 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1827 av_log(s->avctx, AV_LOG_DEBUG, "A");
1828 else if(IS_INTRA4x4(mb_type))
1829 av_log(s->avctx, AV_LOG_DEBUG, "i");
1830 else if(IS_INTRA16x16(mb_type))
1831 av_log(s->avctx, AV_LOG_DEBUG, "I");
1832 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1833 av_log(s->avctx, AV_LOG_DEBUG, "d");
1834 else if(IS_DIRECT(mb_type))
1835 av_log(s->avctx, AV_LOG_DEBUG, "D");
1836 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1837 av_log(s->avctx, AV_LOG_DEBUG, "g");
1838 else if(IS_GMC(mb_type))
1839 av_log(s->avctx, AV_LOG_DEBUG, "G");
1840 else if(IS_SKIP(mb_type))
1841 av_log(s->avctx, AV_LOG_DEBUG, "S");
1842 else if(!USES_LIST(mb_type, 1))
1843 av_log(s->avctx, AV_LOG_DEBUG, ">");
1844 else if(!USES_LIST(mb_type, 0))
1845 av_log(s->avctx, AV_LOG_DEBUG, "<");
1847 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1848 av_log(s->avctx, AV_LOG_DEBUG, "X");
1853 av_log(s->avctx, AV_LOG_DEBUG, "+");
1854 else if(IS_16X8(mb_type))
1855 av_log(s->avctx, AV_LOG_DEBUG, "-");
1856 else if(IS_8X16(mb_type))
1857 av_log(s->avctx, AV_LOG_DEBUG, "|");
1858 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1859 av_log(s->avctx, AV_LOG_DEBUG, " ");
1861 av_log(s->avctx, AV_LOG_DEBUG, "?");
1864 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1865 av_log(s->avctx, AV_LOG_DEBUG, "=");
1867 av_log(s->avctx, AV_LOG_DEBUG, " ");
1869 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1871 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1875 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1876 const int shift= 1 + s->quarter_sample;
1880 int h_chroma_shift, v_chroma_shift;
1881 const int width = s->avctx->width;
1882 const int height= s->avctx->height;
1883 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1884 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1885 s->low_delay=0; //needed to see the vectors without trashing the buffers
1887 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1889 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1890 pict->data[i]= s->visualization_buffer[i];
1892 pict->type= FF_BUFFER_TYPE_COPY;
1895 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1897 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1898 const int mb_index= mb_x + mb_y*s->mb_stride;
1899 if((s->avctx->debug_mv) && pict->motion_val){
1901 for(type=0; type<3; type++){
1904 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1908 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1912 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1917 if(!USES_LIST(pict->mb_type[mb_index], direction))
1920 if(IS_8X8(pict->mb_type[mb_index])){
1923 int sx= mb_x*16 + 4 + 8*(i&1);
1924 int sy= mb_y*16 + 4 + 8*(i>>1);
1925 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1926 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1927 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1928 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1930 }else if(IS_16X8(pict->mb_type[mb_index])){
1934 int sy=mb_y*16 + 4 + 8*i;
1935 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1936 int mx=(pict->motion_val[direction][xy][0]>>shift);
1937 int my=(pict->motion_val[direction][xy][1]>>shift);
1939 if(IS_INTERLACED(pict->mb_type[mb_index]))
1942 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1944 }else if(IS_8X16(pict->mb_type[mb_index])){
1947 int sx=mb_x*16 + 4 + 8*i;
1949 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1950 int mx=(pict->motion_val[direction][xy][0]>>shift);
1951 int my=(pict->motion_val[direction][xy][1]>>shift);
1953 if(IS_INTERLACED(pict->mb_type[mb_index]))
1956 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1959 int sx= mb_x*16 + 8;
1960 int sy= mb_y*16 + 8;
1961 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1962 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1963 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1964 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1968 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1969 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1972 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1973 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1976 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1977 int mb_type= pict->mb_type[mb_index];
1980 #define COLOR(theta, r)\
1981 u= (int)(128 + r*cos(theta*3.141592/180));\
1982 v= (int)(128 + r*sin(theta*3.141592/180));
1986 if(IS_PCM(mb_type)){
1988 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1990 }else if(IS_INTRA4x4(mb_type)){
1992 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1994 }else if(IS_DIRECT(mb_type)){
1996 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1998 }else if(IS_GMC(mb_type)){
2000 }else if(IS_SKIP(mb_type)){
2002 }else if(!USES_LIST(mb_type, 1)){
2004 }else if(!USES_LIST(mb_type, 0)){
2007 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2011 u*= 0x0101010101010101ULL;
2012 v*= 0x0101010101010101ULL;
2014 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2015 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2019 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
2020 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2021 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2023 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2025 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2027 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2028 int dm= 1 << (mv_sample_log2-2);
2030 int sx= mb_x*16 + 8*(i&1);
2031 int sy= mb_y*16 + 8*(i>>1);
2032 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2034 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2035 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2037 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2038 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2039 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2043 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2047 s->mbskip_table[mb_index]=0;
2053 #ifdef CONFIG_ENCODERS
2055 static int get_sae(uint8_t *src, int ref, int stride){
2059 for(y=0; y<16; y++){
2060 for(x=0; x<16; x++){
2061 acc+= FFABS(src[x+y*stride] - ref);
2068 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2075 for(y=0; y<h; y+=16){
2076 for(x=0; x<w; x+=16){
2077 int offset= x + y*stride;
2078 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2079 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2080 int sae = get_sae(src + offset, mean, stride);
2082 acc+= sae + 500 < sad;
2089 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2093 const int encoding_delay= s->max_b_frames;
2098 pic_arg->display_picture_number= s->input_picture_number++;
2100 if(pts != AV_NOPTS_VALUE){
2101 if(s->user_specified_pts != AV_NOPTS_VALUE){
2103 int64_t last= s->user_specified_pts;
2106 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2110 s->user_specified_pts= pts;
2112 if(s->user_specified_pts != AV_NOPTS_VALUE){
2113 s->user_specified_pts=
2114 pts= s->user_specified_pts + 1;
2115 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2117 pts= pic_arg->display_picture_number;
2123 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2124 if(pic_arg->linesize[0] != s->linesize) direct=0;
2125 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2126 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2128 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2131 i= ff_find_unused_picture(s, 1);
2133 pic= (AVFrame*)&s->picture[i];
2137 pic->data[i]= pic_arg->data[i];
2138 pic->linesize[i]= pic_arg->linesize[i];
2140 alloc_picture(s, (Picture*)pic, 1);
2142 i= ff_find_unused_picture(s, 0);
2144 pic= (AVFrame*)&s->picture[i];
2147 alloc_picture(s, (Picture*)pic, 0);
2149 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2150 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2151 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2154 int h_chroma_shift, v_chroma_shift;
2155 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2158 int src_stride= pic_arg->linesize[i];
2159 int dst_stride= i ? s->uvlinesize : s->linesize;
2160 int h_shift= i ? h_chroma_shift : 0;
2161 int v_shift= i ? v_chroma_shift : 0;
2162 int w= s->width >>h_shift;
2163 int h= s->height>>v_shift;
2164 uint8_t *src= pic_arg->data[i];
2165 uint8_t *dst= pic->data[i];
2167 if(!s->avctx->rc_buffer_size)
2168 dst +=INPLACE_OFFSET;
2170 if(src_stride==dst_stride)
2171 memcpy(dst, src, src_stride*h);
2174 memcpy(dst, src, w);
2182 copy_picture_attributes(s, pic, pic_arg);
2183 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2186 /* shift buffer entries */
2187 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2188 s->input_picture[i-1]= s->input_picture[i];
2190 s->input_picture[encoding_delay]= (Picture*)pic;
2195 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2200 for(plane=0; plane<3; plane++){
2201 const int stride= p->linesize[plane];
2202 const int bw= plane ? 1 : 2;
2203 for(y=0; y<s->mb_height*bw; y++){
2204 for(x=0; x<s->mb_width*bw; x++){
2205 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2206 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2208 switch(s->avctx->frame_skip_exp){
2209 case 0: score= FFMAX(score, v); break;
2210 case 1: score+= FFABS(v);break;
2211 case 2: score+= v*v;break;
2212 case 3: score64+= FFABS(v*v*(int64_t)v);break;
2213 case 4: score64+= v*v*(int64_t)(v*v);break;
2219 if(score) score64= score;
2221 if(score64 < s->avctx->frame_skip_threshold)
2223 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2228 static int estimate_best_b_count(MpegEncContext *s){
2229 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2230 AVCodecContext *c= avcodec_alloc_context();
2231 AVFrame input[FF_MAX_B_FRAMES+2];
2232 const int scale= s->avctx->brd_scale;
2233 int i, j, out_size, p_lambda, b_lambda, lambda2;
2234 int outbuf_size= s->width * s->height; //FIXME
2235 uint8_t *outbuf= av_malloc(outbuf_size);
2236 int64_t best_rd= INT64_MAX;
2237 int best_b_count= -1;
2239 assert(scale>=0 && scale <=3);
2242 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2243 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2244 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2245 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2247 c->width = s->width >> scale;
2248 c->height= s->height>> scale;
2249 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2250 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2251 c->mb_decision= s->avctx->mb_decision;
2252 c->me_cmp= s->avctx->me_cmp;
2253 c->mb_cmp= s->avctx->mb_cmp;
2254 c->me_sub_cmp= s->avctx->me_sub_cmp;
2255 c->pix_fmt = PIX_FMT_YUV420P;
2256 c->time_base= s->avctx->time_base;
2257 c->max_b_frames= s->max_b_frames;
2259 if (avcodec_open(c, codec) < 0)
2262 for(i=0; i<s->max_b_frames+2; i++){
2263 int ysize= c->width*c->height;
2264 int csize= (c->width/2)*(c->height/2);
2265 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2267 avcodec_get_frame_defaults(&input[i]);
2268 input[i].data[0]= av_malloc(ysize + 2*csize);
2269 input[i].data[1]= input[i].data[0] + ysize;
2270 input[i].data[2]= input[i].data[1] + csize;
2271 input[i].linesize[0]= c->width;
2272 input[i].linesize[1]=
2273 input[i].linesize[2]= c->width/2;
2275 if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2276 pre_input= *pre_input_ptr;
2278 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2279 pre_input.data[0]+=INPLACE_OFFSET;
2280 pre_input.data[1]+=INPLACE_OFFSET;
2281 pre_input.data[2]+=INPLACE_OFFSET;
2284 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2285 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2286 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2290 for(j=0; j<s->max_b_frames+1; j++){
2293 if(!s->input_picture[j])
2296 c->error[0]= c->error[1]= c->error[2]= 0;
2298 input[0].pict_type= I_TYPE;
2299 input[0].quality= 1 * FF_QP2LAMBDA;
2300 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2301 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2303 for(i=0; i<s->max_b_frames+1; i++){
2304 int is_p= i % (j+1) == j || i==s->max_b_frames;
2306 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2307 input[i+1].quality= is_p ? p_lambda : b_lambda;
2308 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2309 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2312 /* get the delayed frames */
2314 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2315 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2318 rd += c->error[0] + c->error[1] + c->error[2];
2330 for(i=0; i<s->max_b_frames+2; i++){
2331 av_freep(&input[i].data[0]);
2334 return best_b_count;
2337 static void select_input_picture(MpegEncContext *s){
2340 for(i=1; i<MAX_PICTURE_COUNT; i++)
2341 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2342 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2344 /* set next picture type & ordering */
2345 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2346 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2347 s->reordered_input_picture[0]= s->input_picture[0];
2348 s->reordered_input_picture[0]->pict_type= I_TYPE;
2349 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2353 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2354 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2355 //FIXME check that te gop check above is +-1 correct
2356 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2358 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2360 s->input_picture[0]->data[i]= NULL;
2361 s->input_picture[0]->type= 0;
2363 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2364 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2366 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2370 ff_vbv_update(s, 0);
2376 if(s->flags&CODEC_FLAG_PASS2){
2377 for(i=0; i<s->max_b_frames+1; i++){
2378 int pict_num= s->input_picture[0]->display_picture_number + i;
2380 if(pict_num >= s->rc_context.num_entries)
2382 if(!s->input_picture[i]){
2383 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2387 s->input_picture[i]->pict_type=
2388 s->rc_context.entry[pict_num].new_pict_type;
2392 if(s->avctx->b_frame_strategy==0){
2393 b_frames= s->max_b_frames;
2394 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2395 }else if(s->avctx->b_frame_strategy==1){
2396 for(i=1; i<s->max_b_frames+1; i++){
2397 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2398 s->input_picture[i]->b_frame_score=
2399 get_intra_count(s, s->input_picture[i ]->data[0],
2400 s->input_picture[i-1]->data[0], s->linesize) + 1;
2403 for(i=0; i<s->max_b_frames+1; i++){
2404 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2407 b_frames= FFMAX(0, i-1);
2410 for(i=0; i<b_frames+1; i++){
2411 s->input_picture[i]->b_frame_score=0;
2413 }else if(s->avctx->b_frame_strategy==2){
2414 b_frames= estimate_best_b_count(s);
2416 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2421 //static int b_count=0;
2422 //b_count+= b_frames;
2423 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2425 for(i= b_frames - 1; i>=0; i--){
2426 int type= s->input_picture[i]->pict_type;
2427 if(type && type != B_TYPE)
2430 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2431 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2434 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2435 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2436 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2438 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2440 s->input_picture[b_frames]->pict_type= I_TYPE;
2444 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2446 && s->input_picture[b_frames]->pict_type== I_TYPE)
2449 s->reordered_input_picture[0]= s->input_picture[b_frames];
2450 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2451 s->reordered_input_picture[0]->pict_type= P_TYPE;
2452 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2453 for(i=0; i<b_frames; i++){
2454 s->reordered_input_picture[i+1]= s->input_picture[i];
2455 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2456 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2461 if(s->reordered_input_picture[0]){
2462 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2464 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2466 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
2467 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2469 int i= ff_find_unused_picture(s, 0);
2470 Picture *pic= &s->picture[i];
2472 pic->reference = s->reordered_input_picture[0]->reference;
2473 alloc_picture(s, pic, 0);
2475 /* mark us unused / free shared pic */
2476 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2477 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2479 s->reordered_input_picture[0]->data[i]= NULL;
2480 s->reordered_input_picture[0]->type= 0;
2482 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2484 s->current_picture_ptr= pic;
2486 // input is not a shared pix -> reuse buffer for current_pix
2488 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2489 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2491 s->current_picture_ptr= s->reordered_input_picture[0];
2493 s->new_picture.data[i]+= INPLACE_OFFSET;
2496 copy_picture(&s->current_picture, s->current_picture_ptr);
2498 s->picture_number= s->new_picture.display_picture_number;
2499 //printf("dpn:%d\n", s->picture_number);
2501 memset(&s->new_picture, 0, sizeof(Picture));
2505 int MPV_encode_picture(AVCodecContext *avctx,
2506 unsigned char *buf, int buf_size, void *data)
2508 MpegEncContext *s = avctx->priv_data;
2509 AVFrame *pic_arg = data;
2510 int i, stuffing_count;
2512 for(i=0; i<avctx->thread_count; i++){
2513 int start_y= s->thread_context[i]->start_mb_y;
2514 int end_y= s->thread_context[i]-> end_mb_y;
2515 int h= s->mb_height;
2516 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2517 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2519 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2522 s->picture_in_gop_number++;
2524 if(load_input_picture(s, pic_arg) < 0)
2527 select_input_picture(s);
2530 if(s->new_picture.data[0]){
2531 s->pict_type= s->new_picture.pict_type;
2533 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2534 MPV_frame_start(s, avctx);
2536 if (encode_picture(s, s->picture_number) < 0)
2539 avctx->real_pict_num = s->picture_number;
2540 avctx->header_bits = s->header_bits;
2541 avctx->mv_bits = s->mv_bits;
2542 avctx->misc_bits = s->misc_bits;
2543 avctx->i_tex_bits = s->i_tex_bits;
2544 avctx->p_tex_bits = s->p_tex_bits;
2545 avctx->i_count = s->i_count;
2546 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2547 avctx->skip_count = s->skip_count;
2551 if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
2552 ff_mjpeg_encode_picture_trailer(s);
2554 if(avctx->rc_buffer_size){
2555 RateControlContext *rcc= &s->rc_context;
2556 int max_size= rcc->buffer_index/3;
2558 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2559 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2560 if(s->adaptive_quant){
2562 for(i=0; i<s->mb_height*s->mb_stride; i++)
2563 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
2565 s->mb_skipped = 0; //done in MPV_frame_start()
2566 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2567 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2568 s->no_rounding ^= 1;
2570 if(s->pict_type!=B_TYPE){
2571 s->time_base= s->last_time_base;
2572 s->last_non_b_time= s->time - s->pp_time;
2574 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2575 for(i=0; i<avctx->thread_count; i++){
2576 PutBitContext *pb= &s->thread_context[i]->pb;
2577 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2582 assert(s->avctx->rc_max_rate);
2585 if(s->flags&CODEC_FLAG_PASS1)
2586 ff_write_pass1_stats(s);
2589 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2590 avctx->error[i] += s->current_picture_ptr->error[i];
2593 if(s->flags&CODEC_FLAG_PASS1)
2594 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2595 flush_put_bits(&s->pb);
2596 s->frame_bits = put_bits_count(&s->pb);
2598 stuffing_count= ff_vbv_update(s, s->frame_bits);
2600 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2601 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2605 switch(s->codec_id){
2606 case CODEC_ID_MPEG1VIDEO:
2607 case CODEC_ID_MPEG2VIDEO:
2608 while(stuffing_count--){
2609 put_bits(&s->pb, 8, 0);
2612 case CODEC_ID_MPEG4:
2613 put_bits(&s->pb, 16, 0);
2614 put_bits(&s->pb, 16, 0x1C3);
2615 stuffing_count -= 4;
2616 while(stuffing_count--){
2617 put_bits(&s->pb, 8, 0xFF);
2621 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2623 flush_put_bits(&s->pb);
2624 s->frame_bits = put_bits_count(&s->pb);
2627 /* update mpeg1/2 vbv_delay for CBR */
2628 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2629 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2632 assert(s->repeat_first_field==0);
2634 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2635 assert(vbv_delay < 0xFFFF);
2637 s->vbv_delay_ptr[0] &= 0xF8;
2638 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2639 s->vbv_delay_ptr[1] = vbv_delay>>5;
2640 s->vbv_delay_ptr[2] &= 0x07;
2641 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2643 s->total_bits += s->frame_bits;
2644 avctx->frame_bits = s->frame_bits;
2646 assert((pbBufPtr(&s->pb) == s->pb.buf));
2649 assert((s->frame_bits&7)==0);
2651 return s->frame_bits/8;
2654 #endif //CONFIG_ENCODERS
2656 static inline void gmc1_motion(MpegEncContext *s,
2657 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2658 uint8_t **ref_picture)
2661 int offset, src_x, src_y, linesize, uvlinesize;
2662 int motion_x, motion_y;
2665 motion_x= s->sprite_offset[0][0];
2666 motion_y= s->sprite_offset[0][1];
2667 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2668 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2669 motion_x<<=(3-s->sprite_warping_accuracy);
2670 motion_y<<=(3-s->sprite_warping_accuracy);
2671 src_x = av_clip(src_x, -16, s->width);
2672 if (src_x == s->width)
2674 src_y = av_clip(src_y, -16, s->height);
2675 if (src_y == s->height)
2678 linesize = s->linesize;
2679 uvlinesize = s->uvlinesize;
2681 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2683 if(s->flags&CODEC_FLAG_EMU_EDGE){
2684 if( (unsigned)src_x >= s->h_edge_pos - 17
2685 || (unsigned)src_y >= s->v_edge_pos - 17){
2686 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2687 ptr= s->edge_emu_buffer;
2691 if((motion_x|motion_y)&7){
2692 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2693 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2697 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2698 if (s->no_rounding){
2699 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2701 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2705 if(s->flags&CODEC_FLAG_GRAY) return;
2707 motion_x= s->sprite_offset[1][0];
2708 motion_y= s->sprite_offset[1][1];
2709 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2710 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2711 motion_x<<=(3-s->sprite_warping_accuracy);
2712 motion_y<<=(3-s->sprite_warping_accuracy);
2713 src_x = av_clip(src_x, -8, s->width>>1);
2714 if (src_x == s->width>>1)
2716 src_y = av_clip(src_y, -8, s->height>>1);
2717 if (src_y == s->height>>1)
2720 offset = (src_y * uvlinesize) + src_x;
2721 ptr = ref_picture[1] + offset;
2722 if(s->flags&CODEC_FLAG_EMU_EDGE){
2723 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2724 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2725 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);
2726 ptr= s->edge_emu_buffer;
2730 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2732 ptr = ref_picture[2] + offset;
2734 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);
2735 ptr= s->edge_emu_buffer;
2737 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2742 static inline void gmc_motion(MpegEncContext *s,
2743 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2744 uint8_t **ref_picture)
2747 int linesize, uvlinesize;
2748 const int a= s->sprite_warping_accuracy;
2751 linesize = s->linesize;
2752 uvlinesize = s->uvlinesize;
2754 ptr = ref_picture[0];
2756 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2757 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2759 s->dsp.gmc(dest_y, ptr, linesize, 16,
2762 s->sprite_delta[0][0], s->sprite_delta[0][1],
2763 s->sprite_delta[1][0], s->sprite_delta[1][1],
2764 a+1, (1<<(2*a+1)) - s->no_rounding,
2765 s->h_edge_pos, s->v_edge_pos);
2766 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2767 ox + s->sprite_delta[0][0]*8,
2768 oy + s->sprite_delta[1][0]*8,
2769 s->sprite_delta[0][0], s->sprite_delta[0][1],
2770 s->sprite_delta[1][0], s->sprite_delta[1][1],
2771 a+1, (1<<(2*a+1)) - s->no_rounding,
2772 s->h_edge_pos, s->v_edge_pos);
2774 if(s->flags&CODEC_FLAG_GRAY) return;
2776 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2777 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2779 ptr = ref_picture[1];
2780 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2783 s->sprite_delta[0][0], s->sprite_delta[0][1],
2784 s->sprite_delta[1][0], s->sprite_delta[1][1],
2785 a+1, (1<<(2*a+1)) - s->no_rounding,
2786 s->h_edge_pos>>1, s->v_edge_pos>>1);
2788 ptr = ref_picture[2];
2789 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2792 s->sprite_delta[0][0], s->sprite_delta[0][1],
2793 s->sprite_delta[1][0], s->sprite_delta[1][1],
2794 a+1, (1<<(2*a+1)) - s->no_rounding,
2795 s->h_edge_pos>>1, s->v_edge_pos>>1);
2799 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2800 * @param buf destination buffer
2801 * @param src source buffer
2802 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2803 * @param block_w width of block
2804 * @param block_h height of block
2805 * @param src_x x coordinate of the top left sample of the block in the source buffer
2806 * @param src_y y coordinate of the top left sample of the block in the source buffer
2807 * @param w width of the source buffer
2808 * @param h height of the source buffer
2810 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2811 int src_x, int src_y, int w, int h){
2813 int start_y, start_x, end_y, end_x;
2816 src+= (h-1-src_y)*linesize;
2818 }else if(src_y<=-block_h){
2819 src+= (1-block_h-src_y)*linesize;
2825 }else if(src_x<=-block_w){
2826 src+= (1-block_w-src_x);
2830 start_y= FFMAX(0, -src_y);
2831 start_x= FFMAX(0, -src_x);
2832 end_y= FFMIN(block_h, h-src_y);
2833 end_x= FFMIN(block_w, w-src_x);
2835 // copy existing part
2836 for(y=start_y; y<end_y; y++){
2837 for(x=start_x; x<end_x; x++){
2838 buf[x + y*linesize]= src[x + y*linesize];
2843 for(y=0; y<start_y; y++){
2844 for(x=start_x; x<end_x; x++){
2845 buf[x + y*linesize]= buf[x + start_y*linesize];
2850 for(y=end_y; y<block_h; y++){
2851 for(x=start_x; x<end_x; x++){
2852 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2856 for(y=0; y<block_h; y++){
2858 for(x=0; x<start_x; x++){
2859 buf[x + y*linesize]= buf[start_x + y*linesize];
2863 for(x=end_x; x<block_w; x++){
2864 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2869 static inline int hpel_motion(MpegEncContext *s,
2870 uint8_t *dest, uint8_t *src,
2871 int field_based, int field_select,
2872 int src_x, int src_y,
2873 int width, int height, int stride,
2874 int h_edge_pos, int v_edge_pos,
2875 int w, int h, op_pixels_func *pix_op,
2876 int motion_x, int motion_y)
2881 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2882 src_x += motion_x >> 1;
2883 src_y += motion_y >> 1;
2885 /* WARNING: do no forget half pels */
2886 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
2889 src_y = av_clip(src_y, -16, height);
2890 if (src_y == height)
2892 src += src_y * stride + src_x;
2894 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2895 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2896 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2897 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2898 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2899 src= s->edge_emu_buffer;
2905 pix_op[dxy](dest, src, stride, h);
2909 static inline int hpel_motion_lowres(MpegEncContext *s,
2910 uint8_t *dest, uint8_t *src,
2911 int field_based, int field_select,
2912 int src_x, int src_y,
2913 int width, int height, int stride,
2914 int h_edge_pos, int v_edge_pos,
2915 int w, int h, h264_chroma_mc_func *pix_op,
2916 int motion_x, int motion_y)
2918 const int lowres= s->avctx->lowres;
2919 const int s_mask= (2<<lowres)-1;
2923 if(s->quarter_sample){
2928 sx= motion_x & s_mask;
2929 sy= motion_y & s_mask;
2930 src_x += motion_x >> (lowres+1);
2931 src_y += motion_y >> (lowres+1);
2933 src += src_y * stride + src_x;
2935 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2936 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2937 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2938 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2939 src= s->edge_emu_buffer;
2947 pix_op[lowres](dest, src, stride, h, sx, sy);
2951 /* apply one mpeg motion vector to the three components */
2952 static av_always_inline void mpeg_motion(MpegEncContext *s,
2953 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2954 int field_based, int bottom_field, int field_select,
2955 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2956 int motion_x, int motion_y, int h)
2958 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2959 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2962 if(s->quarter_sample)
2969 v_edge_pos = s->v_edge_pos >> field_based;
2970 linesize = s->current_picture.linesize[0] << field_based;
2971 uvlinesize = s->current_picture.linesize[1] << field_based;
2973 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2974 src_x = s->mb_x* 16 + (motion_x >> 1);
2975 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2977 if (s->out_format == FMT_H263) {
2978 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2979 mx = (motion_x>>1)|(motion_x&1);
2981 uvdxy = ((my & 1) << 1) | (mx & 1);
2982 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2983 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2985 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2989 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2993 uvsrc_x = s->mb_x*8 + mx;
2994 uvsrc_y = s->mb_y*8 + my;
2996 if(s->chroma_y_shift){
2999 uvdxy = ((my & 1) << 1) | (mx & 1);
3000 uvsrc_x = s->mb_x* 8 + (mx >> 1);
3001 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
3003 if(s->chroma_x_shift){
3006 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
3007 uvsrc_x = s->mb_x* 8 + (mx >> 1);
3018 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3019 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3020 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3022 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
3023 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
3024 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3025 s->codec_id == CODEC_ID_MPEG1VIDEO){
3026 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3029 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3030 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3031 ptr_y = s->edge_emu_buffer;
3032 if(!(s->flags&CODEC_FLAG_GRAY)){
3033 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3034 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3035 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3036 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3037 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3043 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3044 dest_y += s->linesize;
3045 dest_cb+= s->uvlinesize;
3046 dest_cr+= s->uvlinesize;
3050 ptr_y += s->linesize;
3051 ptr_cb+= s->uvlinesize;
3052 ptr_cr+= s->uvlinesize;
3055 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3057 if(!(s->flags&CODEC_FLAG_GRAY)){
3058 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3059 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3061 if((ENABLE_H261_ENCODER || ENABLE_H261_DECODER) && s->out_format == FMT_H261){
3062 ff_h261_loop_filter(s);
3066 /* apply one mpeg motion vector to the three components */
3067 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
3068 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3069 int field_based, int bottom_field, int field_select,
3070 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3071 int motion_x, int motion_y, int h)
3073 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3074 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3075 const int lowres= s->avctx->lowres;
3076 const int block_s= 8>>lowres;
3077 const int s_mask= (2<<lowres)-1;
3078 const int h_edge_pos = s->h_edge_pos >> lowres;
3079 const int v_edge_pos = s->v_edge_pos >> lowres;
3080 linesize = s->current_picture.linesize[0] << field_based;
3081 uvlinesize = s->current_picture.linesize[1] << field_based;
3083 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3089 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3092 sx= motion_x & s_mask;
3093 sy= motion_y & s_mask;
3094 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3095 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3097 if (s->out_format == FMT_H263) {
3098 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3099 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3102 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3105 uvsx = (2*mx) & s_mask;
3106 uvsy = (2*my) & s_mask;
3107 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3108 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3114 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3115 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3118 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3119 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3120 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3122 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3123 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3124 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3125 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3126 ptr_y = s->edge_emu_buffer;
3127 if(!(s->flags&CODEC_FLAG_GRAY)){
3128 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3129 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3130 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3131 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3132 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3138 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3139 dest_y += s->linesize;
3140 dest_cb+= s->uvlinesize;
3141 dest_cr+= s->uvlinesize;
3145 ptr_y += s->linesize;
3146 ptr_cb+= s->uvlinesize;
3147 ptr_cr+= s->uvlinesize;
3152 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3154 if(!(s->flags&CODEC_FLAG_GRAY)){
3155 uvsx <<= 2 - lowres;
3156 uvsy <<= 2 - lowres;
3157 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3158 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3160 //FIXME h261 lowres loop filter
3163 //FIXME move to dsputil, avg variant, 16x16 version
3164 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3166 uint8_t * const top = src[1];
3167 uint8_t * const left = src[2];
3168 uint8_t * const mid = src[0];
3169 uint8_t * const right = src[3];
3170 uint8_t * const bottom= src[4];
3171 #define OBMC_FILTER(x, t, l, m, r, b)\
3172 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3173 #define OBMC_FILTER4(x, t, l, m, r, b)\
3174 OBMC_FILTER(x , t, l, m, r, b);\
3175 OBMC_FILTER(x+1 , t, l, m, r, b);\
3176 OBMC_FILTER(x +stride, t, l, m, r, b);\
3177 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3180 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3181 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3182 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3183 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3184 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3185 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3187 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3188 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3189 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3190 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3192 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3193 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3194 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3195 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3197 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3198 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3199 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3200 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3202 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3203 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3204 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3205 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3206 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3207 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3209 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3210 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3211 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3212 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3215 /* obmc for 1 8x8 luma block */
3216 static inline void obmc_motion(MpegEncContext *s,
3217 uint8_t *dest, uint8_t *src,
3218 int src_x, int src_y,
3219 op_pixels_func *pix_op,
3220 int16_t mv[5][2]/* mid top left right bottom*/)
3226 assert(s->quarter_sample==0);
3229 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3232 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3233 hpel_motion(s, ptr[i], src, 0, 0,
3235 s->width, s->height, s->linesize,
3236 s->h_edge_pos, s->v_edge_pos,
3238 mv[i][0], mv[i][1]);
3242 put_obmc(dest, ptr, s->linesize);
3245 static inline void qpel_motion(MpegEncContext *s,
3246 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3247 int field_based, int bottom_field, int field_select,
3248 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3249 qpel_mc_func (*qpix_op)[16],
3250 int motion_x, int motion_y, int h)
3252 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3253 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3255 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3256 src_x = s->mb_x * 16 + (motion_x >> 2);
3257 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3259 v_edge_pos = s->v_edge_pos >> field_based;
3260 linesize = s->linesize << field_based;
3261 uvlinesize = s->uvlinesize << field_based;
3266 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3267 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3268 mx= (motion_x>>1) + rtab[motion_x&7];
3269 my= (motion_y>>1) + rtab[motion_y&7];
3270 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3271 mx= (motion_x>>1)|(motion_x&1);
3272 my= (motion_y>>1)|(motion_y&1);
3280 uvdxy= (mx&1) | ((my&1)<<1);
3284 uvsrc_x = s->mb_x * 8 + mx;
3285 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3287 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3288 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3289 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3291 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3292 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3293 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3294 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3295 ptr_y= s->edge_emu_buffer;
3296 if(!(s->flags&CODEC_FLAG_GRAY)){
3297 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3298 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3299 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3300 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3301 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3308 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3311 dest_y += s->linesize;
3312 dest_cb+= s->uvlinesize;
3313 dest_cr+= s->uvlinesize;
3317 ptr_y += s->linesize;
3318 ptr_cb += s->uvlinesize;
3319 ptr_cr += s->uvlinesize;
3321 //damn interlaced mode
3322 //FIXME boundary mirroring is not exactly correct here
3323 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3324 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3326 if(!(s->flags&CODEC_FLAG_GRAY)){
3327 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3328 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3332 inline int ff_h263_round_chroma(int x){
3334 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3337 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3342 * h263 chorma 4mv motion compensation.
3344 static inline void chroma_4mv_motion(MpegEncContext *s,
3345 uint8_t *dest_cb, uint8_t *dest_cr,
3346 uint8_t **ref_picture,
3347 op_pixels_func *pix_op,
3349 int dxy, emu=0, src_x, src_y, offset;
3352 /* In case of 8X8, we construct a single chroma motion vector
3353 with a special rounding */
3354 mx= ff_h263_round_chroma(mx);
3355 my= ff_h263_round_chroma(my);
3357 dxy = ((my & 1) << 1) | (mx & 1);
3361 src_x = s->mb_x * 8 + mx;
3362 src_y = s->mb_y * 8 + my;
3363 src_x = av_clip(src_x, -8, s->width/2);
3364 if (src_x == s->width/2)
3366 src_y = av_clip(src_y, -8, s->height/2);
3367 if (src_y == s->height/2)
3370 offset = (src_y * (s->uvlinesize)) + src_x;
3371 ptr = ref_picture[1] + offset;
3372 if(s->flags&CODEC_FLAG_EMU_EDGE){
3373 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3374 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3375 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);
3376 ptr= s->edge_emu_buffer;
3380 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3382 ptr = ref_picture[2] + offset;
3384 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);
3385 ptr= s->edge_emu_buffer;
3387 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3390 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3391 uint8_t *dest_cb, uint8_t *dest_cr,
3392 uint8_t **ref_picture,
3393 h264_chroma_mc_func *pix_op,
3395 const int lowres= s->avctx->lowres;
3396 const int block_s= 8>>lowres;
3397 const int s_mask= (2<<lowres)-1;
3398 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3399 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3400 int emu=0, src_x, src_y, offset, sx, sy;
3403 if(s->quarter_sample){
3408 /* In case of 8X8, we construct a single chroma motion vector
3409 with a special rounding */
3410 mx= ff_h263_round_chroma(mx);
3411 my= ff_h263_round_chroma(my);
3415 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3416 src_y = s->mb_y*block_s + (my >> (lowres+1));
3418 offset = src_y * s->uvlinesize + src_x;
3419 ptr = ref_picture[1] + offset;
3420 if(s->flags&CODEC_FLAG_EMU_EDGE){
3421 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3422 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3423 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3424 ptr= s->edge_emu_buffer;
3430 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3432 ptr = ref_picture[2] + offset;
3434 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3435 ptr= s->edge_emu_buffer;
3437 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3440 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3441 /* fetch pixels for estimated mv 4 macroblocks ahead
3442 * optimized for 64byte cache lines */
3443 const int shift = s->quarter_sample ? 2 : 1;
3444 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3445 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3446 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3447 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3448 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3449 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3453 * motion compensation of a single macroblock
3455 * @param dest_y luma destination pointer
3456 * @param dest_cb chroma cb/u destination pointer
3457 * @param dest_cr chroma cr/v destination pointer
3458 * @param dir direction (0->forward, 1->backward)
3459 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3460 * @param pic_op halfpel motion compensation function (average or put normally)
3461 * @param pic_op qpel motion compensation function (average or put normally)
3462 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3464 static inline void MPV_motion(MpegEncContext *s,
3465 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3466 int dir, uint8_t **ref_picture,
3467 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3469 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3471 uint8_t *ptr, *dest;
3476 prefetch_motion(s, ref_picture, dir);
3478 if(s->obmc && s->pict_type != B_TYPE){
3479 int16_t mv_cache[4][4][2];
3480 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3481 const int mot_stride= s->b8_stride;
3482 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3484 assert(!s->mb_skipped);
3486 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3487 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3488 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3490 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3491 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3493 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3496 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3497 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3498 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3500 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3501 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3504 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3505 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3506 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3508 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3509 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];