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"
37 #include "libvo/fastmemcpy.h"
43 #ifdef CONFIG_ENCODERS
44 static int encode_picture(MpegEncContext *s, int picture_number);
45 #endif //CONFIG_ENCODERS
46 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
59 DCTELEM *block, int n, int qscale);
60 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
61 #ifdef CONFIG_ENCODERS
62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
65 static int sse_mb(MpegEncContext *s);
66 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
67 #endif //CONFIG_ENCODERS
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
71 extern void XVMC_field_end(MpegEncContext *s);
72 extern void XVMC_decode_mb(MpegEncContext *s);
75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
78 /* enable all paranoid tests for rounding, overflows, etc... */
84 /* for jpeg fast DCT */
87 static const uint16_t aanscales[64] = {
88 /* precomputed values scaled up by 14 bits */
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
99 static const uint8_t h263_chroma_roundtab[16] = {
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
104 static const uint8_t ff_default_chroma_qscale_table[32]={
105 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
106 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
109 #ifdef CONFIG_ENCODERS
110 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
111 static uint8_t default_fcode_tab[MAX_MV*2+1];
113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
115 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
121 for(qscale=qmin; qscale<=qmax; qscale++){
123 if (dsp->fdct == ff_jpeg_fdct_islow
124 #ifdef FAAN_POSTSCALE
125 || dsp->fdct == ff_faandct
129 const int j= dsp->idct_permutation[i];
130 /* 16 <= qscale * quant_matrix[i] <= 7905 */
131 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
132 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
133 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
135 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
136 (qscale * quant_matrix[j]));
138 } else if (dsp->fdct == fdct_ifast
139 #ifndef FAAN_POSTSCALE
140 || dsp->fdct == ff_faandct
144 const int j= dsp->idct_permutation[i];
145 /* 16 <= qscale * quant_matrix[i] <= 7905 */
146 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
147 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
148 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
150 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
151 (aanscales[i] * qscale * quant_matrix[j]));
155 const int j= dsp->idct_permutation[i];
156 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
157 So 16 <= qscale * quant_matrix[i] <= 7905
158 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
159 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
161 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
162 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
163 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
165 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
166 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
170 for(i=intra; i<64; i++){
172 if (dsp->fdct == fdct_ifast
173 #ifndef FAAN_POSTSCALE
174 || dsp->fdct == ff_faandct
177 max= (8191LL*aanscales[i]) >> 14;
179 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
185 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
189 static inline void update_qscale(MpegEncContext *s){
190 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
191 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
193 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
195 #endif //CONFIG_ENCODERS
197 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
201 st->scantable= src_scantable;
205 j = src_scantable[i];
206 st->permutated[i] = permutation[j];
215 j = st->permutated[i];
217 st->raster_end[i]= end;
221 #ifdef CONFIG_ENCODERS
222 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
228 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
233 #endif //CONFIG_ENCODERS
235 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
243 uint32_t tmp= *state << 8;
244 *state= tmp + *(p++);
245 if(tmp == 0x100 || p==end)
250 if (p[-1] > 1 ) p+= 3;
251 else if(p[-2] ) p+= 2;
252 else if(p[-3]|(p[-1]-1)) p++;
260 *state= be2me_32(unaligned32(p));
265 /* init common dct for both encoder and decoder */
266 int DCT_common_init(MpegEncContext *s)
268 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
269 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
270 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
271 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
273 if(s->flags & CODEC_FLAG_BITEXACT)
274 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
275 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
277 #ifdef CONFIG_ENCODERS
278 s->dct_quantize= dct_quantize_c;
279 s->denoise_dct= denoise_dct_c;
280 #endif //CONFIG_ENCODERS
283 MPV_common_init_mmx(s);
286 MPV_common_init_axp(s);
289 MPV_common_init_mlib(s);
292 MPV_common_init_mmi(s);
295 MPV_common_init_armv4l(s);
298 MPV_common_init_ppc(s);
301 #ifdef CONFIG_ENCODERS
302 s->fast_dct_quantize= s->dct_quantize;
304 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
305 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
308 #endif //CONFIG_ENCODERS
310 /* load & permutate scantables
311 note: only wmv uses different ones
313 if(s->alternate_scan){
314 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
315 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
317 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
320 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
321 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
326 static void copy_picture(Picture *dst, Picture *src){
328 dst->type= FF_BUFFER_TYPE_COPY;
331 #ifdef CONFIG_ENCODERS
332 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
335 dst->pict_type = src->pict_type;
336 dst->quality = src->quality;
337 dst->coded_picture_number = src->coded_picture_number;
338 dst->display_picture_number = src->display_picture_number;
339 // dst->reference = src->reference;
341 dst->interlaced_frame = src->interlaced_frame;
342 dst->top_field_first = src->top_field_first;
344 if(s->avctx->me_threshold){
345 if(!src->motion_val[0])
346 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
349 if(!src->ref_index[0])
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
351 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
352 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
353 src->motion_subsample_log2, dst->motion_subsample_log2);
355 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
358 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
359 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
361 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
362 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
364 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
365 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
373 * allocates a Picture
374 * The pixels are allocated/set by calling get_buffer() if shared=0
376 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
377 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
378 const int mb_array_size= s->mb_stride*s->mb_height;
379 const int b8_array_size= s->b8_stride*s->mb_height*2;
380 const int b4_array_size= s->b4_stride*s->mb_height*4;
384 assert(pic->data[0]);
385 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
386 pic->type= FF_BUFFER_TYPE_SHARED;
390 assert(!pic->data[0]);
392 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
394 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
395 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
399 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
400 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
404 if(pic->linesize[1] != pic->linesize[2]){
405 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
409 s->linesize = pic->linesize[0];
410 s->uvlinesize= pic->linesize[1];
413 if(pic->qscale_table==NULL){
415 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
416 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
417 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
420 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
421 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
422 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
423 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
424 if(s->out_format == FMT_H264){
426 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
427 pic->motion_val[i]= pic->motion_val_base[i]+4;
428 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
430 pic->motion_subsample_log2= 2;
431 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
433 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
434 pic->motion_val[i]= pic->motion_val_base[i]+4;
435 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
437 pic->motion_subsample_log2= 3;
439 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
440 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
442 pic->qstride= s->mb_stride;
443 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
446 //it might be nicer if the application would keep track of these but it would require a API change
447 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
448 s->prev_pict_types[0]= s->pict_type;
449 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
450 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
453 fail: //for the CHECKED_ALLOCZ macro
458 * deallocates a picture
460 static void free_picture(MpegEncContext *s, Picture *pic){
463 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
464 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
467 av_freep(&pic->mb_var);
468 av_freep(&pic->mc_mb_var);
469 av_freep(&pic->mb_mean);
470 av_freep(&pic->mbskip_table);
471 av_freep(&pic->qscale_table);
472 av_freep(&pic->mb_type_base);
473 av_freep(&pic->dct_coeff);
474 av_freep(&pic->pan_scan);
477 av_freep(&pic->motion_val_base[i]);
478 av_freep(&pic->ref_index[i]);
481 if(pic->type == FF_BUFFER_TYPE_SHARED){
490 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
493 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
494 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
495 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
497 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
498 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
499 s->rd_scratchpad= s->me.scratchpad;
500 s->b_scratchpad= s->me.scratchpad;
501 s->obmc_scratchpad= s->me.scratchpad + 16;
503 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
504 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
505 if(s->avctx->noise_reduction){
506 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
509 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
510 s->block= s->blocks[0];
513 s->pblocks[i] = (short *)(&s->block[i]);
517 return -1; //free() through MPV_common_end()
520 static void free_duplicate_context(MpegEncContext *s){
523 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
524 av_freep(&s->me.scratchpad);
527 s->obmc_scratchpad= NULL;
529 av_freep(&s->dct_error_sum);
530 av_freep(&s->me.map);
531 av_freep(&s->me.score_map);
532 av_freep(&s->blocks);
536 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
537 #define COPY(a) bak->a= src->a
538 COPY(allocated_edge_emu_buffer);
539 COPY(edge_emu_buffer);
543 COPY(obmc_scratchpad);
550 COPY(me.map_generation);
558 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
561 //FIXME copy only needed parts
563 backup_duplicate_context(&bak, dst);
564 memcpy(dst, src, sizeof(MpegEncContext));
565 backup_duplicate_context(dst, &bak);
567 dst->pblocks[i] = (short *)(&dst->block[i]);
569 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
572 #ifdef CONFIG_ENCODERS
573 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
574 #define COPY(a) dst->a= src->a
576 COPY(current_picture);
582 COPY(picture_in_gop_number);
583 COPY(gop_picture_number);
584 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
585 COPY(progressive_frame); //FIXME don't set in encode_header
586 COPY(partitioned_frame); //FIXME don't set in encode_header
592 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
593 * the changed fields will not depend upon the prior state of the MpegEncContext.
595 static void MPV_common_defaults(MpegEncContext *s){
597 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
598 s->chroma_qscale_table= ff_default_chroma_qscale_table;
599 s->progressive_frame= 1;
600 s->progressive_sequence= 1;
601 s->picture_structure= PICT_FRAME;
603 s->coded_picture_number = 0;
604 s->picture_number = 0;
605 s->input_picture_number = 0;
607 s->picture_in_gop_number = 0;
614 * sets the given MpegEncContext to defaults for decoding.
615 * the changed fields will not depend upon the prior state of the MpegEncContext.
617 void MPV_decode_defaults(MpegEncContext *s){
618 MPV_common_defaults(s);
622 * sets the given MpegEncContext to defaults for encoding.
623 * the changed fields will not depend upon the prior state of the MpegEncContext.
626 #ifdef CONFIG_ENCODERS
627 static void MPV_encode_defaults(MpegEncContext *s){
630 MPV_common_defaults(s);
636 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
637 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
639 for(i=-16; i<16; i++){
640 default_fcode_tab[i + MAX_MV]= 1;
643 s->me.mv_penalty= default_mv_penalty;
644 s->fcode_tab= default_fcode_tab;
646 #endif //CONFIG_ENCODERS
649 * init common structure for both encoder and decoder.
650 * this assumes that some variables like width/height are already set
652 int MPV_common_init(MpegEncContext *s)
654 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
656 s->mb_height = (s->height + 15) / 16;
658 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
659 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
663 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
666 dsputil_init(&s->dsp, s->avctx);
669 s->flags= s->avctx->flags;
670 s->flags2= s->avctx->flags2;
672 s->mb_width = (s->width + 15) / 16;
673 s->mb_stride = s->mb_width + 1;
674 s->b8_stride = s->mb_width*2 + 1;
675 s->b4_stride = s->mb_width*4 + 1;
676 mb_array_size= s->mb_height * s->mb_stride;
677 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
679 /* set chroma shifts */
680 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
681 &(s->chroma_y_shift) );
683 /* set default edge pos, will be overriden in decode_header if needed */
684 s->h_edge_pos= s->mb_width*16;
685 s->v_edge_pos= s->mb_height*16;
687 s->mb_num = s->mb_width * s->mb_height;
692 s->block_wrap[3]= s->b8_stride;
694 s->block_wrap[5]= s->mb_stride;
696 y_size = s->b8_stride * (2 * s->mb_height + 1);
697 c_size = s->mb_stride * (s->mb_height + 1);
698 yc_size = y_size + 2 * c_size;
700 /* convert fourcc to upper case */
701 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
702 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
703 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
704 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
706 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
707 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
708 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
709 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
711 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
713 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
714 for(y=0; y<s->mb_height; y++){
715 for(x=0; x<s->mb_width; x++){
716 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
719 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
722 /* Allocate MV tables */
723 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
724 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
725 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
726 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
727 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
728 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
729 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
730 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
731 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
732 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
733 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
734 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
736 if(s->msmpeg4_version){
737 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
739 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
741 /* Allocate MB type table */
742 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
744 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
746 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
747 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
748 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
749 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
750 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
751 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
753 if(s->avctx->noise_reduction){
754 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
757 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
759 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
761 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
762 /* interlaced direct mode decoding tables */
767 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
768 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
770 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
771 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
772 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
774 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
777 if (s->out_format == FMT_H263) {
779 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
780 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
781 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
782 s->ac_val[2] = s->ac_val[1] + c_size;
785 CHECKED_ALLOCZ(s->coded_block_base, y_size);
786 s->coded_block= s->coded_block_base + s->b8_stride + 1;
788 /* cbp, ac_pred, pred_dir */
789 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
790 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
793 if (s->h263_pred || s->h263_plus || !s->encoding) {
795 //MN: we need these for error resilience of intra-frames
796 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
797 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
798 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
799 s->dc_val[2] = s->dc_val[1] + c_size;
800 for(i=0;i<yc_size;i++)
801 s->dc_val_base[i] = 1024;
804 /* which mb is a intra block */
805 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
806 memset(s->mbintra_table, 1, mb_array_size);
808 /* init macroblock skip table */
809 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
810 //Note the +1 is for a quicker mpeg4 slice_end detection
811 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
813 s->parse_context.state= -1;
814 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
815 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
816 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
817 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
820 s->context_initialized = 1;
822 s->thread_context[0]= s;
823 for(i=1; i<s->avctx->thread_count; i++){
824 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
825 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
828 for(i=0; i<s->avctx->thread_count; i++){
829 if(init_duplicate_context(s->thread_context[i], s) < 0)
831 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
832 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
841 /* init common structure for both encoder and decoder */
842 void MPV_common_end(MpegEncContext *s)
846 for(i=0; i<s->avctx->thread_count; i++){
847 free_duplicate_context(s->thread_context[i]);
849 for(i=1; i<s->avctx->thread_count; i++){
850 av_freep(&s->thread_context[i]);
853 av_freep(&s->parse_context.buffer);
854 s->parse_context.buffer_size=0;
856 av_freep(&s->mb_type);
857 av_freep(&s->p_mv_table_base);
858 av_freep(&s->b_forw_mv_table_base);
859 av_freep(&s->b_back_mv_table_base);
860 av_freep(&s->b_bidir_forw_mv_table_base);
861 av_freep(&s->b_bidir_back_mv_table_base);
862 av_freep(&s->b_direct_mv_table_base);
864 s->b_forw_mv_table= NULL;
865 s->b_back_mv_table= NULL;
866 s->b_bidir_forw_mv_table= NULL;
867 s->b_bidir_back_mv_table= NULL;
868 s->b_direct_mv_table= NULL;
872 av_freep(&s->b_field_mv_table_base[i][j][k]);
873 s->b_field_mv_table[i][j][k]=NULL;
875 av_freep(&s->b_field_select_table[i][j]);
876 av_freep(&s->p_field_mv_table_base[i][j]);
877 s->p_field_mv_table[i][j]=NULL;
879 av_freep(&s->p_field_select_table[i]);
882 av_freep(&s->dc_val_base);
883 av_freep(&s->ac_val_base);
884 av_freep(&s->coded_block_base);
885 av_freep(&s->mbintra_table);
886 av_freep(&s->cbp_table);
887 av_freep(&s->pred_dir_table);
889 av_freep(&s->mbskip_table);
890 av_freep(&s->prev_pict_types);
891 av_freep(&s->bitstream_buffer);
892 s->allocated_bitstream_buffer_size=0;
894 av_freep(&s->avctx->stats_out);
895 av_freep(&s->ac_stats);
896 av_freep(&s->error_status_table);
897 av_freep(&s->mb_index2xy);
898 av_freep(&s->lambda_table);
899 av_freep(&s->q_intra_matrix);
900 av_freep(&s->q_inter_matrix);
901 av_freep(&s->q_intra_matrix16);
902 av_freep(&s->q_inter_matrix16);
903 av_freep(&s->input_picture);
904 av_freep(&s->reordered_input_picture);
905 av_freep(&s->dct_offset);
908 for(i=0; i<MAX_PICTURE_COUNT; i++){
909 free_picture(s, &s->picture[i]);
912 av_freep(&s->picture);
913 s->context_initialized = 0;
916 s->current_picture_ptr= NULL;
917 s->linesize= s->uvlinesize= 0;
920 av_freep(&s->visualization_buffer[i]);
922 avcodec_default_free_buffers(s->avctx);
925 #ifdef CONFIG_ENCODERS
927 /* init video encoder */
928 int MPV_encode_init(AVCodecContext *avctx)
930 MpegEncContext *s = avctx->priv_data;
932 int chroma_h_shift, chroma_v_shift;
934 MPV_encode_defaults(s);
936 switch (avctx->codec_id) {
937 case CODEC_ID_MPEG2VIDEO:
938 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
939 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
945 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
946 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
947 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
952 if(avctx->pix_fmt != PIX_FMT_YUV420P){
953 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
958 switch (avctx->pix_fmt) {
959 case PIX_FMT_YUVJ422P:
960 case PIX_FMT_YUV422P:
961 s->chroma_format = CHROMA_422;
963 case PIX_FMT_YUVJ420P:
964 case PIX_FMT_YUV420P:
966 s->chroma_format = CHROMA_420;
970 s->bit_rate = avctx->bit_rate;
971 s->width = avctx->width;
972 s->height = avctx->height;
973 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
974 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
977 s->gop_size = avctx->gop_size;
979 s->flags= avctx->flags;
980 s->flags2= avctx->flags2;
981 s->max_b_frames= avctx->max_b_frames;
982 s->codec_id= avctx->codec->id;
983 s->luma_elim_threshold = avctx->luma_elim_threshold;
984 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
985 s->strict_std_compliance= avctx->strict_std_compliance;
986 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
987 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
988 s->mpeg_quant= avctx->mpeg_quant;
989 s->rtp_mode= !!avctx->rtp_payload_size;
990 s->intra_dc_precision= avctx->intra_dc_precision;
991 s->user_specified_pts = AV_NOPTS_VALUE;
993 if (s->gop_size <= 1) {
1000 s->me_method = avctx->me_method;
1003 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
1005 s->adaptive_quant= ( s->avctx->lumi_masking
1006 || s->avctx->dark_masking
1007 || s->avctx->temporal_cplx_masking
1008 || s->avctx->spatial_cplx_masking
1009 || s->avctx->p_masking
1010 || s->avctx->border_masking
1011 || (s->flags&CODEC_FLAG_QP_RD))
1012 && !s->fixed_qscale;
1014 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1015 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1016 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1017 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1019 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1020 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1024 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1025 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1028 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1029 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1033 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1034 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1038 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1039 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1040 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1042 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");
1045 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1046 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1047 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1051 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1052 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1056 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1057 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1061 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1062 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1066 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1067 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1071 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1072 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1076 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1077 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1078 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1082 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1083 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1087 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1088 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1092 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1093 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1097 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1098 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1102 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1103 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1107 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1108 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1109 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1110 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1114 if(s->avctx->thread_count > 1)
1117 if(!avctx->time_base.den || !avctx->time_base.num){
1118 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1122 i= (INT_MAX/2+128)>>8;
1123 if(avctx->me_threshold >= i){
1124 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1127 if(avctx->mb_threshold >= i){
1128 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1132 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1133 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1134 avctx->b_frame_strategy = 0;
1137 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1139 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1140 avctx->time_base.den /= i;
1141 avctx->time_base.num /= i;
1145 if(s->codec_id==CODEC_ID_MJPEG){
1146 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1147 s->inter_quant_bias= 0;
1148 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1149 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1150 s->inter_quant_bias= 0;
1152 s->intra_quant_bias=0;
1153 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1156 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1157 s->intra_quant_bias= avctx->intra_quant_bias;
1158 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1159 s->inter_quant_bias= avctx->inter_quant_bias;
1161 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1163 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1164 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1167 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1169 switch(avctx->codec->id) {
1170 case CODEC_ID_MPEG1VIDEO:
1171 s->out_format = FMT_MPEG1;
1172 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1173 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1175 case CODEC_ID_MPEG2VIDEO:
1176 s->out_format = FMT_MPEG1;
1177 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1178 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1181 case CODEC_ID_LJPEG:
1182 case CODEC_ID_JPEGLS:
1183 case CODEC_ID_MJPEG:
1184 s->out_format = FMT_MJPEG;
1185 s->intra_only = 1; /* force intra only for jpeg */
1186 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1187 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1188 s->mjpeg_vsample[0] = 2;
1189 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1190 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1191 s->mjpeg_hsample[0] = 2;
1192 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1193 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1194 if (mjpeg_init(s) < 0)
1200 s->out_format = FMT_H261;
1205 if (h263_get_picture_format(s->width, s->height) == 7) {
1206 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);
1209 s->out_format = FMT_H263;
1210 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1214 case CODEC_ID_H263P:
1215 s->out_format = FMT_H263;
1218 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1219 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1220 s->modified_quant= s->h263_aic;
1221 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1222 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1223 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1224 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1225 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1228 /* These are just to be sure */
1233 s->out_format = FMT_H263;
1234 s->h263_flv = 2; /* format = 1; 11-bit codes */
1235 s->unrestricted_mv = 1;
1236 s->rtp_mode=0; /* don't allow GOB */
1241 s->out_format = FMT_H263;
1246 s->out_format = FMT_H263;
1249 s->modified_quant=1;
1253 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1255 case CODEC_ID_MPEG4:
1256 s->out_format = FMT_H263;
1258 s->unrestricted_mv = 1;
1259 s->low_delay= s->max_b_frames ? 0 : 1;
1260 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1262 case CODEC_ID_MSMPEG4V1:
1263 s->out_format = FMT_H263;
1264 s->h263_msmpeg4 = 1;
1266 s->unrestricted_mv = 1;
1267 s->msmpeg4_version= 1;
1271 case CODEC_ID_MSMPEG4V2:
1272 s->out_format = FMT_H263;
1273 s->h263_msmpeg4 = 1;
1275 s->unrestricted_mv = 1;
1276 s->msmpeg4_version= 2;
1280 case CODEC_ID_MSMPEG4V3:
1281 s->out_format = FMT_H263;
1282 s->h263_msmpeg4 = 1;
1284 s->unrestricted_mv = 1;
1285 s->msmpeg4_version= 3;
1286 s->flipflop_rounding=1;
1291 s->out_format = FMT_H263;
1292 s->h263_msmpeg4 = 1;
1294 s->unrestricted_mv = 1;
1295 s->msmpeg4_version= 4;
1296 s->flipflop_rounding=1;
1301 s->out_format = FMT_H263;
1302 s->h263_msmpeg4 = 1;
1304 s->unrestricted_mv = 1;
1305 s->msmpeg4_version= 5;
1306 s->flipflop_rounding=1;
1314 avctx->has_b_frames= !s->low_delay;
1319 if (MPV_common_init(s) < 0)
1322 if(s->modified_quant)
1323 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1324 s->progressive_frame=
1325 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1326 s->quant_precision=5;
1328 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1329 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1331 #ifdef CONFIG_H261_ENCODER
1332 if (s->out_format == FMT_H261)
1333 ff_h261_encode_init(s);
1335 if (s->out_format == FMT_H263)
1336 h263_encode_init(s);
1337 if(s->msmpeg4_version)
1338 ff_msmpeg4_encode_init(s);
1339 if (s->out_format == FMT_MPEG1)
1340 ff_mpeg1_encode_init(s);
1344 int j= s->dsp.idct_permutation[i];
1345 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1346 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1347 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1348 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1349 s->intra_matrix[j] =
1350 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1353 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1354 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1356 if(s->avctx->intra_matrix)
1357 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1358 if(s->avctx->inter_matrix)
1359 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1362 /* precompute matrix */
1363 /* for mjpeg, we do include qscale in the matrix */
1364 if (s->out_format != FMT_MJPEG) {
1365 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1366 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1367 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1368 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1371 if(ff_rate_control_init(s) < 0)
1377 int MPV_encode_end(AVCodecContext *avctx)
1379 MpegEncContext *s = avctx->priv_data;
1381 ff_rate_control_uninit(s);
1384 if (s->out_format == FMT_MJPEG)
1387 av_freep(&avctx->extradata);
1392 #endif //CONFIG_ENCODERS
1394 void init_rl(RLTable *rl, int use_static)
1396 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1397 uint8_t index_run[MAX_RUN+1];
1398 int last, run, level, start, end, i;
1400 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1401 if(use_static && rl->max_level[0])
1404 /* compute max_level[], max_run[] and index_run[] */
1405 for(last=0;last<2;last++) {
1414 memset(max_level, 0, MAX_RUN + 1);
1415 memset(max_run, 0, MAX_LEVEL + 1);
1416 memset(index_run, rl->n, MAX_RUN + 1);
1417 for(i=start;i<end;i++) {
1418 run = rl->table_run[i];
1419 level = rl->table_level[i];
1420 if (index_run[run] == rl->n)
1422 if (level > max_level[run])
1423 max_level[run] = level;
1424 if (run > max_run[level])
1425 max_run[level] = run;
1428 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1430 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1431 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1433 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1435 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1436 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1438 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1440 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1441 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1445 /* draw the edges of width 'w' of an image of size width, height */
1446 //FIXME check that this is ok for mpeg4 interlaced
1447 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1449 uint8_t *ptr, *last_line;
1452 last_line = buf + (height - 1) * wrap;
1454 /* top and bottom */
1455 memcpy(buf - (i + 1) * wrap, buf, width);
1456 memcpy(last_line + (i + 1) * wrap, last_line, width);
1458 /* left and right */
1460 for(i=0;i<height;i++) {
1461 memset(ptr - w, ptr[0], w);
1462 memset(ptr + width, ptr[width-1], w);
1467 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1468 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1469 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1470 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1474 int ff_find_unused_picture(MpegEncContext *s, int shared){
1478 for(i=0; i<MAX_PICTURE_COUNT; i++){
1479 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1482 for(i=0; i<MAX_PICTURE_COUNT; i++){
1483 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1485 for(i=0; i<MAX_PICTURE_COUNT; i++){
1486 if(s->picture[i].data[0]==NULL) return i;
1494 static void update_noise_reduction(MpegEncContext *s){
1497 for(intra=0; intra<2; intra++){
1498 if(s->dct_count[intra] > (1<<16)){
1499 for(i=0; i<64; i++){
1500 s->dct_error_sum[intra][i] >>=1;
1502 s->dct_count[intra] >>= 1;
1505 for(i=0; i<64; i++){
1506 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);
1512 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1514 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1520 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1522 /* mark&release old frames */
1523 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1524 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1526 /* release forgotten pictures */
1527 /* if(mpeg124/h263) */
1529 for(i=0; i<MAX_PICTURE_COUNT; i++){
1530 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1531 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1532 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1539 /* release non reference frames */
1540 for(i=0; i<MAX_PICTURE_COUNT; i++){
1541 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1542 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1546 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1547 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1549 i= ff_find_unused_picture(s, 0);
1550 pic= (AVFrame*)&s->picture[i];
1553 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1554 && !s->dropable ? 3 : 0;
1556 pic->coded_picture_number= s->coded_picture_number++;
1558 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1561 s->current_picture_ptr= (Picture*)pic;
1562 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1563 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1566 s->current_picture_ptr->pict_type= s->pict_type;
1567 // if(s->flags && CODEC_FLAG_QSCALE)
1568 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1569 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1571 copy_picture(&s->current_picture, s->current_picture_ptr);
1573 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1574 if (s->pict_type != B_TYPE) {
1575 s->last_picture_ptr= s->next_picture_ptr;
1577 s->next_picture_ptr= s->current_picture_ptr;
1579 /* 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,
1580 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1581 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1582 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1583 s->pict_type, s->dropable);*/
1585 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1586 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1588 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1589 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1590 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1594 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1596 if(s->picture_structure!=PICT_FRAME){
1599 if(s->picture_structure == PICT_BOTTOM_FIELD){
1600 s->current_picture.data[i] += s->current_picture.linesize[i];
1602 s->current_picture.linesize[i] *= 2;
1603 s->last_picture.linesize[i] *=2;
1604 s->next_picture.linesize[i] *=2;
1609 s->hurry_up= s->avctx->hurry_up;
1610 s->error_resilience= avctx->error_resilience;
1612 /* set dequantizer, we can't do it during init as it might change for mpeg4
1613 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1614 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1615 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1616 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1617 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1618 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1619 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1621 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1622 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1625 if(s->dct_error_sum){
1626 assert(s->avctx->noise_reduction && s->encoding);
1628 update_noise_reduction(s);
1632 if(s->avctx->xvmc_acceleration)
1633 return XVMC_field_start(s, avctx);
1638 /* generic function for encode/decode called after a frame has been coded/decoded */
1639 void MPV_frame_end(MpegEncContext *s)
1642 /* draw edge for correct motion prediction if outside */
1644 //just to make sure that all data is rendered.
1645 if(s->avctx->xvmc_acceleration){
1649 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1650 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1651 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1652 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1656 s->last_pict_type = s->pict_type;
1657 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1658 if(s->pict_type!=B_TYPE){
1659 s->last_non_b_pict_type= s->pict_type;
1662 /* copy back current_picture variables */
1663 for(i=0; i<MAX_PICTURE_COUNT; i++){
1664 if(s->picture[i].data[0] == s->current_picture.data[0]){
1665 s->picture[i]= s->current_picture;
1669 assert(i<MAX_PICTURE_COUNT);
1673 /* release non-reference frames */
1674 for(i=0; i<MAX_PICTURE_COUNT; i++){
1675 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1676 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1680 // clear copies, to avoid confusion
1682 memset(&s->last_picture, 0, sizeof(Picture));
1683 memset(&s->next_picture, 0, sizeof(Picture));
1684 memset(&s->current_picture, 0, sizeof(Picture));
1686 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1690 * draws an line from (ex, ey) -> (sx, sy).
1691 * @param w width of the image
1692 * @param h height of the image
1693 * @param stride stride/linesize of the image
1694 * @param color color of the arrow
1696 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1699 sx= clip(sx, 0, w-1);
1700 sy= clip(sy, 0, h-1);
1701 ex= clip(ex, 0, w-1);
1702 ey= clip(ey, 0, h-1);
1704 buf[sy*stride + sx]+= color;
1706 if(FFABS(ex - sx) > FFABS(ey - sy)){
1708 FFSWAP(int, sx, ex);
1709 FFSWAP(int, sy, ey);
1711 buf+= sx + sy*stride;
1713 f= ((ey-sy)<<16)/ex;
1714 for(x= 0; x <= ex; x++){
1717 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1718 buf[(y+1)*stride + x]+= (color* fr )>>16;
1722 FFSWAP(int, sx, ex);
1723 FFSWAP(int, sy, ey);
1725 buf+= sx + sy*stride;
1727 if(ey) f= ((ex-sx)<<16)/ey;
1729 for(y= 0; y <= ey; y++){
1732 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1733 buf[y*stride + x+1]+= (color* fr )>>16;;
1739 * draws an arrow from (ex, ey) -> (sx, sy).
1740 * @param w width of the image
1741 * @param h height of the image
1742 * @param stride stride/linesize of the image
1743 * @param color color of the arrow
1745 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1748 sx= clip(sx, -100, w+100);
1749 sy= clip(sy, -100, h+100);
1750 ex= clip(ex, -100, w+100);
1751 ey= clip(ey, -100, h+100);
1756 if(dx*dx + dy*dy > 3*3){
1759 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1761 //FIXME subpixel accuracy
1762 rx= ROUNDED_DIV(rx*3<<4, length);
1763 ry= ROUNDED_DIV(ry*3<<4, length);
1765 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1766 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1768 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1772 * prints debuging info for the given picture.
1774 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1776 if(!pict || !pict->mb_type) return;
1778 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1781 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1782 switch (pict->pict_type) {
1783 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1784 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1785 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1786 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1787 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1788 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1790 for(y=0; y<s->mb_height; y++){
1791 for(x=0; x<s->mb_width; x++){
1792 if(s->avctx->debug&FF_DEBUG_SKIP){
1793 int count= s->mbskip_table[x + y*s->mb_stride];
1794 if(count>9) count=9;
1795 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1797 if(s->avctx->debug&FF_DEBUG_QP){
1798 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1800 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1801 int mb_type= pict->mb_type[x + y*s->mb_stride];
1802 //Type & MV direction
1804 av_log(s->avctx, AV_LOG_DEBUG, "P");
1805 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1806 av_log(s->avctx, AV_LOG_DEBUG, "A");
1807 else if(IS_INTRA4x4(mb_type))
1808 av_log(s->avctx, AV_LOG_DEBUG, "i");
1809 else if(IS_INTRA16x16(mb_type))
1810 av_log(s->avctx, AV_LOG_DEBUG, "I");
1811 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1812 av_log(s->avctx, AV_LOG_DEBUG, "d");
1813 else if(IS_DIRECT(mb_type))
1814 av_log(s->avctx, AV_LOG_DEBUG, "D");
1815 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1816 av_log(s->avctx, AV_LOG_DEBUG, "g");
1817 else if(IS_GMC(mb_type))
1818 av_log(s->avctx, AV_LOG_DEBUG, "G");
1819 else if(IS_SKIP(mb_type))
1820 av_log(s->avctx, AV_LOG_DEBUG, "S");
1821 else if(!USES_LIST(mb_type, 1))
1822 av_log(s->avctx, AV_LOG_DEBUG, ">");
1823 else if(!USES_LIST(mb_type, 0))
1824 av_log(s->avctx, AV_LOG_DEBUG, "<");
1826 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1827 av_log(s->avctx, AV_LOG_DEBUG, "X");
1832 av_log(s->avctx, AV_LOG_DEBUG, "+");
1833 else if(IS_16X8(mb_type))
1834 av_log(s->avctx, AV_LOG_DEBUG, "-");
1835 else if(IS_8X16(mb_type))
1836 av_log(s->avctx, AV_LOG_DEBUG, "|");
1837 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1838 av_log(s->avctx, AV_LOG_DEBUG, " ");
1840 av_log(s->avctx, AV_LOG_DEBUG, "?");
1843 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1844 av_log(s->avctx, AV_LOG_DEBUG, "=");
1846 av_log(s->avctx, AV_LOG_DEBUG, " ");
1848 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1850 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1854 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1855 const int shift= 1 + s->quarter_sample;
1859 int h_chroma_shift, v_chroma_shift;
1860 const int width = s->avctx->width;
1861 const int height= s->avctx->height;
1862 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1863 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1864 s->low_delay=0; //needed to see the vectors without trashing the buffers
1866 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1868 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1869 pict->data[i]= s->visualization_buffer[i];
1871 pict->type= FF_BUFFER_TYPE_COPY;
1874 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1876 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1877 const int mb_index= mb_x + mb_y*s->mb_stride;
1878 if((s->avctx->debug_mv) && pict->motion_val){
1880 for(type=0; type<3; type++){
1883 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1887 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1891 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1896 if(!USES_LIST(pict->mb_type[mb_index], direction))
1899 if(IS_8X8(pict->mb_type[mb_index])){
1902 int sx= mb_x*16 + 4 + 8*(i&1);
1903 int sy= mb_y*16 + 4 + 8*(i>>1);
1904 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1905 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1906 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1907 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1909 }else if(IS_16X8(pict->mb_type[mb_index])){
1913 int sy=mb_y*16 + 4 + 8*i;
1914 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1915 int mx=(pict->motion_val[direction][xy][0]>>shift);
1916 int my=(pict->motion_val[direction][xy][1]>>shift);
1918 if(IS_INTERLACED(pict->mb_type[mb_index]))
1921 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1923 }else if(IS_8X16(pict->mb_type[mb_index])){
1926 int sx=mb_x*16 + 4 + 8*i;
1928 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1929 int mx=(pict->motion_val[direction][xy][0]>>shift);
1930 int my=(pict->motion_val[direction][xy][1]>>shift);
1932 if(IS_INTERLACED(pict->mb_type[mb_index]))
1935 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1938 int sx= mb_x*16 + 8;
1939 int sy= mb_y*16 + 8;
1940 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1941 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1942 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1943 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1947 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1948 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1951 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1952 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1955 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1956 int mb_type= pict->mb_type[mb_index];
1959 #define COLOR(theta, r)\
1960 u= (int)(128 + r*cos(theta*3.141592/180));\
1961 v= (int)(128 + r*sin(theta*3.141592/180));
1965 if(IS_PCM(mb_type)){
1967 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1969 }else if(IS_INTRA4x4(mb_type)){
1971 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1973 }else if(IS_DIRECT(mb_type)){
1975 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1977 }else if(IS_GMC(mb_type)){
1979 }else if(IS_SKIP(mb_type)){
1981 }else if(!USES_LIST(mb_type, 1)){
1983 }else if(!USES_LIST(mb_type, 0)){
1986 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1990 u*= 0x0101010101010101ULL;
1991 v*= 0x0101010101010101ULL;
1993 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1994 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1998 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1999 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2000 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2002 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2004 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2006 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2007 int dm= 1 << (mv_sample_log2-2);
2009 int sx= mb_x*16 + 8*(i&1);
2010 int sy= mb_y*16 + 8*(i>>1);
2011 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2013 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2014 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2016 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2017 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2018 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2022 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2026 s->mbskip_table[mb_index]=0;
2032 #ifdef CONFIG_ENCODERS
2034 static int get_sae(uint8_t *src, int ref, int stride){
2038 for(y=0; y<16; y++){
2039 for(x=0; x<16; x++){
2040 acc+= FFABS(src[x+y*stride] - ref);
2047 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2054 for(y=0; y<h; y+=16){
2055 for(x=0; x<w; x+=16){
2056 int offset= x + y*stride;
2057 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2058 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2059 int sae = get_sae(src + offset, mean, stride);
2061 acc+= sae + 500 < sad;
2068 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2072 const int encoding_delay= s->max_b_frames;
2077 pic_arg->display_picture_number= s->input_picture_number++;
2079 if(pts != AV_NOPTS_VALUE){
2080 if(s->user_specified_pts != AV_NOPTS_VALUE){
2082 int64_t last= s->user_specified_pts;
2085 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2089 s->user_specified_pts= pts;
2091 if(s->user_specified_pts != AV_NOPTS_VALUE){
2092 s->user_specified_pts=
2093 pts= s->user_specified_pts + 1;
2094 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2096 pts= pic_arg->display_picture_number;
2102 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2103 if(pic_arg->linesize[0] != s->linesize) direct=0;
2104 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2105 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2107 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2110 i= ff_find_unused_picture(s, 1);
2112 pic= (AVFrame*)&s->picture[i];
2116 pic->data[i]= pic_arg->data[i];
2117 pic->linesize[i]= pic_arg->linesize[i];
2119 alloc_picture(s, (Picture*)pic, 1);
2121 i= ff_find_unused_picture(s, 0);
2123 pic= (AVFrame*)&s->picture[i];
2126 alloc_picture(s, (Picture*)pic, 0);
2128 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2129 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2130 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2133 int h_chroma_shift, v_chroma_shift;
2134 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2137 int src_stride= pic_arg->linesize[i];
2138 int dst_stride= i ? s->uvlinesize : s->linesize;
2139 int h_shift= i ? h_chroma_shift : 0;
2140 int v_shift= i ? v_chroma_shift : 0;
2141 int w= s->width >>h_shift;
2142 int h= s->height>>v_shift;
2143 uint8_t *src= pic_arg->data[i];
2144 uint8_t *dst= pic->data[i];
2146 if(!s->avctx->rc_buffer_size)
2147 dst +=INPLACE_OFFSET;
2149 if(src_stride==dst_stride)
2150 memcpy(dst, src, src_stride*h);
2153 memcpy(dst, src, w);
2161 copy_picture_attributes(s, pic, pic_arg);
2162 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2165 /* shift buffer entries */
2166 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2167 s->input_picture[i-1]= s->input_picture[i];
2169 s->input_picture[encoding_delay]= (Picture*)pic;
2174 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2179 for(plane=0; plane<3; plane++){
2180 const int stride= p->linesize[plane];
2181 const int bw= plane ? 1 : 2;
2182 for(y=0; y<s->mb_height*bw; y++){
2183 for(x=0; x<s->mb_width*bw; x++){
2184 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2185 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);
2187 switch(s->avctx->frame_skip_exp){
2188 case 0: score= FFMAX(score, v); break;
2189 case 1: score+= FFABS(v);break;
2190 case 2: score+= v*v;break;
2191 case 3: score64+= FFABS(v*v*(int64_t)v);break;
2192 case 4: score64+= v*v*(int64_t)(v*v);break;
2198 if(score) score64= score;
2200 if(score64 < s->avctx->frame_skip_threshold)
2202 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2207 static int estimate_best_b_count(MpegEncContext *s){
2208 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2209 AVCodecContext *c= avcodec_alloc_context();
2210 AVFrame input[FF_MAX_B_FRAMES+2];
2211 const int scale= s->avctx->brd_scale;
2212 int i, j, out_size, p_lambda, b_lambda, lambda2;
2213 int outbuf_size= s->width * s->height; //FIXME
2214 uint8_t *outbuf= av_malloc(outbuf_size);
2215 int64_t best_rd= INT64_MAX;
2216 int best_b_count= -1;
2218 assert(scale>=0 && scale <=3);
2221 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2222 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2223 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2224 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2226 c->width = s->width >> scale;
2227 c->height= s->height>> scale;
2228 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2229 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2230 c->mb_decision= s->avctx->mb_decision;
2231 c->me_cmp= s->avctx->me_cmp;
2232 c->mb_cmp= s->avctx->mb_cmp;
2233 c->me_sub_cmp= s->avctx->me_sub_cmp;
2234 c->pix_fmt = PIX_FMT_YUV420P;
2235 c->time_base= s->avctx->time_base;
2236 c->max_b_frames= s->max_b_frames;
2238 if (avcodec_open(c, codec) < 0)
2241 for(i=0; i<s->max_b_frames+2; i++){
2242 int ysize= c->width*c->height;
2243 int csize= (c->width/2)*(c->height/2);
2244 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2247 pre_input= *pre_input_ptr;
2249 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2250 pre_input.data[0]+=INPLACE_OFFSET;
2251 pre_input.data[1]+=INPLACE_OFFSET;
2252 pre_input.data[2]+=INPLACE_OFFSET;
2255 avcodec_get_frame_defaults(&input[i]);
2256 input[i].data[0]= av_malloc(ysize + 2*csize);
2257 input[i].data[1]= input[i].data[0] + ysize;
2258 input[i].data[2]= input[i].data[1] + csize;
2259 input[i].linesize[0]= c->width;
2260 input[i].linesize[1]=
2261 input[i].linesize[2]= c->width/2;
2263 if(!i || s->input_picture[i-1]){
2264 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2265 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);
2266 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);
2270 for(j=0; j<s->max_b_frames+1; j++){
2273 if(!s->input_picture[j])
2276 c->error[0]= c->error[1]= c->error[2]= 0;
2278 input[0].pict_type= I_TYPE;
2279 input[0].quality= 1 * FF_QP2LAMBDA;
2280 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2281 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2283 for(i=0; i<s->max_b_frames+1; i++){
2284 int is_p= i % (j+1) == j || i==s->max_b_frames;
2286 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2287 input[i+1].quality= is_p ? p_lambda : b_lambda;
2288 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2289 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2292 /* get the delayed frames */
2294 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2295 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2298 rd += c->error[0] + c->error[1] + c->error[2];
2310 for(i=0; i<s->max_b_frames+2; i++){
2311 av_freep(&input[i].data[0]);
2314 return best_b_count;
2317 static void select_input_picture(MpegEncContext *s){
2320 for(i=1; i<MAX_PICTURE_COUNT; i++)
2321 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2322 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2324 /* set next picture type & ordering */
2325 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2326 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2327 s->reordered_input_picture[0]= s->input_picture[0];
2328 s->reordered_input_picture[0]->pict_type= I_TYPE;
2329 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2333 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2334 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2335 //FIXME check that te gop check above is +-1 correct
2336 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2338 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2340 s->input_picture[0]->data[i]= NULL;
2341 s->input_picture[0]->type= 0;
2343 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2344 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2346 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2350 ff_vbv_update(s, 0);
2356 if(s->flags&CODEC_FLAG_PASS2){
2357 for(i=0; i<s->max_b_frames+1; i++){
2358 int pict_num= s->input_picture[0]->display_picture_number + i;
2360 if(pict_num >= s->rc_context.num_entries)
2362 if(!s->input_picture[i]){
2363 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2367 s->input_picture[i]->pict_type=
2368 s->rc_context.entry[pict_num].new_pict_type;
2372 if(s->avctx->b_frame_strategy==0){
2373 b_frames= s->max_b_frames;
2374 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2375 }else if(s->avctx->b_frame_strategy==1){
2376 for(i=1; i<s->max_b_frames+1; i++){
2377 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2378 s->input_picture[i]->b_frame_score=
2379 get_intra_count(s, s->input_picture[i ]->data[0],
2380 s->input_picture[i-1]->data[0], s->linesize) + 1;
2383 for(i=0; i<s->max_b_frames+1; i++){
2384 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2387 b_frames= FFMAX(0, i-1);
2390 for(i=0; i<b_frames+1; i++){
2391 s->input_picture[i]->b_frame_score=0;
2393 }else if(s->avctx->b_frame_strategy==2){
2394 b_frames= estimate_best_b_count(s);
2396 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2401 //static int b_count=0;
2402 //b_count+= b_frames;
2403 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2405 for(i= b_frames - 1; i>=0; i--){
2406 int type= s->input_picture[i]->pict_type;
2407 if(type && type != B_TYPE)
2410 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2411 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2414 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2415 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2416 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2418 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2420 s->input_picture[b_frames]->pict_type= I_TYPE;
2424 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2426 && s->input_picture[b_frames]->pict_type== I_TYPE)
2429 s->reordered_input_picture[0]= s->input_picture[b_frames];
2430 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2431 s->reordered_input_picture[0]->pict_type= P_TYPE;
2432 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2433 for(i=0; i<b_frames; i++){
2434 s->reordered_input_picture[i+1]= s->input_picture[i];
2435 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2436 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2441 if(s->reordered_input_picture[0]){
2442 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2444 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2446 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
2447 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2449 int i= ff_find_unused_picture(s, 0);
2450 Picture *pic= &s->picture[i];
2452 pic->reference = s->reordered_input_picture[0]->reference;
2453 alloc_picture(s, pic, 0);
2455 /* mark us unused / free shared pic */
2456 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2457 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2459 s->reordered_input_picture[0]->data[i]= NULL;
2460 s->reordered_input_picture[0]->type= 0;
2462 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2464 s->current_picture_ptr= pic;
2466 // input is not a shared pix -> reuse buffer for current_pix
2468 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2469 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2471 s->current_picture_ptr= s->reordered_input_picture[0];
2473 s->new_picture.data[i]+= INPLACE_OFFSET;
2476 copy_picture(&s->current_picture, s->current_picture_ptr);
2478 s->picture_number= s->new_picture.display_picture_number;
2479 //printf("dpn:%d\n", s->picture_number);
2481 memset(&s->new_picture, 0, sizeof(Picture));
2485 int MPV_encode_picture(AVCodecContext *avctx,
2486 unsigned char *buf, int buf_size, void *data)
2488 MpegEncContext *s = avctx->priv_data;
2489 AVFrame *pic_arg = data;
2490 int i, stuffing_count;
2492 for(i=0; i<avctx->thread_count; i++){
2493 int start_y= s->thread_context[i]->start_mb_y;
2494 int end_y= s->thread_context[i]-> end_mb_y;
2495 int h= s->mb_height;
2496 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2497 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2499 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2502 s->picture_in_gop_number++;
2504 if(load_input_picture(s, pic_arg) < 0)
2507 select_input_picture(s);
2510 if(s->new_picture.data[0]){
2511 s->pict_type= s->new_picture.pict_type;
2513 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2514 MPV_frame_start(s, avctx);
2516 if (encode_picture(s, s->picture_number) < 0)
2519 avctx->real_pict_num = s->picture_number;
2520 avctx->header_bits = s->header_bits;
2521 avctx->mv_bits = s->mv_bits;
2522 avctx->misc_bits = s->misc_bits;
2523 avctx->i_tex_bits = s->i_tex_bits;
2524 avctx->p_tex_bits = s->p_tex_bits;
2525 avctx->i_count = s->i_count;
2526 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2527 avctx->skip_count = s->skip_count;
2531 if (s->out_format == FMT_MJPEG)
2532 mjpeg_picture_trailer(s);
2534 if(avctx->rc_buffer_size){
2535 RateControlContext *rcc= &s->rc_context;
2536 int max_size= rcc->buffer_index/3;
2538 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2539 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2540 s->mb_skipped = 0; //done in MPV_frame_start()
2541 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2542 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2543 s->no_rounding ^= 1;
2545 if(s->pict_type!=B_TYPE){
2546 s->time_base= s->last_time_base;
2547 s->last_non_b_time= s->time - s->pp_time;
2549 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2550 for(i=0; i<avctx->thread_count; i++){
2551 PutBitContext *pb= &s->thread_context[i]->pb;
2552 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2557 assert(s->avctx->rc_max_rate);
2560 if(s->flags&CODEC_FLAG_PASS1)
2561 ff_write_pass1_stats(s);
2564 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2565 avctx->error[i] += s->current_picture_ptr->error[i];
2568 if(s->flags&CODEC_FLAG_PASS1)
2569 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2570 flush_put_bits(&s->pb);
2571 s->frame_bits = put_bits_count(&s->pb);
2573 stuffing_count= ff_vbv_update(s, s->frame_bits);
2575 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2576 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2580 switch(s->codec_id){
2581 case CODEC_ID_MPEG1VIDEO:
2582 case CODEC_ID_MPEG2VIDEO:
2583 while(stuffing_count--){
2584 put_bits(&s->pb, 8, 0);
2587 case CODEC_ID_MPEG4:
2588 put_bits(&s->pb, 16, 0);
2589 put_bits(&s->pb, 16, 0x1C3);
2590 stuffing_count -= 4;
2591 while(stuffing_count--){
2592 put_bits(&s->pb, 8, 0xFF);
2596 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2598 flush_put_bits(&s->pb);
2599 s->frame_bits = put_bits_count(&s->pb);
2602 /* update mpeg1/2 vbv_delay for CBR */
2603 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2604 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2607 assert(s->repeat_first_field==0);
2609 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2610 assert(vbv_delay < 0xFFFF);
2612 s->vbv_delay_ptr[0] &= 0xF8;
2613 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2614 s->vbv_delay_ptr[1] = vbv_delay>>5;
2615 s->vbv_delay_ptr[2] &= 0x07;
2616 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2618 s->total_bits += s->frame_bits;
2619 avctx->frame_bits = s->frame_bits;
2621 assert((pbBufPtr(&s->pb) == s->pb.buf));
2624 assert((s->frame_bits&7)==0);
2626 return s->frame_bits/8;
2629 #endif //CONFIG_ENCODERS
2631 static inline void gmc1_motion(MpegEncContext *s,
2632 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2633 uint8_t **ref_picture)
2636 int offset, src_x, src_y, linesize, uvlinesize;
2637 int motion_x, motion_y;
2640 motion_x= s->sprite_offset[0][0];
2641 motion_y= s->sprite_offset[0][1];
2642 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2643 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2644 motion_x<<=(3-s->sprite_warping_accuracy);
2645 motion_y<<=(3-s->sprite_warping_accuracy);
2646 src_x = clip(src_x, -16, s->width);
2647 if (src_x == s->width)
2649 src_y = clip(src_y, -16, s->height);
2650 if (src_y == s->height)
2653 linesize = s->linesize;
2654 uvlinesize = s->uvlinesize;
2656 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2658 if(s->flags&CODEC_FLAG_EMU_EDGE){
2659 if( (unsigned)src_x >= s->h_edge_pos - 17
2660 || (unsigned)src_y >= s->v_edge_pos - 17){
2661 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2662 ptr= s->edge_emu_buffer;
2666 if((motion_x|motion_y)&7){
2667 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2668 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2672 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2673 if (s->no_rounding){
2674 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2676 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2680 if(s->flags&CODEC_FLAG_GRAY) return;
2682 motion_x= s->sprite_offset[1][0];
2683 motion_y= s->sprite_offset[1][1];
2684 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2685 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2686 motion_x<<=(3-s->sprite_warping_accuracy);
2687 motion_y<<=(3-s->sprite_warping_accuracy);
2688 src_x = clip(src_x, -8, s->width>>1);
2689 if (src_x == s->width>>1)
2691 src_y = clip(src_y, -8, s->height>>1);
2692 if (src_y == s->height>>1)
2695 offset = (src_y * uvlinesize) + src_x;
2696 ptr = ref_picture[1] + offset;
2697 if(s->flags&CODEC_FLAG_EMU_EDGE){
2698 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2699 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2700 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);
2701 ptr= s->edge_emu_buffer;
2705 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2707 ptr = ref_picture[2] + offset;
2709 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);
2710 ptr= s->edge_emu_buffer;
2712 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2717 static inline void gmc_motion(MpegEncContext *s,
2718 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2719 uint8_t **ref_picture)
2722 int linesize, uvlinesize;
2723 const int a= s->sprite_warping_accuracy;
2726 linesize = s->linesize;
2727 uvlinesize = s->uvlinesize;
2729 ptr = ref_picture[0];
2731 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2732 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2734 s->dsp.gmc(dest_y, ptr, linesize, 16,
2737 s->sprite_delta[0][0], s->sprite_delta[0][1],
2738 s->sprite_delta[1][0], s->sprite_delta[1][1],
2739 a+1, (1<<(2*a+1)) - s->no_rounding,
2740 s->h_edge_pos, s->v_edge_pos);
2741 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2742 ox + s->sprite_delta[0][0]*8,
2743 oy + s->sprite_delta[1][0]*8,
2744 s->sprite_delta[0][0], s->sprite_delta[0][1],
2745 s->sprite_delta[1][0], s->sprite_delta[1][1],
2746 a+1, (1<<(2*a+1)) - s->no_rounding,
2747 s->h_edge_pos, s->v_edge_pos);
2749 if(s->flags&CODEC_FLAG_GRAY) return;
2751 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2752 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2754 ptr = ref_picture[1];
2755 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2758 s->sprite_delta[0][0], s->sprite_delta[0][1],
2759 s->sprite_delta[1][0], s->sprite_delta[1][1],
2760 a+1, (1<<(2*a+1)) - s->no_rounding,
2761 s->h_edge_pos>>1, s->v_edge_pos>>1);
2763 ptr = ref_picture[2];
2764 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2767 s->sprite_delta[0][0], s->sprite_delta[0][1],
2768 s->sprite_delta[1][0], s->sprite_delta[1][1],
2769 a+1, (1<<(2*a+1)) - s->no_rounding,
2770 s->h_edge_pos>>1, s->v_edge_pos>>1);
2774 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2775 * @param buf destination buffer
2776 * @param src source buffer
2777 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2778 * @param block_w width of block
2779 * @param block_h height of block
2780 * @param src_x x coordinate of the top left sample of the block in the source buffer
2781 * @param src_y y coordinate of the top left sample of the block in the source buffer
2782 * @param w width of the source buffer
2783 * @param h height of the source buffer
2785 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2786 int src_x, int src_y, int w, int h){
2788 int start_y, start_x, end_y, end_x;
2791 src+= (h-1-src_y)*linesize;
2793 }else if(src_y<=-block_h){
2794 src+= (1-block_h-src_y)*linesize;
2800 }else if(src_x<=-block_w){
2801 src+= (1-block_w-src_x);
2805 start_y= FFMAX(0, -src_y);
2806 start_x= FFMAX(0, -src_x);
2807 end_y= FFMIN(block_h, h-src_y);
2808 end_x= FFMIN(block_w, w-src_x);
2810 // copy existing part
2811 for(y=start_y; y<end_y; y++){
2812 for(x=start_x; x<end_x; x++){
2813 buf[x + y*linesize]= src[x + y*linesize];
2818 for(y=0; y<start_y; y++){
2819 for(x=start_x; x<end_x; x++){
2820 buf[x + y*linesize]= buf[x + start_y*linesize];
2825 for(y=end_y; y<block_h; y++){
2826 for(x=start_x; x<end_x; x++){
2827 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2831 for(y=0; y<block_h; y++){
2833 for(x=0; x<start_x; x++){
2834 buf[x + y*linesize]= buf[start_x + y*linesize];
2838 for(x=end_x; x<block_w; x++){
2839 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2844 static inline int hpel_motion(MpegEncContext *s,
2845 uint8_t *dest, uint8_t *src,
2846 int field_based, int field_select,
2847 int src_x, int src_y,
2848 int width, int height, int stride,
2849 int h_edge_pos, int v_edge_pos,
2850 int w, int h, op_pixels_func *pix_op,
2851 int motion_x, int motion_y)
2856 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2857 src_x += motion_x >> 1;
2858 src_y += motion_y >> 1;
2860 /* WARNING: do no forget half pels */
2861 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2864 src_y = clip(src_y, -16, height);
2865 if (src_y == height)
2867 src += src_y * stride + src_x;
2869 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2870 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2871 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2872 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2873 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2874 src= s->edge_emu_buffer;
2880 pix_op[dxy](dest, src, stride, h);
2884 static inline int hpel_motion_lowres(MpegEncContext *s,
2885 uint8_t *dest, uint8_t *src,
2886 int field_based, int field_select,
2887 int src_x, int src_y,
2888 int width, int height, int stride,
2889 int h_edge_pos, int v_edge_pos,
2890 int w, int h, h264_chroma_mc_func *pix_op,
2891 int motion_x, int motion_y)
2893 const int lowres= s->avctx->lowres;
2894 const int s_mask= (2<<lowres)-1;
2898 if(s->quarter_sample){
2903 sx= motion_x & s_mask;
2904 sy= motion_y & s_mask;
2905 src_x += motion_x >> (lowres+1);
2906 src_y += motion_y >> (lowres+1);
2908 src += src_y * stride + src_x;
2910 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2911 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2912 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2913 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2914 src= s->edge_emu_buffer;
2922 pix_op[lowres](dest, src, stride, h, sx, sy);
2926 /* apply one mpeg motion vector to the three components */
2927 static always_inline void mpeg_motion(MpegEncContext *s,
2928 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2929 int field_based, int bottom_field, int field_select,
2930 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2931 int motion_x, int motion_y, int h)
2933 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2934 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2937 if(s->quarter_sample)
2944 v_edge_pos = s->v_edge_pos >> field_based;
2945 linesize = s->current_picture.linesize[0] << field_based;
2946 uvlinesize = s->current_picture.linesize[1] << field_based;
2948 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2949 src_x = s->mb_x* 16 + (motion_x >> 1);
2950 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2952 if (s->out_format == FMT_H263) {
2953 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2954 mx = (motion_x>>1)|(motion_x&1);
2956 uvdxy = ((my & 1) << 1) | (mx & 1);
2957 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2958 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2960 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2964 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2968 uvsrc_x = s->mb_x*8 + mx;
2969 uvsrc_y = s->mb_y*8 + my;
2971 if(s->chroma_y_shift){
2974 uvdxy = ((my & 1) << 1) | (mx & 1);
2975 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2976 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2978 if(s->chroma_x_shift){
2981 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2982 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2993 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2994 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2995 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2997 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2998 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2999 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3000 s->codec_id == CODEC_ID_MPEG1VIDEO){
3001 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3004 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3005 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3006 ptr_y = s->edge_emu_buffer;
3007 if(!(s->flags&CODEC_FLAG_GRAY)){
3008 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3009 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3010 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3011 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3012 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3018 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3019 dest_y += s->linesize;
3020 dest_cb+= s->uvlinesize;
3021 dest_cr+= s->uvlinesize;
3025 ptr_y += s->linesize;
3026 ptr_cb+= s->uvlinesize;
3027 ptr_cr+= s->uvlinesize;
3030 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3032 if(!(s->flags&CODEC_FLAG_GRAY)){
3033 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3034 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3036 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3037 if(s->out_format == FMT_H261){
3038 ff_h261_loop_filter(s);
3043 /* apply one mpeg motion vector to the three components */
3044 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3045 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3046 int field_based, int bottom_field, int field_select,
3047 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3048 int motion_x, int motion_y, int h)
3050 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3051 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3052 const int lowres= s->avctx->lowres;
3053 const int block_s= 8>>lowres;
3054 const int s_mask= (2<<lowres)-1;
3055 const int h_edge_pos = s->h_edge_pos >> lowres;
3056 const int v_edge_pos = s->v_edge_pos >> lowres;
3057 linesize = s->current_picture.linesize[0] << field_based;
3058 uvlinesize = s->current_picture.linesize[1] << field_based;
3060 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3066 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3069 sx= motion_x & s_mask;
3070 sy= motion_y & s_mask;
3071 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3072 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3074 if (s->out_format == FMT_H263) {
3075 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3076 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3079 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3082 uvsx = (2*mx) & s_mask;
3083 uvsy = (2*my) & s_mask;
3084 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3085 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3091 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3092 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3095 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3096 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3097 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3099 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3100 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3101 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3102 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3103 ptr_y = s->edge_emu_buffer;
3104 if(!(s->flags&CODEC_FLAG_GRAY)){
3105 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3106 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3107 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3108 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3109 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3115 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3116 dest_y += s->linesize;
3117 dest_cb+= s->uvlinesize;
3118 dest_cr+= s->uvlinesize;
3122 ptr_y += s->linesize;
3123 ptr_cb+= s->uvlinesize;
3124 ptr_cr+= s->uvlinesize;
3129 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3131 if(!(s->flags&CODEC_FLAG_GRAY)){
3132 uvsx <<= 2 - lowres;
3133 uvsy <<= 2 - lowres;
3134 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3135 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3137 //FIXME h261 lowres loop filter
3140 //FIXME move to dsputil, avg variant, 16x16 version
3141 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3143 uint8_t * const top = src[1];
3144 uint8_t * const left = src[2];
3145 uint8_t * const mid = src[0];
3146 uint8_t * const right = src[3];
3147 uint8_t * const bottom= src[4];
3148 #define OBMC_FILTER(x, t, l, m, r, b)\
3149 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3150 #define OBMC_FILTER4(x, t, l, m, r, b)\
3151 OBMC_FILTER(x , t, l, m, r, b);\
3152 OBMC_FILTER(x+1 , t, l, m, r, b);\
3153 OBMC_FILTER(x +stride, t, l, m, r, b);\
3154 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3157 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3158 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3159 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3160 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3161 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3162 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3164 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3165 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3166 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3167 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3169 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3170 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3171 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3172 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3174 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3175 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3176 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3177 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3179 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3180 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3181 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3182 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3183 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3184 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3186 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3187 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3188 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3189 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3192 /* obmc for 1 8x8 luma block */
3193 static inline void obmc_motion(MpegEncContext *s,
3194 uint8_t *dest, uint8_t *src,
3195 int src_x, int src_y,
3196 op_pixels_func *pix_op,
3197 int16_t mv[5][2]/* mid top left right bottom*/)
3203 assert(s->quarter_sample==0);
3206 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3209 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3210 hpel_motion(s, ptr[i], src, 0, 0,
3212 s->width, s->height, s->linesize,
3213 s->h_edge_pos, s->v_edge_pos,
3215 mv[i][0], mv[i][1]);
3219 put_obmc(dest, ptr, s->linesize);
3222 static inline void qpel_motion(MpegEncContext *s,
3223 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3224 int field_based, int bottom_field, int field_select,
3225 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3226 qpel_mc_func (*qpix_op)[16],
3227 int motion_x, int motion_y, int h)
3229 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3230 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3232 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3233 src_x = s->mb_x * 16 + (motion_x >> 2);
3234 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3236 v_edge_pos = s->v_edge_pos >> field_based;
3237 linesize = s->linesize << field_based;
3238 uvlinesize = s->uvlinesize << field_based;
3243 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3244 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3245 mx= (motion_x>>1) + rtab[motion_x&7];
3246 my= (motion_y>>1) + rtab[motion_y&7];
3247 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3248 mx= (motion_x>>1)|(motion_x&1);
3249 my= (motion_y>>1)|(motion_y&1);
3257 uvdxy= (mx&1) | ((my&1)<<1);
3261 uvsrc_x = s->mb_x * 8 + mx;
3262 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3264 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3265 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3266 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3268 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3269 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3270 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3271 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3272 ptr_y= s->edge_emu_buffer;
3273 if(!(s->flags&CODEC_FLAG_GRAY)){
3274 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3275 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3276 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3277 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3278 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3285 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3288 dest_y += s->linesize;
3289 dest_cb+= s->uvlinesize;
3290 dest_cr+= s->uvlinesize;
3294 ptr_y += s->linesize;
3295 ptr_cb += s->uvlinesize;
3296 ptr_cr += s->uvlinesize;
3298 //damn interlaced mode
3299 //FIXME boundary mirroring is not exactly correct here
3300 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3301 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3303 if(!(s->flags&CODEC_FLAG_GRAY)){
3304 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3305 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3309 inline int ff_h263_round_chroma(int x){
3311 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3314 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3319 * h263 chorma 4mv motion compensation.
3321 static inline void chroma_4mv_motion(MpegEncContext *s,
3322 uint8_t *dest_cb, uint8_t *dest_cr,
3323 uint8_t **ref_picture,
3324 op_pixels_func *pix_op,
3326 int dxy, emu=0, src_x, src_y, offset;
3329 /* In case of 8X8, we construct a single chroma motion vector
3330 with a special rounding */
3331 mx= ff_h263_round_chroma(mx);
3332 my= ff_h263_round_chroma(my);
3334 dxy = ((my & 1) << 1) | (mx & 1);
3338 src_x = s->mb_x * 8 + mx;
3339 src_y = s->mb_y * 8 + my;
3340 src_x = clip(src_x, -8, s->width/2);
3341 if (src_x == s->width/2)
3343 src_y = clip(src_y, -8, s->height/2);
3344 if (src_y == s->height/2)
3347 offset = (src_y * (s->uvlinesize)) + src_x;
3348 ptr = ref_picture[1] + offset;
3349 if(s->flags&CODEC_FLAG_EMU_EDGE){
3350 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3351 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3352 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);
3353 ptr= s->edge_emu_buffer;
3357 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3359 ptr = ref_picture[2] + offset;
3361 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);
3362 ptr= s->edge_emu_buffer;
3364 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3367 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3368 uint8_t *dest_cb, uint8_t *dest_cr,
3369 uint8_t **ref_picture,
3370 h264_chroma_mc_func *pix_op,
3372 const int lowres= s->avctx->lowres;
3373 const int block_s= 8>>lowres;
3374 const int s_mask= (2<<lowres)-1;
3375 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3376 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3377 int emu=0, src_x, src_y, offset, sx, sy;
3380 if(s->quarter_sample){
3385 /* In case of 8X8, we construct a single chroma motion vector
3386 with a special rounding */
3387 mx= ff_h263_round_chroma(mx);
3388 my= ff_h263_round_chroma(my);
3392 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3393 src_y = s->mb_y*block_s + (my >> (lowres+1));
3395 offset = src_y * s->uvlinesize + src_x;
3396 ptr = ref_picture[1] + offset;
3397 if(s->flags&CODEC_FLAG_EMU_EDGE){
3398 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3399 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3400 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3401 ptr= s->edge_emu_buffer;
3407 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3409 ptr = ref_picture[2] + offset;
3411 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3412 ptr= s->edge_emu_buffer;
3414 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3417 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3418 /* fetch pixels for estimated mv 4 macroblocks ahead
3419 * optimized for 64byte cache lines */
3420 const int shift = s->quarter_sample ? 2 : 1;
3421 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3422 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3423 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3424 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3425 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3426 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3430 * motion compensation of a single macroblock
3432 * @param dest_y luma destination pointer
3433 * @param dest_cb chroma cb/u destination pointer
3434 * @param dest_cr chroma cr/v destination pointer
3435 * @param dir direction (0->forward, 1->backward)
3436 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3437 * @param pic_op halfpel motion compensation function (average or put normally)
3438 * @param pic_op qpel motion compensation function (average or put normally)
3439 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3441 static inline void MPV_motion(MpegEncContext *s,
3442 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3443 int dir, uint8_t **ref_picture,
3444 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3446 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3448 uint8_t *ptr, *dest;
3453 prefetch_motion(s, ref_picture, dir);
3455 if(s->obmc && s->pict_type != B_TYPE){
3456 int16_t mv_cache[4][4][2];
3457 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3458 const int mot_stride= s->b8_stride;
3459 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3461 assert(!s->mb_skipped);
3463 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3464 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3465 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3467 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3468 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3470 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3473 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3474 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3475 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3477 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3478 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3481 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3482 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3483 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3485 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3486 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3492 const int x= (i&1)+1;
3493 const int y= (i>>1)+1;
3495 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3496 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3497 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3498 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3499 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3501 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3503 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3510 if(!(s->flags&CODEC_FLAG_GRAY))
3511 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3516 switch(s->mv_type) {