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"
39 #include "libvo/fastmemcpy.h"
45 #ifdef CONFIG_ENCODERS
46 static int encode_picture(MpegEncContext *s, int picture_number);
47 #endif //CONFIG_ENCODERS
48 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
59 DCTELEM *block, int n, int qscale);
60 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
61 DCTELEM *block, int n, int qscale);
62 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
63 #ifdef CONFIG_ENCODERS
64 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
65 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
66 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
67 static int sse_mb(MpegEncContext *s);
68 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
69 #endif //CONFIG_ENCODERS
72 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
73 extern void XVMC_field_end(MpegEncContext *s);
74 extern void XVMC_decode_mb(MpegEncContext *s);
77 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
80 /* enable all paranoid tests for rounding, overflows, etc... */
86 /* for jpeg fast DCT */
89 static const uint16_t aanscales[64] = {
90 /* precomputed values scaled up by 14 bits */
91 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
92 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
93 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
94 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
95 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
96 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
97 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
98 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
101 static const uint8_t h263_chroma_roundtab[16] = {
102 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
103 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
106 static const uint8_t ff_default_chroma_qscale_table[32]={
107 // 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
108 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
111 #ifdef CONFIG_ENCODERS
112 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
113 static uint8_t default_fcode_tab[MAX_MV*2+1];
115 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
117 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
118 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
123 for(qscale=qmin; qscale<=qmax; qscale++){
125 if (dsp->fdct == ff_jpeg_fdct_islow
126 #ifdef FAAN_POSTSCALE
127 || dsp->fdct == ff_faandct
131 const int j= dsp->idct_permutation[i];
132 /* 16 <= qscale * quant_matrix[i] <= 7905 */
133 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
134 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
135 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
137 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
138 (qscale * quant_matrix[j]));
140 } else if (dsp->fdct == fdct_ifast
141 #ifndef FAAN_POSTSCALE
142 || dsp->fdct == ff_faandct
146 const int j= dsp->idct_permutation[i];
147 /* 16 <= qscale * quant_matrix[i] <= 7905 */
148 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
149 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
150 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
152 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
153 (aanscales[i] * qscale * quant_matrix[j]));
157 const int j= dsp->idct_permutation[i];
158 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
159 So 16 <= qscale * quant_matrix[i] <= 7905
160 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
161 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
163 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
164 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
165 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
167 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
168 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
172 for(i=intra; i<64; i++){
174 if (dsp->fdct == fdct_ifast
175 #ifndef FAAN_POSTSCALE
176 || dsp->fdct == ff_faandct
179 max= (8191LL*aanscales[i]) >> 14;
181 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
187 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
191 static inline void update_qscale(MpegEncContext *s){
192 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
193 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
195 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
197 #endif //CONFIG_ENCODERS
199 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
203 st->scantable= src_scantable;
207 j = src_scantable[i];
208 st->permutated[i] = permutation[j];
217 j = st->permutated[i];
219 st->raster_end[i]= end;
223 #ifdef CONFIG_ENCODERS
224 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
230 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
235 #endif //CONFIG_ENCODERS
237 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
245 uint32_t tmp= *state << 8;
246 *state= tmp + *(p++);
247 if(tmp == 0x100 || p==end)
252 if (p[-1] > 1 ) p+= 3;
253 else if(p[-2] ) p+= 2;
254 else if(p[-3]|(p[-1]-1)) p++;
262 *state= be2me_32(unaligned32(p));
267 /* init common dct for both encoder and decoder */
268 int DCT_common_init(MpegEncContext *s)
270 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
271 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
272 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
273 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
274 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
275 if(s->flags & CODEC_FLAG_BITEXACT)
276 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
277 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
279 #ifdef CONFIG_ENCODERS
280 s->dct_quantize= dct_quantize_c;
281 s->denoise_dct= denoise_dct_c;
282 #endif //CONFIG_ENCODERS
285 MPV_common_init_mmx(s);
288 MPV_common_init_axp(s);
291 MPV_common_init_mlib(s);
294 MPV_common_init_mmi(s);
297 MPV_common_init_armv4l(s);
300 MPV_common_init_ppc(s);
303 #ifdef CONFIG_ENCODERS
304 s->fast_dct_quantize= s->dct_quantize;
306 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
307 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
310 #endif //CONFIG_ENCODERS
312 /* load & permutate scantables
313 note: only wmv uses different ones
315 if(s->alternate_scan){
316 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
317 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
319 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
320 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
322 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
323 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
328 static void copy_picture(Picture *dst, Picture *src){
330 dst->type= FF_BUFFER_TYPE_COPY;
333 #ifdef CONFIG_ENCODERS
334 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
337 dst->pict_type = src->pict_type;
338 dst->quality = src->quality;
339 dst->coded_picture_number = src->coded_picture_number;
340 dst->display_picture_number = src->display_picture_number;
341 // dst->reference = src->reference;
343 dst->interlaced_frame = src->interlaced_frame;
344 dst->top_field_first = src->top_field_first;
346 if(s->avctx->me_threshold){
347 if(!src->motion_val[0])
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
351 if(!src->ref_index[0])
352 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
353 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
354 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
355 src->motion_subsample_log2, dst->motion_subsample_log2);
357 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
360 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
361 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
363 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
364 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
366 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
367 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
375 * allocates a Picture
376 * The pixels are allocated/set by calling get_buffer() if shared=0
378 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
379 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
380 const int mb_array_size= s->mb_stride*s->mb_height;
381 const int b8_array_size= s->b8_stride*s->mb_height*2;
382 const int b4_array_size= s->b4_stride*s->mb_height*4;
386 assert(pic->data[0]);
387 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
388 pic->type= FF_BUFFER_TYPE_SHARED;
392 assert(!pic->data[0]);
394 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
396 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
397 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
401 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
402 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
406 if(pic->linesize[1] != pic->linesize[2]){
407 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
411 s->linesize = pic->linesize[0];
412 s->uvlinesize= pic->linesize[1];
415 if(pic->qscale_table==NULL){
417 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
418 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
419 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
422 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
423 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
424 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
425 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
426 if(s->out_format == FMT_H264){
428 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
429 pic->motion_val[i]= pic->motion_val_base[i]+4;
430 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
432 pic->motion_subsample_log2= 2;
433 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
435 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
436 pic->motion_val[i]= pic->motion_val_base[i]+4;
437 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
439 pic->motion_subsample_log2= 3;
441 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
442 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
444 pic->qstride= s->mb_stride;
445 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
448 //it might be nicer if the application would keep track of these but it would require a API change
449 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
450 s->prev_pict_types[0]= s->pict_type;
451 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
452 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
455 fail: //for the CHECKED_ALLOCZ macro
460 * deallocates a picture
462 static void free_picture(MpegEncContext *s, Picture *pic){
465 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
466 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
469 av_freep(&pic->mb_var);
470 av_freep(&pic->mc_mb_var);
471 av_freep(&pic->mb_mean);
472 av_freep(&pic->mbskip_table);
473 av_freep(&pic->qscale_table);
474 av_freep(&pic->mb_type_base);
475 av_freep(&pic->dct_coeff);
476 av_freep(&pic->pan_scan);
479 av_freep(&pic->motion_val_base[i]);
480 av_freep(&pic->ref_index[i]);
483 if(pic->type == FF_BUFFER_TYPE_SHARED){
492 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
495 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
496 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
497 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
499 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
500 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
501 s->rd_scratchpad= s->me.scratchpad;
502 s->b_scratchpad= s->me.scratchpad;
503 s->obmc_scratchpad= s->me.scratchpad + 16;
505 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
506 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
507 if(s->avctx->noise_reduction){
508 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
511 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
512 s->block= s->blocks[0];
515 s->pblocks[i] = (short *)(&s->block[i]);
519 return -1; //free() through MPV_common_end()
522 static void free_duplicate_context(MpegEncContext *s){
525 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
526 av_freep(&s->me.scratchpad);
529 s->obmc_scratchpad= NULL;
531 av_freep(&s->dct_error_sum);
532 av_freep(&s->me.map);
533 av_freep(&s->me.score_map);
534 av_freep(&s->blocks);
538 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
539 #define COPY(a) bak->a= src->a
540 COPY(allocated_edge_emu_buffer);
541 COPY(edge_emu_buffer);
545 COPY(obmc_scratchpad);
552 COPY(me.map_generation);
560 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
563 //FIXME copy only needed parts
565 backup_duplicate_context(&bak, dst);
566 memcpy(dst, src, sizeof(MpegEncContext));
567 backup_duplicate_context(dst, &bak);
569 dst->pblocks[i] = (short *)(&dst->block[i]);
571 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
574 #ifdef CONFIG_ENCODERS
575 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
576 #define COPY(a) dst->a= src->a
578 COPY(current_picture);
584 COPY(picture_in_gop_number);
585 COPY(gop_picture_number);
586 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
587 COPY(progressive_frame); //FIXME don't set in encode_header
588 COPY(partitioned_frame); //FIXME don't set in encode_header
594 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
595 * the changed fields will not depend upon the prior state of the MpegEncContext.
597 static void MPV_common_defaults(MpegEncContext *s){
599 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
600 s->chroma_qscale_table= ff_default_chroma_qscale_table;
601 s->progressive_frame= 1;
602 s->progressive_sequence= 1;
603 s->picture_structure= PICT_FRAME;
605 s->coded_picture_number = 0;
606 s->picture_number = 0;
607 s->input_picture_number = 0;
609 s->picture_in_gop_number = 0;
616 * sets the given MpegEncContext to defaults for decoding.
617 * the changed fields will not depend upon the prior state of the MpegEncContext.
619 void MPV_decode_defaults(MpegEncContext *s){
620 MPV_common_defaults(s);
624 * sets the given MpegEncContext to defaults for encoding.
625 * the changed fields will not depend upon the prior state of the MpegEncContext.
628 #ifdef CONFIG_ENCODERS
629 static void MPV_encode_defaults(MpegEncContext *s){
631 MPV_common_defaults(s);
633 for(i=-16; i<16; i++){
634 default_fcode_tab[i + MAX_MV]= 1;
636 s->me.mv_penalty= default_mv_penalty;
637 s->fcode_tab= default_fcode_tab;
639 #endif //CONFIG_ENCODERS
642 * init common structure for both encoder and decoder.
643 * this assumes that some variables like width/height are already set
645 int MPV_common_init(MpegEncContext *s)
647 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
649 s->mb_height = (s->height + 15) / 16;
651 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
652 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
656 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
659 dsputil_init(&s->dsp, s->avctx);
662 s->flags= s->avctx->flags;
663 s->flags2= s->avctx->flags2;
665 s->mb_width = (s->width + 15) / 16;
666 s->mb_stride = s->mb_width + 1;
667 s->b8_stride = s->mb_width*2 + 1;
668 s->b4_stride = s->mb_width*4 + 1;
669 mb_array_size= s->mb_height * s->mb_stride;
670 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
672 /* set chroma shifts */
673 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
674 &(s->chroma_y_shift) );
676 /* set default edge pos, will be overriden in decode_header if needed */
677 s->h_edge_pos= s->mb_width*16;
678 s->v_edge_pos= s->mb_height*16;
680 s->mb_num = s->mb_width * s->mb_height;
685 s->block_wrap[3]= s->b8_stride;
687 s->block_wrap[5]= s->mb_stride;
689 y_size = s->b8_stride * (2 * s->mb_height + 1);
690 c_size = s->mb_stride * (s->mb_height + 1);
691 yc_size = y_size + 2 * c_size;
693 /* convert fourcc to upper case */
694 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
695 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
696 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
697 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
699 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
700 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
701 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
702 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
704 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
706 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
707 for(y=0; y<s->mb_height; y++){
708 for(x=0; x<s->mb_width; x++){
709 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
712 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
715 /* Allocate MV tables */
716 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
717 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
718 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
719 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
720 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
721 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
722 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
723 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
724 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
725 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
726 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
727 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
729 if(s->msmpeg4_version){
730 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
732 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
734 /* Allocate MB type table */
735 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
737 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
739 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
740 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
741 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
742 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
743 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
744 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
746 if(s->avctx->noise_reduction){
747 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
750 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
752 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
754 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
755 /* interlaced direct mode decoding tables */
760 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
761 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
763 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
764 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
765 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
767 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
770 if (s->out_format == FMT_H263) {
772 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
773 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
774 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
775 s->ac_val[2] = s->ac_val[1] + c_size;
778 CHECKED_ALLOCZ(s->coded_block_base, y_size);
779 s->coded_block= s->coded_block_base + s->b8_stride + 1;
781 /* cbp, ac_pred, pred_dir */
782 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
783 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
786 if (s->h263_pred || s->h263_plus || !s->encoding) {
788 //MN: we need these for error resilience of intra-frames
789 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
790 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
791 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
792 s->dc_val[2] = s->dc_val[1] + c_size;
793 for(i=0;i<yc_size;i++)
794 s->dc_val_base[i] = 1024;
797 /* which mb is a intra block */
798 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
799 memset(s->mbintra_table, 1, mb_array_size);
801 /* init macroblock skip table */
802 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
803 //Note the +1 is for a quicker mpeg4 slice_end detection
804 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
806 s->parse_context.state= -1;
807 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
808 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
809 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
810 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
813 s->context_initialized = 1;
815 s->thread_context[0]= s;
816 for(i=1; i<s->avctx->thread_count; i++){
817 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
818 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
821 for(i=0; i<s->avctx->thread_count; i++){
822 if(init_duplicate_context(s->thread_context[i], s) < 0)
824 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
825 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
834 /* init common structure for both encoder and decoder */
835 void MPV_common_end(MpegEncContext *s)
839 for(i=0; i<s->avctx->thread_count; i++){
840 free_duplicate_context(s->thread_context[i]);
842 for(i=1; i<s->avctx->thread_count; i++){
843 av_freep(&s->thread_context[i]);
846 av_freep(&s->parse_context.buffer);
847 s->parse_context.buffer_size=0;
849 av_freep(&s->mb_type);
850 av_freep(&s->p_mv_table_base);
851 av_freep(&s->b_forw_mv_table_base);
852 av_freep(&s->b_back_mv_table_base);
853 av_freep(&s->b_bidir_forw_mv_table_base);
854 av_freep(&s->b_bidir_back_mv_table_base);
855 av_freep(&s->b_direct_mv_table_base);
857 s->b_forw_mv_table= NULL;
858 s->b_back_mv_table= NULL;
859 s->b_bidir_forw_mv_table= NULL;
860 s->b_bidir_back_mv_table= NULL;
861 s->b_direct_mv_table= NULL;
865 av_freep(&s->b_field_mv_table_base[i][j][k]);
866 s->b_field_mv_table[i][j][k]=NULL;
868 av_freep(&s->b_field_select_table[i][j]);
869 av_freep(&s->p_field_mv_table_base[i][j]);
870 s->p_field_mv_table[i][j]=NULL;
872 av_freep(&s->p_field_select_table[i]);
875 av_freep(&s->dc_val_base);
876 av_freep(&s->ac_val_base);
877 av_freep(&s->coded_block_base);
878 av_freep(&s->mbintra_table);
879 av_freep(&s->cbp_table);
880 av_freep(&s->pred_dir_table);
882 av_freep(&s->mbskip_table);
883 av_freep(&s->prev_pict_types);
884 av_freep(&s->bitstream_buffer);
885 s->allocated_bitstream_buffer_size=0;
887 av_freep(&s->avctx->stats_out);
888 av_freep(&s->ac_stats);
889 av_freep(&s->error_status_table);
890 av_freep(&s->mb_index2xy);
891 av_freep(&s->lambda_table);
892 av_freep(&s->q_intra_matrix);
893 av_freep(&s->q_inter_matrix);
894 av_freep(&s->q_intra_matrix16);
895 av_freep(&s->q_inter_matrix16);
896 av_freep(&s->input_picture);
897 av_freep(&s->reordered_input_picture);
898 av_freep(&s->dct_offset);
901 for(i=0; i<MAX_PICTURE_COUNT; i++){
902 free_picture(s, &s->picture[i]);
905 av_freep(&s->picture);
906 s->context_initialized = 0;
909 s->current_picture_ptr= NULL;
910 s->linesize= s->uvlinesize= 0;
913 av_freep(&s->visualization_buffer[i]);
915 avcodec_default_free_buffers(s->avctx);
918 #ifdef CONFIG_ENCODERS
920 /* init video encoder */
921 int MPV_encode_init(AVCodecContext *avctx)
923 MpegEncContext *s = avctx->priv_data;
925 int chroma_h_shift, chroma_v_shift;
927 MPV_encode_defaults(s);
929 switch (avctx->codec_id) {
930 case CODEC_ID_MPEG2VIDEO:
931 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
932 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
938 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
939 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
940 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
945 if(avctx->pix_fmt != PIX_FMT_YUV420P){
946 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
951 switch (avctx->pix_fmt) {
952 case PIX_FMT_YUVJ422P:
953 case PIX_FMT_YUV422P:
954 s->chroma_format = CHROMA_422;
956 case PIX_FMT_YUVJ420P:
957 case PIX_FMT_YUV420P:
959 s->chroma_format = CHROMA_420;
963 s->bit_rate = avctx->bit_rate;
964 s->width = avctx->width;
965 s->height = avctx->height;
966 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
967 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
970 s->gop_size = avctx->gop_size;
972 s->flags= avctx->flags;
973 s->flags2= avctx->flags2;
974 s->max_b_frames= avctx->max_b_frames;
975 s->codec_id= avctx->codec->id;
976 s->luma_elim_threshold = avctx->luma_elim_threshold;
977 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
978 s->strict_std_compliance= avctx->strict_std_compliance;
979 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
980 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
981 s->mpeg_quant= avctx->mpeg_quant;
982 s->rtp_mode= !!avctx->rtp_payload_size;
983 s->intra_dc_precision= avctx->intra_dc_precision;
984 s->user_specified_pts = AV_NOPTS_VALUE;
986 if (s->gop_size <= 1) {
993 s->me_method = avctx->me_method;
996 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
998 s->adaptive_quant= ( s->avctx->lumi_masking
999 || s->avctx->dark_masking
1000 || s->avctx->temporal_cplx_masking
1001 || s->avctx->spatial_cplx_masking
1002 || s->avctx->p_masking
1003 || s->avctx->border_masking
1004 || (s->flags&CODEC_FLAG_QP_RD))
1005 && !s->fixed_qscale;
1007 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1008 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1009 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1010 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1011 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
1013 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1014 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1018 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1019 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1022 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1023 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1027 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1028 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1032 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1033 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1034 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1036 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");
1039 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1040 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1041 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1045 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1046 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1050 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1051 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1055 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1056 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1060 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1061 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1065 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1066 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1070 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1071 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1072 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1076 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1077 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1081 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1082 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1086 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1087 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1091 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1092 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
1096 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1097 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1101 if(s->flags & CODEC_FLAG_LOW_DELAY){
1102 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
1103 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
1106 if (s->max_b_frames != 0){
1107 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
1112 if(s->q_scale_type == 1){
1113 if(s->codec_id != CODEC_ID_MPEG2VIDEO){
1114 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
1117 if(avctx->qmax > 12){
1118 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
1123 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1124 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1125 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1126 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1130 if(s->avctx->thread_count > 1)
1133 if(!avctx->time_base.den || !avctx->time_base.num){
1134 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1138 i= (INT_MAX/2+128)>>8;
1139 if(avctx->me_threshold >= i){
1140 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1143 if(avctx->mb_threshold >= i){
1144 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1148 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1149 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1150 avctx->b_frame_strategy = 0;
1153 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1155 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1156 avctx->time_base.den /= i;
1157 avctx->time_base.num /= i;
1161 if(s->codec_id==CODEC_ID_MJPEG){
1162 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1163 s->inter_quant_bias= 0;
1164 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1165 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1166 s->inter_quant_bias= 0;
1168 s->intra_quant_bias=0;
1169 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1172 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1173 s->intra_quant_bias= avctx->intra_quant_bias;
1174 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1175 s->inter_quant_bias= avctx->inter_quant_bias;
1177 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1179 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1180 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1183 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1185 switch(avctx->codec->id) {
1186 case CODEC_ID_MPEG1VIDEO:
1187 s->out_format = FMT_MPEG1;
1188 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1189 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1191 case CODEC_ID_MPEG2VIDEO:
1192 s->out_format = FMT_MPEG1;
1193 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
1194 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1197 case CODEC_ID_LJPEG:
1198 case CODEC_ID_MJPEG:
1199 s->out_format = FMT_MJPEG;
1200 s->intra_only = 1; /* force intra only for jpeg */
1201 s->mjpeg_vsample[0] = 2;
1202 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
1203 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
1204 s->mjpeg_hsample[0] = 2;
1205 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
1206 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
1207 if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) || mjpeg_init(s) < 0)
1213 if (!ENABLE_H261_ENCODER) return -1;
1214 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
1215 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height);
1218 s->out_format = FMT_H261;
1223 if (h263_get_picture_format(s->width, s->height) == 7) {
1224 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);
1227 s->out_format = FMT_H263;
1228 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1232 case CODEC_ID_H263P:
1233 s->out_format = FMT_H263;
1236 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1237 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
1238 s->modified_quant= s->h263_aic;
1239 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1240 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1241 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1242 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1243 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1246 /* These are just to be sure */
1251 s->out_format = FMT_H263;
1252 s->h263_flv = 2; /* format = 1; 11-bit codes */
1253 s->unrestricted_mv = 1;
1254 s->rtp_mode=0; /* don't allow GOB */
1259 s->out_format = FMT_H263;
1264 s->out_format = FMT_H263;
1267 s->modified_quant=1;
1271 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1273 case CODEC_ID_MPEG4:
1274 s->out_format = FMT_H263;
1276 s->unrestricted_mv = 1;
1277 s->low_delay= s->max_b_frames ? 0 : 1;
1278 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1280 case CODEC_ID_MSMPEG4V1:
1281 s->out_format = FMT_H263;
1282 s->h263_msmpeg4 = 1;
1284 s->unrestricted_mv = 1;
1285 s->msmpeg4_version= 1;
1289 case CODEC_ID_MSMPEG4V2:
1290 s->out_format = FMT_H263;
1291 s->h263_msmpeg4 = 1;
1293 s->unrestricted_mv = 1;
1294 s->msmpeg4_version= 2;
1298 case CODEC_ID_MSMPEG4V3:
1299 s->out_format = FMT_H263;
1300 s->h263_msmpeg4 = 1;
1302 s->unrestricted_mv = 1;
1303 s->msmpeg4_version= 3;
1304 s->flipflop_rounding=1;
1309 s->out_format = FMT_H263;
1310 s->h263_msmpeg4 = 1;
1312 s->unrestricted_mv = 1;
1313 s->msmpeg4_version= 4;
1314 s->flipflop_rounding=1;
1319 s->out_format = FMT_H263;
1320 s->h263_msmpeg4 = 1;
1322 s->unrestricted_mv = 1;
1323 s->msmpeg4_version= 5;
1324 s->flipflop_rounding=1;
1332 avctx->has_b_frames= !s->low_delay;
1337 if (MPV_common_init(s) < 0)
1340 if(s->modified_quant)
1341 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1342 s->progressive_frame=
1343 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
1344 s->quant_precision=5;
1346 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1347 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1349 if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
1350 ff_h261_encode_init(s);
1351 if (s->out_format == FMT_H263)
1352 h263_encode_init(s);
1353 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
1354 ff_msmpeg4_encode_init(s);
1355 if (s->out_format == FMT_MPEG1)
1356 ff_mpeg1_encode_init(s);
1360 int j= s->dsp.idct_permutation[i];
1361 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1362 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1363 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1364 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1365 s->intra_matrix[j] =
1366 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1369 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1370 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1372 if(s->avctx->intra_matrix)
1373 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1374 if(s->avctx->inter_matrix)
1375 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1378 /* precompute matrix */
1379 /* for mjpeg, we do include qscale in the matrix */
1380 if (s->out_format != FMT_MJPEG) {
1381 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1382 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1383 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1384 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1387 if(ff_rate_control_init(s) < 0)
1393 int MPV_encode_end(AVCodecContext *avctx)
1395 MpegEncContext *s = avctx->priv_data;
1397 ff_rate_control_uninit(s);
1400 if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG)
1403 av_freep(&avctx->extradata);
1408 #endif //CONFIG_ENCODERS
1410 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
1412 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1413 uint8_t index_run[MAX_RUN+1];
1414 int last, run, level, start, end, i;
1416 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1417 if(static_store && rl->max_level[0])
1420 /* compute max_level[], max_run[] and index_run[] */
1421 for(last=0;last<2;last++) {
1430 memset(max_level, 0, MAX_RUN + 1);
1431 memset(max_run, 0, MAX_LEVEL + 1);
1432 memset(index_run, rl->n, MAX_RUN + 1);
1433 for(i=start;i<end;i++) {
1434 run = rl->table_run[i];
1435 level = rl->table_level[i];
1436 if (index_run[run] == rl->n)
1438 if (level > max_level[run])
1439 max_level[run] = level;
1440 if (run > max_run[level])
1441 max_run[level] = run;
1444 rl->max_level[last] = static_store[last];
1446 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1447 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1449 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1451 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1452 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1454 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1456 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1457 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1461 /* draw the edges of width 'w' of an image of size width, height */
1462 //FIXME check that this is ok for mpeg4 interlaced
1463 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1465 uint8_t *ptr, *last_line;
1468 last_line = buf + (height - 1) * wrap;
1470 /* top and bottom */
1471 memcpy(buf - (i + 1) * wrap, buf, width);
1472 memcpy(last_line + (i + 1) * wrap, last_line, width);
1474 /* left and right */
1476 for(i=0;i<height;i++) {
1477 memset(ptr - w, ptr[0], w);
1478 memset(ptr + width, ptr[width-1], w);
1483 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1484 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1485 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1486 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1490 int ff_find_unused_picture(MpegEncContext *s, int shared){
1494 for(i=0; i<MAX_PICTURE_COUNT; i++){
1495 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1498 for(i=0; i<MAX_PICTURE_COUNT; i++){
1499 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1501 for(i=0; i<MAX_PICTURE_COUNT; i++){
1502 if(s->picture[i].data[0]==NULL) return i;
1510 static void update_noise_reduction(MpegEncContext *s){
1513 for(intra=0; intra<2; intra++){
1514 if(s->dct_count[intra] > (1<<16)){
1515 for(i=0; i<64; i++){
1516 s->dct_error_sum[intra][i] >>=1;
1518 s->dct_count[intra] >>= 1;
1521 for(i=0; i<64; i++){
1522 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);
1528 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1530 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1536 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1538 /* mark&release old frames */
1539 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1540 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1541 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1543 /* release forgotten pictures */
1544 /* if(mpeg124/h263) */
1546 for(i=0; i<MAX_PICTURE_COUNT; i++){
1547 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1548 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1549 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1557 /* release non reference frames */
1558 for(i=0; i<MAX_PICTURE_COUNT; i++){
1559 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1560 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1564 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1565 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1567 i= ff_find_unused_picture(s, 0);
1568 pic= (AVFrame*)&s->picture[i];
1571 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1572 && !s->dropable ? 3 : 0;
1574 pic->coded_picture_number= s->coded_picture_number++;
1576 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1579 s->current_picture_ptr= (Picture*)pic;
1580 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1581 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1584 s->current_picture_ptr->pict_type= s->pict_type;
1585 // if(s->flags && CODEC_FLAG_QSCALE)
1586 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1587 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1589 copy_picture(&s->current_picture, s->current_picture_ptr);
1591 if (s->pict_type != B_TYPE) {
1592 s->last_picture_ptr= s->next_picture_ptr;
1594 s->next_picture_ptr= s->current_picture_ptr;
1596 /* 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,
1597 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1598 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1599 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1600 s->pict_type, s->dropable);*/
1602 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1603 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1605 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
1606 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1607 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1611 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1613 if(s->picture_structure!=PICT_FRAME){
1616 if(s->picture_structure == PICT_BOTTOM_FIELD){
1617 s->current_picture.data[i] += s->current_picture.linesize[i];
1619 s->current_picture.linesize[i] *= 2;
1620 s->last_picture.linesize[i] *=2;
1621 s->next_picture.linesize[i] *=2;
1625 s->hurry_up= s->avctx->hurry_up;
1626 s->error_resilience= avctx->error_resilience;
1628 /* set dequantizer, we can't do it during init as it might change for mpeg4
1629 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1630 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1631 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1632 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1633 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1634 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1635 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1637 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1638 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1641 if(s->dct_error_sum){
1642 assert(s->avctx->noise_reduction && s->encoding);
1644 update_noise_reduction(s);
1648 if(s->avctx->xvmc_acceleration)
1649 return XVMC_field_start(s, avctx);
1654 /* generic function for encode/decode called after a frame has been coded/decoded */
1655 void MPV_frame_end(MpegEncContext *s)
1658 /* draw edge for correct motion prediction if outside */
1660 //just to make sure that all data is rendered.
1661 if(s->avctx->xvmc_acceleration){
1665 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1666 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1667 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1668 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1672 s->last_pict_type = s->pict_type;
1673 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1674 if(s->pict_type!=B_TYPE){
1675 s->last_non_b_pict_type= s->pict_type;
1678 /* copy back current_picture variables */
1679 for(i=0; i<MAX_PICTURE_COUNT; i++){
1680 if(s->picture[i].data[0] == s->current_picture.data[0]){
1681 s->picture[i]= s->current_picture;
1685 assert(i<MAX_PICTURE_COUNT);
1689 /* release non-reference frames */
1690 for(i=0; i<MAX_PICTURE_COUNT; i++){
1691 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1692 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1696 // clear copies, to avoid confusion
1698 memset(&s->last_picture, 0, sizeof(Picture));
1699 memset(&s->next_picture, 0, sizeof(Picture));
1700 memset(&s->current_picture, 0, sizeof(Picture));
1702 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1706 * draws an line from (ex, ey) -> (sx, sy).
1707 * @param w width of the image
1708 * @param h height of the image
1709 * @param stride stride/linesize of the image
1710 * @param color color of the arrow
1712 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1715 sx= av_clip(sx, 0, w-1);
1716 sy= av_clip(sy, 0, h-1);
1717 ex= av_clip(ex, 0, w-1);
1718 ey= av_clip(ey, 0, h-1);
1720 buf[sy*stride + sx]+= color;
1722 if(FFABS(ex - sx) > FFABS(ey - sy)){
1724 FFSWAP(int, sx, ex);
1725 FFSWAP(int, sy, ey);
1727 buf+= sx + sy*stride;
1729 f= ((ey-sy)<<16)/ex;
1730 for(x= 0; x <= ex; x++){
1733 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1734 buf[(y+1)*stride + x]+= (color* fr )>>16;
1738 FFSWAP(int, sx, ex);
1739 FFSWAP(int, sy, ey);
1741 buf+= sx + sy*stride;
1743 if(ey) f= ((ex-sx)<<16)/ey;
1745 for(y= 0; y <= ey; y++){
1748 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1749 buf[y*stride + x+1]+= (color* fr )>>16;;
1755 * draws an arrow from (ex, ey) -> (sx, sy).
1756 * @param w width of the image
1757 * @param h height of the image
1758 * @param stride stride/linesize of the image
1759 * @param color color of the arrow
1761 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1764 sx= av_clip(sx, -100, w+100);
1765 sy= av_clip(sy, -100, h+100);
1766 ex= av_clip(ex, -100, w+100);
1767 ey= av_clip(ey, -100, h+100);
1772 if(dx*dx + dy*dy > 3*3){
1775 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1777 //FIXME subpixel accuracy
1778 rx= ROUNDED_DIV(rx*3<<4, length);
1779 ry= ROUNDED_DIV(ry*3<<4, length);
1781 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1782 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1784 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1788 * prints debuging info for the given picture.
1790 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1792 if(!pict || !pict->mb_type) return;
1794 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1797 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1798 switch (pict->pict_type) {
1799 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1800 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1801 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1802 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1803 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1804 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1806 for(y=0; y<s->mb_height; y++){
1807 for(x=0; x<s->mb_width; x++){
1808 if(s->avctx->debug&FF_DEBUG_SKIP){
1809 int count= s->mbskip_table[x + y*s->mb_stride];
1810 if(count>9) count=9;
1811 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1813 if(s->avctx->debug&FF_DEBUG_QP){
1814 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1816 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1817 int mb_type= pict->mb_type[x + y*s->mb_stride];
1818 //Type & MV direction
1820 av_log(s->avctx, AV_LOG_DEBUG, "P");
1821 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1822 av_log(s->avctx, AV_LOG_DEBUG, "A");
1823 else if(IS_INTRA4x4(mb_type))
1824 av_log(s->avctx, AV_LOG_DEBUG, "i");
1825 else if(IS_INTRA16x16(mb_type))
1826 av_log(s->avctx, AV_LOG_DEBUG, "I");
1827 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1828 av_log(s->avctx, AV_LOG_DEBUG, "d");
1829 else if(IS_DIRECT(mb_type))
1830 av_log(s->avctx, AV_LOG_DEBUG, "D");
1831 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1832 av_log(s->avctx, AV_LOG_DEBUG, "g");
1833 else if(IS_GMC(mb_type))
1834 av_log(s->avctx, AV_LOG_DEBUG, "G");
1835 else if(IS_SKIP(mb_type))
1836 av_log(s->avctx, AV_LOG_DEBUG, "S");
1837 else if(!USES_LIST(mb_type, 1))
1838 av_log(s->avctx, AV_LOG_DEBUG, ">");
1839 else if(!USES_LIST(mb_type, 0))
1840 av_log(s->avctx, AV_LOG_DEBUG, "<");
1842 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1843 av_log(s->avctx, AV_LOG_DEBUG, "X");
1848 av_log(s->avctx, AV_LOG_DEBUG, "+");
1849 else if(IS_16X8(mb_type))
1850 av_log(s->avctx, AV_LOG_DEBUG, "-");
1851 else if(IS_8X16(mb_type))
1852 av_log(s->avctx, AV_LOG_DEBUG, "|");
1853 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1854 av_log(s->avctx, AV_LOG_DEBUG, " ");
1856 av_log(s->avctx, AV_LOG_DEBUG, "?");
1859 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1860 av_log(s->avctx, AV_LOG_DEBUG, "=");
1862 av_log(s->avctx, AV_LOG_DEBUG, " ");
1864 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1866 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1870 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1871 const int shift= 1 + s->quarter_sample;
1875 int h_chroma_shift, v_chroma_shift;
1876 const int width = s->avctx->width;
1877 const int height= s->avctx->height;
1878 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1879 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1880 s->low_delay=0; //needed to see the vectors without trashing the buffers
1882 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1884 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1885 pict->data[i]= s->visualization_buffer[i];
1887 pict->type= FF_BUFFER_TYPE_COPY;
1890 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1892 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1893 const int mb_index= mb_x + mb_y*s->mb_stride;
1894 if((s->avctx->debug_mv) && pict->motion_val){
1896 for(type=0; type<3; type++){
1899 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1903 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1907 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1912 if(!USES_LIST(pict->mb_type[mb_index], direction))
1915 if(IS_8X8(pict->mb_type[mb_index])){
1918 int sx= mb_x*16 + 4 + 8*(i&1);
1919 int sy= mb_y*16 + 4 + 8*(i>>1);
1920 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1921 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1922 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1923 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1925 }else if(IS_16X8(pict->mb_type[mb_index])){
1929 int sy=mb_y*16 + 4 + 8*i;
1930 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1931 int mx=(pict->motion_val[direction][xy][0]>>shift);
1932 int my=(pict->motion_val[direction][xy][1]>>shift);
1934 if(IS_INTERLACED(pict->mb_type[mb_index]))
1937 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1939 }else if(IS_8X16(pict->mb_type[mb_index])){
1942 int sx=mb_x*16 + 4 + 8*i;
1944 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1945 int mx=(pict->motion_val[direction][xy][0]>>shift);
1946 int my=(pict->motion_val[direction][xy][1]>>shift);
1948 if(IS_INTERLACED(pict->mb_type[mb_index]))
1951 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1954 int sx= mb_x*16 + 8;
1955 int sy= mb_y*16 + 8;
1956 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1957 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1958 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1959 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1963 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1964 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1967 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1968 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1971 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1972 int mb_type= pict->mb_type[mb_index];
1975 #define COLOR(theta, r)\
1976 u= (int)(128 + r*cos(theta*3.141592/180));\
1977 v= (int)(128 + r*sin(theta*3.141592/180));
1981 if(IS_PCM(mb_type)){
1983 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1985 }else if(IS_INTRA4x4(mb_type)){
1987 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1989 }else if(IS_DIRECT(mb_type)){
1991 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1993 }else if(IS_GMC(mb_type)){
1995 }else if(IS_SKIP(mb_type)){
1997 }else if(!USES_LIST(mb_type, 1)){
1999 }else if(!USES_LIST(mb_type, 0)){
2002 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2006 u*= 0x0101010101010101ULL;
2007 v*= 0x0101010101010101ULL;
2009 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
2010 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
2014 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
2015 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2016 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
2018 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2020 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2022 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2023 int dm= 1 << (mv_sample_log2-2);
2025 int sx= mb_x*16 + 8*(i&1);
2026 int sy= mb_y*16 + 8*(i>>1);
2027 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2029 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2030 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2032 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2033 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2034 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2038 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2042 s->mbskip_table[mb_index]=0;
2048 #ifdef CONFIG_ENCODERS
2050 static int get_sae(uint8_t *src, int ref, int stride){
2054 for(y=0; y<16; y++){
2055 for(x=0; x<16; x++){
2056 acc+= FFABS(src[x+y*stride] - ref);
2063 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2070 for(y=0; y<h; y+=16){
2071 for(x=0; x<w; x+=16){
2072 int offset= x + y*stride;
2073 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2074 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2075 int sae = get_sae(src + offset, mean, stride);
2077 acc+= sae + 500 < sad;
2084 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2088 const int encoding_delay= s->max_b_frames;
2093 pic_arg->display_picture_number= s->input_picture_number++;
2095 if(pts != AV_NOPTS_VALUE){
2096 if(s->user_specified_pts != AV_NOPTS_VALUE){
2098 int64_t last= s->user_specified_pts;
2101 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2105 s->user_specified_pts= pts;
2107 if(s->user_specified_pts != AV_NOPTS_VALUE){
2108 s->user_specified_pts=
2109 pts= s->user_specified_pts + 1;
2110 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2112 pts= pic_arg->display_picture_number;
2118 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2119 if(pic_arg->linesize[0] != s->linesize) direct=0;
2120 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2121 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2123 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2126 i= ff_find_unused_picture(s, 1);
2128 pic= (AVFrame*)&s->picture[i];
2132 pic->data[i]= pic_arg->data[i];
2133 pic->linesize[i]= pic_arg->linesize[i];
2135 alloc_picture(s, (Picture*)pic, 1);
2137 i= ff_find_unused_picture(s, 0);
2139 pic= (AVFrame*)&s->picture[i];
2142 alloc_picture(s, (Picture*)pic, 0);
2144 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2145 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2146 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2149 int h_chroma_shift, v_chroma_shift;
2150 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2153 int src_stride= pic_arg->linesize[i];
2154 int dst_stride= i ? s->uvlinesize : s->linesize;
2155 int h_shift= i ? h_chroma_shift : 0;
2156 int v_shift= i ? v_chroma_shift : 0;
2157 int w= s->width >>h_shift;
2158 int h= s->height>>v_shift;
2159 uint8_t *src= pic_arg->data[i];
2160 uint8_t *dst= pic->data[i];
2162 if(!s->avctx->rc_buffer_size)
2163 dst +=INPLACE_OFFSET;
2165 if(src_stride==dst_stride)
2166 memcpy(dst, src, src_stride*h);
2169 memcpy(dst, src, w);
2177 copy_picture_attributes(s, pic, pic_arg);
2178 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2181 /* shift buffer entries */
2182 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2183 s->input_picture[i-1]= s->input_picture[i];
2185 s->input_picture[encoding_delay]= (Picture*)pic;
2190 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2195 for(plane=0; plane<3; plane++){
2196 const int stride= p->linesize[plane];
2197 const int bw= plane ? 1 : 2;
2198 for(y=0; y<s->mb_height*bw; y++){
2199 for(x=0; x<s->mb_width*bw; x++){
2200 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2201 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);
2203 switch(s->avctx->frame_skip_exp){
2204 case 0: score= FFMAX(score, v); break;
2205 case 1: score+= FFABS(v);break;
2206 case 2: score+= v*v;break;
2207 case 3: score64+= FFABS(v*v*(int64_t)v);break;
2208 case 4: score64+= v*v*(int64_t)(v*v);break;
2214 if(score) score64= score;
2216 if(score64 < s->avctx->frame_skip_threshold)
2218 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2223 static int estimate_best_b_count(MpegEncContext *s){
2224 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2225 AVCodecContext *c= avcodec_alloc_context();
2226 AVFrame input[FF_MAX_B_FRAMES+2];
2227 const int scale= s->avctx->brd_scale;
2228 int i, j, out_size, p_lambda, b_lambda, lambda2;
2229 int outbuf_size= s->width * s->height; //FIXME
2230 uint8_t *outbuf= av_malloc(outbuf_size);
2231 int64_t best_rd= INT64_MAX;
2232 int best_b_count= -1;
2234 assert(scale>=0 && scale <=3);
2237 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2238 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2239 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2240 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2242 c->width = s->width >> scale;
2243 c->height= s->height>> scale;
2244 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2245 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2246 c->mb_decision= s->avctx->mb_decision;
2247 c->me_cmp= s->avctx->me_cmp;
2248 c->mb_cmp= s->avctx->mb_cmp;
2249 c->me_sub_cmp= s->avctx->me_sub_cmp;
2250 c->pix_fmt = PIX_FMT_YUV420P;
2251 c->time_base= s->avctx->time_base;
2252 c->max_b_frames= s->max_b_frames;
2254 if (avcodec_open(c, codec) < 0)
2257 for(i=0; i<s->max_b_frames+2; i++){
2258 int ysize= c->width*c->height;
2259 int csize= (c->width/2)*(c->height/2);
2260 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2262 avcodec_get_frame_defaults(&input[i]);
2263 input[i].data[0]= av_malloc(ysize + 2*csize);
2264 input[i].data[1]= input[i].data[0] + ysize;
2265 input[i].data[2]= input[i].data[1] + csize;
2266 input[i].linesize[0]= c->width;
2267 input[i].linesize[1]=
2268 input[i].linesize[2]= c->width/2;
2270 if(pre_input_ptr && (!i || s->input_picture[i-1])) {
2271 pre_input= *pre_input_ptr;
2273 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
2274 pre_input.data[0]+=INPLACE_OFFSET;
2275 pre_input.data[1]+=INPLACE_OFFSET;
2276 pre_input.data[2]+=INPLACE_OFFSET;
2279 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2280 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);
2281 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);
2285 for(j=0; j<s->max_b_frames+1; j++){
2288 if(!s->input_picture[j])
2291 c->error[0]= c->error[1]= c->error[2]= 0;
2293 input[0].pict_type= I_TYPE;
2294 input[0].quality= 1 * FF_QP2LAMBDA;
2295 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2296 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2298 for(i=0; i<s->max_b_frames+1; i++){
2299 int is_p= i % (j+1) == j || i==s->max_b_frames;
2301 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2302 input[i+1].quality= is_p ? p_lambda : b_lambda;
2303 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2304 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2307 /* get the delayed frames */
2309 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2310 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2313 rd += c->error[0] + c->error[1] + c->error[2];
2325 for(i=0; i<s->max_b_frames+2; i++){
2326 av_freep(&input[i].data[0]);
2329 return best_b_count;
2332 static void select_input_picture(MpegEncContext *s){
2335 for(i=1; i<MAX_PICTURE_COUNT; i++)
2336 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2337 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2339 /* set next picture type & ordering */
2340 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2341 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2342 s->reordered_input_picture[0]= s->input_picture[0];
2343 s->reordered_input_picture[0]->pict_type= I_TYPE;
2344 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2348 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2349 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2350 //FIXME check that te gop check above is +-1 correct
2351 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2353 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2355 s->input_picture[0]->data[i]= NULL;
2356 s->input_picture[0]->type= 0;
2358 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2359 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2361 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2365 ff_vbv_update(s, 0);
2371 if(s->flags&CODEC_FLAG_PASS2){
2372 for(i=0; i<s->max_b_frames+1; i++){
2373 int pict_num= s->input_picture[0]->display_picture_number + i;
2375 if(pict_num >= s->rc_context.num_entries)
2377 if(!s->input_picture[i]){
2378 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2382 s->input_picture[i]->pict_type=
2383 s->rc_context.entry[pict_num].new_pict_type;
2387 if(s->avctx->b_frame_strategy==0){
2388 b_frames= s->max_b_frames;
2389 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2390 }else if(s->avctx->b_frame_strategy==1){
2391 for(i=1; i<s->max_b_frames+1; i++){
2392 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2393 s->input_picture[i]->b_frame_score=
2394 get_intra_count(s, s->input_picture[i ]->data[0],
2395 s->input_picture[i-1]->data[0], s->linesize) + 1;
2398 for(i=0; i<s->max_b_frames+1; i++){
2399 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2402 b_frames= FFMAX(0, i-1);
2405 for(i=0; i<b_frames+1; i++){
2406 s->input_picture[i]->b_frame_score=0;
2408 }else if(s->avctx->b_frame_strategy==2){
2409 b_frames= estimate_best_b_count(s);
2411 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2416 //static int b_count=0;
2417 //b_count+= b_frames;
2418 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2420 for(i= b_frames - 1; i>=0; i--){
2421 int type= s->input_picture[i]->pict_type;
2422 if(type && type != B_TYPE)
2425 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2426 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2429 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2430 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2431 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2433 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2435 s->input_picture[b_frames]->pict_type= I_TYPE;
2439 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2441 && s->input_picture[b_frames]->pict_type== I_TYPE)
2444 s->reordered_input_picture[0]= s->input_picture[b_frames];
2445 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2446 s->reordered_input_picture[0]->pict_type= P_TYPE;
2447 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2448 for(i=0; i<b_frames; i++){
2449 s->reordered_input_picture[i+1]= s->input_picture[i];
2450 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2451 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2456 if(s->reordered_input_picture[0]){
2457 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2459 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2461 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
2462 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2464 int i= ff_find_unused_picture(s, 0);
2465 Picture *pic= &s->picture[i];
2467 pic->reference = s->reordered_input_picture[0]->reference;
2468 alloc_picture(s, pic, 0);
2470 /* mark us unused / free shared pic */
2471 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
2472 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
2474 s->reordered_input_picture[0]->data[i]= NULL;
2475 s->reordered_input_picture[0]->type= 0;
2477 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2479 s->current_picture_ptr= pic;
2481 // input is not a shared pix -> reuse buffer for current_pix
2483 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2484 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2486 s->current_picture_ptr= s->reordered_input_picture[0];
2488 s->new_picture.data[i]+= INPLACE_OFFSET;
2491 copy_picture(&s->current_picture, s->current_picture_ptr);
2493 s->picture_number= s->new_picture.display_picture_number;
2494 //printf("dpn:%d\n", s->picture_number);
2496 memset(&s->new_picture, 0, sizeof(Picture));
2500 int MPV_encode_picture(AVCodecContext *avctx,
2501 unsigned char *buf, int buf_size, void *data)
2503 MpegEncContext *s = avctx->priv_data;
2504 AVFrame *pic_arg = data;
2505 int i, stuffing_count;
2507 for(i=0; i<avctx->thread_count; i++){
2508 int start_y= s->thread_context[i]->start_mb_y;
2509 int end_y= s->thread_context[i]-> end_mb_y;
2510 int h= s->mb_height;
2511 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2512 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2514 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2517 s->picture_in_gop_number++;
2519 if(load_input_picture(s, pic_arg) < 0)
2522 select_input_picture(s);
2525 if(s->new_picture.data[0]){
2526 s->pict_type= s->new_picture.pict_type;
2528 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2529 MPV_frame_start(s, avctx);
2531 if (encode_picture(s, s->picture_number) < 0)
2534 avctx->real_pict_num = s->picture_number;
2535 avctx->header_bits = s->header_bits;
2536 avctx->mv_bits = s->mv_bits;
2537 avctx->misc_bits = s->misc_bits;
2538 avctx->i_tex_bits = s->i_tex_bits;
2539 avctx->p_tex_bits = s->p_tex_bits;
2540 avctx->i_count = s->i_count;
2541 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2542 avctx->skip_count = s->skip_count;
2546 if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
2547 mjpeg_picture_trailer(s);
2549 if(avctx->rc_buffer_size){
2550 RateControlContext *rcc= &s->rc_context;
2551 int max_size= rcc->buffer_index/3;
2553 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
2554 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
2555 if(s->adaptive_quant){
2557 for(i=0; i<s->mb_height*s->mb_stride; i++)
2558 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
2560 s->mb_skipped = 0; //done in MPV_frame_start()
2561 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
2562 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
2563 s->no_rounding ^= 1;
2565 if(s->pict_type!=B_TYPE){
2566 s->time_base= s->last_time_base;
2567 s->last_non_b_time= s->time - s->pp_time;
2569 // av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
2570 for(i=0; i<avctx->thread_count; i++){
2571 PutBitContext *pb= &s->thread_context[i]->pb;
2572 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
2577 assert(s->avctx->rc_max_rate);
2580 if(s->flags&CODEC_FLAG_PASS1)
2581 ff_write_pass1_stats(s);
2584 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2585 avctx->error[i] += s->current_picture_ptr->error[i];
2588 if(s->flags&CODEC_FLAG_PASS1)
2589 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2590 flush_put_bits(&s->pb);
2591 s->frame_bits = put_bits_count(&s->pb);
2593 stuffing_count= ff_vbv_update(s, s->frame_bits);
2595 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2596 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2600 switch(s->codec_id){
2601 case CODEC_ID_MPEG1VIDEO:
2602 case CODEC_ID_MPEG2VIDEO:
2603 while(stuffing_count--){
2604 put_bits(&s->pb, 8, 0);
2607 case CODEC_ID_MPEG4:
2608 put_bits(&s->pb, 16, 0);
2609 put_bits(&s->pb, 16, 0x1C3);
2610 stuffing_count -= 4;
2611 while(stuffing_count--){
2612 put_bits(&s->pb, 8, 0xFF);
2616 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2618 flush_put_bits(&s->pb);
2619 s->frame_bits = put_bits_count(&s->pb);
2622 /* update mpeg1/2 vbv_delay for CBR */
2623 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2624 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2627 assert(s->repeat_first_field==0);
2629 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2630 assert(vbv_delay < 0xFFFF);
2632 s->vbv_delay_ptr[0] &= 0xF8;
2633 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2634 s->vbv_delay_ptr[1] = vbv_delay>>5;
2635 s->vbv_delay_ptr[2] &= 0x07;
2636 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2638 s->total_bits += s->frame_bits;
2639 avctx->frame_bits = s->frame_bits;
2641 assert((pbBufPtr(&s->pb) == s->pb.buf));
2644 assert((s->frame_bits&7)==0);
2646 return s->frame_bits/8;
2649 #endif //CONFIG_ENCODERS
2651 static inline void gmc1_motion(MpegEncContext *s,
2652 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2653 uint8_t **ref_picture)
2656 int offset, src_x, src_y, linesize, uvlinesize;
2657 int motion_x, motion_y;
2660 motion_x= s->sprite_offset[0][0];
2661 motion_y= s->sprite_offset[0][1];
2662 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2663 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2664 motion_x<<=(3-s->sprite_warping_accuracy);
2665 motion_y<<=(3-s->sprite_warping_accuracy);
2666 src_x = av_clip(src_x, -16, s->width);
2667 if (src_x == s->width)
2669 src_y = av_clip(src_y, -16, s->height);
2670 if (src_y == s->height)
2673 linesize = s->linesize;
2674 uvlinesize = s->uvlinesize;
2676 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2678 if(s->flags&CODEC_FLAG_EMU_EDGE){
2679 if( (unsigned)src_x >= s->h_edge_pos - 17
2680 || (unsigned)src_y >= s->v_edge_pos - 17){
2681 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2682 ptr= s->edge_emu_buffer;
2686 if((motion_x|motion_y)&7){
2687 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2688 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2692 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2693 if (s->no_rounding){
2694 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2696 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2700 if(s->flags&CODEC_FLAG_GRAY) return;
2702 motion_x= s->sprite_offset[1][0];
2703 motion_y= s->sprite_offset[1][1];
2704 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2705 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2706 motion_x<<=(3-s->sprite_warping_accuracy);
2707 motion_y<<=(3-s->sprite_warping_accuracy);
2708 src_x = av_clip(src_x, -8, s->width>>1);
2709 if (src_x == s->width>>1)
2711 src_y = av_clip(src_y, -8, s->height>>1);
2712 if (src_y == s->height>>1)
2715 offset = (src_y * uvlinesize) + src_x;
2716 ptr = ref_picture[1] + offset;
2717 if(s->flags&CODEC_FLAG_EMU_EDGE){
2718 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2719 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2720 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);
2721 ptr= s->edge_emu_buffer;
2725 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2727 ptr = ref_picture[2] + offset;
2729 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);
2730 ptr= s->edge_emu_buffer;
2732 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2737 static inline void gmc_motion(MpegEncContext *s,
2738 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2739 uint8_t **ref_picture)
2742 int linesize, uvlinesize;
2743 const int a= s->sprite_warping_accuracy;
2746 linesize = s->linesize;
2747 uvlinesize = s->uvlinesize;
2749 ptr = ref_picture[0];
2751 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2752 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2754 s->dsp.gmc(dest_y, ptr, linesize, 16,
2757 s->sprite_delta[0][0], s->sprite_delta[0][1],
2758 s->sprite_delta[1][0], s->sprite_delta[1][1],
2759 a+1, (1<<(2*a+1)) - s->no_rounding,
2760 s->h_edge_pos, s->v_edge_pos);
2761 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2762 ox + s->sprite_delta[0][0]*8,
2763 oy + s->sprite_delta[1][0]*8,
2764 s->sprite_delta[0][0], s->sprite_delta[0][1],
2765 s->sprite_delta[1][0], s->sprite_delta[1][1],
2766 a+1, (1<<(2*a+1)) - s->no_rounding,
2767 s->h_edge_pos, s->v_edge_pos);
2769 if(s->flags&CODEC_FLAG_GRAY) return;
2771 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2772 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2774 ptr = ref_picture[1];
2775 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2778 s->sprite_delta[0][0], s->sprite_delta[0][1],
2779 s->sprite_delta[1][0], s->sprite_delta[1][1],
2780 a+1, (1<<(2*a+1)) - s->no_rounding,
2781 s->h_edge_pos>>1, s->v_edge_pos>>1);
2783 ptr = ref_picture[2];
2784 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2787 s->sprite_delta[0][0], s->sprite_delta[0][1],
2788 s->sprite_delta[1][0], s->sprite_delta[1][1],
2789 a+1, (1<<(2*a+1)) - s->no_rounding,
2790 s->h_edge_pos>>1, s->v_edge_pos>>1);
2794 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2795 * @param buf destination buffer
2796 * @param src source buffer
2797 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2798 * @param block_w width of block
2799 * @param block_h height of block
2800 * @param src_x x coordinate of the top left sample of the block in the source buffer
2801 * @param src_y y coordinate of the top left sample of the block in the source buffer
2802 * @param w width of the source buffer
2803 * @param h height of the source buffer
2805 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2806 int src_x, int src_y, int w, int h){
2808 int start_y, start_x, end_y, end_x;
2811 src+= (h-1-src_y)*linesize;
2813 }else if(src_y<=-block_h){
2814 src+= (1-block_h-src_y)*linesize;
2820 }else if(src_x<=-block_w){
2821 src+= (1-block_w-src_x);
2825 start_y= FFMAX(0, -src_y);
2826 start_x= FFMAX(0, -src_x);
2827 end_y= FFMIN(block_h, h-src_y);
2828 end_x= FFMIN(block_w, w-src_x);
2830 // copy existing part
2831 for(y=start_y; y<end_y; y++){
2832 for(x=start_x; x<end_x; x++){
2833 buf[x + y*linesize]= src[x + y*linesize];
2838 for(y=0; y<start_y; y++){
2839 for(x=start_x; x<end_x; x++){
2840 buf[x + y*linesize]= buf[x + start_y*linesize];
2845 for(y=end_y; y<block_h; y++){
2846 for(x=start_x; x<end_x; x++){
2847 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2851 for(y=0; y<block_h; y++){
2853 for(x=0; x<start_x; x++){
2854 buf[x + y*linesize]= buf[start_x + y*linesize];
2858 for(x=end_x; x<block_w; x++){
2859 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2864 static inline int hpel_motion(MpegEncContext *s,
2865 uint8_t *dest, uint8_t *src,
2866 int field_based, int field_select,
2867 int src_x, int src_y,
2868 int width, int height, int stride,
2869 int h_edge_pos, int v_edge_pos,
2870 int w, int h, op_pixels_func *pix_op,
2871 int motion_x, int motion_y)
2876 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2877 src_x += motion_x >> 1;
2878 src_y += motion_y >> 1;
2880 /* WARNING: do no forget half pels */
2881 src_x = av_clip(src_x, -16, width); //FIXME unneeded for emu?
2884 src_y = av_clip(src_y, -16, height);
2885 if (src_y == height)
2887 src += src_y * stride + src_x;
2889 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2890 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2891 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2892 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2893 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2894 src= s->edge_emu_buffer;
2900 pix_op[dxy](dest, src, stride, h);
2904 static inline int hpel_motion_lowres(MpegEncContext *s,
2905 uint8_t *dest, uint8_t *src,
2906 int field_based, int field_select,
2907 int src_x, int src_y,
2908 int width, int height, int stride,
2909 int h_edge_pos, int v_edge_pos,
2910 int w, int h, h264_chroma_mc_func *pix_op,
2911 int motion_x, int motion_y)
2913 const int lowres= s->avctx->lowres;
2914 const int s_mask= (2<<lowres)-1;
2918 if(s->quarter_sample){
2923 sx= motion_x & s_mask;
2924 sy= motion_y & s_mask;
2925 src_x += motion_x >> (lowres+1);
2926 src_y += motion_y >> (lowres+1);
2928 src += src_y * stride + src_x;
2930 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2931 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2932 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2933 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2934 src= s->edge_emu_buffer;
2942 pix_op[lowres](dest, src, stride, h, sx, sy);
2946 /* apply one mpeg motion vector to the three components */
2947 static av_always_inline void mpeg_motion(MpegEncContext *s,
2948 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2949 int field_based, int bottom_field, int field_select,
2950 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2951 int motion_x, int motion_y, int h)
2953 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2954 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2957 if(s->quarter_sample)
2964 v_edge_pos = s->v_edge_pos >> field_based;
2965 linesize = s->current_picture.linesize[0] << field_based;
2966 uvlinesize = s->current_picture.linesize[1] << field_based;
2968 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2969 src_x = s->mb_x* 16 + (motion_x >> 1);
2970 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2972 if (s->out_format == FMT_H263) {
2973 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2974 mx = (motion_x>>1)|(motion_x&1);
2976 uvdxy = ((my & 1) << 1) | (mx & 1);
2977 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2978 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2980 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2984 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2988 uvsrc_x = s->mb_x*8 + mx;
2989 uvsrc_y = s->mb_y*8 + my;
2991 if(s->chroma_y_shift){
2994 uvdxy = ((my & 1) << 1) | (mx & 1);
2995 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2996 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2998 if(s->chroma_x_shift){
3001 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
3002 uvsrc_x = s->mb_x* 8 + (mx >> 1);
3013 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3014 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3015 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3017 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
3018 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
3019 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
3020 s->codec_id == CODEC_ID_MPEG1VIDEO){
3021 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
3024 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3025 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3026 ptr_y = s->edge_emu_buffer;
3027 if(!(s->flags&CODEC_FLAG_GRAY)){
3028 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3029 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3030 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3031 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3032 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3038 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3039 dest_y += s->linesize;
3040 dest_cb+= s->uvlinesize;
3041 dest_cr+= s->uvlinesize;
3045 ptr_y += s->linesize;
3046 ptr_cb+= s->uvlinesize;
3047 ptr_cr+= s->uvlinesize;
3050 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
3052 if(!(s->flags&CODEC_FLAG_GRAY)){
3053 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3054 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3056 if((ENABLE_H261_ENCODER || ENABLE_H261_DECODER) && s->out_format == FMT_H261){
3057 ff_h261_loop_filter(s);
3061 /* apply one mpeg motion vector to the three components */
3062 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
3063 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3064 int field_based, int bottom_field, int field_select,
3065 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3066 int motion_x, int motion_y, int h)
3068 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3069 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3070 const int lowres= s->avctx->lowres;
3071 const int block_s= 8>>lowres;
3072 const int s_mask= (2<<lowres)-1;
3073 const int h_edge_pos = s->h_edge_pos >> lowres;
3074 const int v_edge_pos = s->v_edge_pos >> lowres;
3075 linesize = s->current_picture.linesize[0] << field_based;
3076 uvlinesize = s->current_picture.linesize[1] << field_based;
3078 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3084 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3087 sx= motion_x & s_mask;
3088 sy= motion_y & s_mask;
3089 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3090 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3092 if (s->out_format == FMT_H263) {
3093 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3094 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3097 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3100 uvsx = (2*mx) & s_mask;
3101 uvsy = (2*my) & s_mask;
3102 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3103 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3109 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3110 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3113 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3114 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3115 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3117 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3118 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3119 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3120 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3121 ptr_y = s->edge_emu_buffer;
3122 if(!(s->flags&CODEC_FLAG_GRAY)){
3123 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3124 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3125 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3126 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3127 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3133 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3134 dest_y += s->linesize;
3135 dest_cb+= s->uvlinesize;
3136 dest_cr+= s->uvlinesize;
3140 ptr_y += s->linesize;
3141 ptr_cb+= s->uvlinesize;
3142 ptr_cr+= s->uvlinesize;
3147 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3149 if(!(s->flags&CODEC_FLAG_GRAY)){
3150 uvsx <<= 2 - lowres;
3151 uvsy <<= 2 - lowres;
3152 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3153 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3155 //FIXME h261 lowres loop filter
3158 //FIXME move to dsputil, avg variant, 16x16 version
3159 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3161 uint8_t * const top = src[1];
3162 uint8_t * const left = src[2];
3163 uint8_t * const mid = src[0];
3164 uint8_t * const right = src[3];
3165 uint8_t * const bottom= src[4];
3166 #define OBMC_FILTER(x, t, l, m, r, b)\
3167 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3168 #define OBMC_FILTER4(x, t, l, m, r, b)\
3169 OBMC_FILTER(x , t, l, m, r, b);\
3170 OBMC_FILTER(x+1 , t, l, m, r, b);\
3171 OBMC_FILTER(x +stride, t, l, m, r, b);\
3172 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3175 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3176 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3177 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3178 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3179 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3180 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3182 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3183 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3184 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3185 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3187 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3188 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3189 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3190 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3192 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3193 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3194 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3195 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3197 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3198 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3199 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3200 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3201 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3202 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3204 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3205 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3206 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3207 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3210 /* obmc for 1 8x8 luma block */
3211 static inline void obmc_motion(MpegEncContext *s,
3212 uint8_t *dest, uint8_t *src,
3213 int src_x, int src_y,
3214 op_pixels_func *pix_op,
3215 int16_t mv[5][2]/* mid top left right bottom*/)
3221 assert(s->quarter_sample==0);
3224 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3227 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3228 hpel_motion(s, ptr[i], src, 0, 0,
3230 s->width, s->height, s->linesize,
3231 s->h_edge_pos, s->v_edge_pos,
3233 mv[i][0], mv[i][1]);
3237 put_obmc(dest, ptr, s->linesize);
3240 static inline void qpel_motion(MpegEncContext *s,
3241 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3242 int field_based, int bottom_field, int field_select,
3243 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3244 qpel_mc_func (*qpix_op)[16],
3245 int motion_x, int motion_y, int h)
3247 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3248 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3250 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3251 src_x = s->mb_x * 16 + (motion_x >> 2);
3252 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3254 v_edge_pos = s->v_edge_pos >> field_based;
3255 linesize = s->linesize << field_based;
3256 uvlinesize = s->uvlinesize << field_based;
3261 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3262 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3263 mx= (motion_x>>1) + rtab[motion_x&7];
3264 my= (motion_y>>1) + rtab[motion_y&7];
3265 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3266 mx= (motion_x>>1)|(motion_x&1);
3267 my= (motion_y>>1)|(motion_y&1);
3275 uvdxy= (mx&1) | ((my&1)<<1);
3279 uvsrc_x = s->mb_x * 8 + mx;
3280 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3282 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3283 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3284 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3286 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3287 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3288 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3289 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3290 ptr_y= s->edge_emu_buffer;
3291 if(!(s->flags&CODEC_FLAG_GRAY)){
3292 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3293 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3294 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3295 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3296 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3303 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3306 dest_y += s->linesize;
3307 dest_cb+= s->uvlinesize;
3308 dest_cr+= s->uvlinesize;
3312 ptr_y += s->linesize;
3313 ptr_cb += s->uvlinesize;
3314 ptr_cr += s->uvlinesize;
3316 //damn interlaced mode
3317 //FIXME boundary mirroring is not exactly correct here
3318 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3319 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3321 if(!(s->flags&CODEC_FLAG_GRAY)){
3322 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3323 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3327 inline int ff_h263_round_chroma(int x){
3329 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3332 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3337 * h263 chorma 4mv motion compensation.
3339 static inline void chroma_4mv_motion(MpegEncContext *s,
3340 uint8_t *dest_cb, uint8_t *dest_cr,
3341 uint8_t **ref_picture,
3342 op_pixels_func *pix_op,
3344 int dxy, emu=0, src_x, src_y, offset;
3347 /* In case of 8X8, we construct a single chroma motion vector
3348 with a special rounding */
3349 mx= ff_h263_round_chroma(mx);
3350 my= ff_h263_round_chroma(my);
3352 dxy = ((my & 1) << 1) | (mx & 1);
3356 src_x = s->mb_x * 8 + mx;
3357 src_y = s->mb_y * 8 + my;
3358 src_x = av_clip(src_x, -8, s->width/2);
3359 if (src_x == s->width/2)
3361 src_y = av_clip(src_y, -8, s->height/2);
3362 if (src_y == s->height/2)
3365 offset = (src_y * (s->uvlinesize)) + src_x;
3366 ptr = ref_picture[1] + offset;
3367 if(s->flags&CODEC_FLAG_EMU_EDGE){
3368 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3369 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3370 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);
3371 ptr= s->edge_emu_buffer;
3375 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3377 ptr = ref_picture[2] + offset;
3379 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);
3380 ptr= s->edge_emu_buffer;
3382 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3385 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3386 uint8_t *dest_cb, uint8_t *dest_cr,
3387 uint8_t **ref_picture,
3388 h264_chroma_mc_func *pix_op,
3390 const int lowres= s->avctx->lowres;
3391 const int block_s= 8>>lowres;
3392 const int s_mask= (2<<lowres)-1;
3393 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3394 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3395 int emu=0, src_x, src_y, offset, sx, sy;
3398 if(s->quarter_sample){
3403 /* In case of 8X8, we construct a single chroma motion vector
3404 with a special rounding */
3405 mx= ff_h263_round_chroma(mx);
3406 my= ff_h263_round_chroma(my);
3410 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3411 src_y = s->mb_y*block_s + (my >> (lowres+1));
3413 offset = src_y * s->uvlinesize + src_x;
3414 ptr = ref_picture[1] + offset;
3415 if(s->flags&CODEC_FLAG_EMU_EDGE){
3416 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3417 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3418 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3419 ptr= s->edge_emu_buffer;
3425 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3427 ptr = ref_picture[2] + offset;
3429 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3430 ptr= s->edge_emu_buffer;
3432 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3435 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3436 /* fetch pixels for estimated mv 4 macroblocks ahead
3437 * optimized for 64byte cache lines */
3438 const int shift = s->quarter_sample ? 2 : 1;
3439 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3440 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3441 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3442 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3443 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3444 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3448 * motion compensation of a single macroblock
3450 * @param dest_y luma destination pointer
3451 * @param dest_cb chroma cb/u destination pointer
3452 * @param dest_cr chroma cr/v destination pointer
3453 * @param dir direction (0->forward, 1->backward)
3454 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3455 * @param pic_op halfpel motion compensation function (average or put normally)
3456 * @param pic_op qpel motion compensation function (average or put normally)
3457 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3459 static inline void MPV_motion(MpegEncContext *s,
3460 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3461 int dir, uint8_t **ref_picture,
3462 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3464 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3466 uint8_t *ptr, *dest;
3471 prefetch_motion(s, ref_picture, dir);
3473 if(s->obmc && s->pict_type != B_TYPE){
3474 int16_t mv_cache[4][4][2];
3475 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3476 const int mot_stride= s->b8_stride;
3477 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3479 assert(!s->mb_skipped);
3481 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3482 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3483 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3485 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3486 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3488 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3491 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3492 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3493 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3495 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3496 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3499 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3500 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3501 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3503 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3504 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3510 const int x= (i&1)+1;
3511 const int y= (i>>1)+1;