2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
24 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "mpegvideo.h"
34 #include "fastmemcpy.h"
40 #ifdef CONFIG_ENCODERS
41 static void encode_picture(MpegEncContext *s, int picture_number);
42 #endif //CONFIG_ENCODERS
43 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
44 DCTELEM *block, int n, int qscale);
45 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
46 DCTELEM *block, int n, int qscale);
47 static void dct_unquantize_h263_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
50 #ifdef CONFIG_ENCODERS
51 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
52 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
53 static int sse_mb(MpegEncContext *s);
54 #endif //CONFIG_ENCODERS
57 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58 extern void XVMC_field_end(MpegEncContext *s);
59 extern void XVMC_decode_mb(MpegEncContext *s);
62 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
65 /* enable all paranoid tests for rounding, overflows, etc... */
71 /* for jpeg fast DCT */
74 static const uint16_t aanscales[64] = {
75 /* precomputed values scaled up by 14 bits */
76 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
77 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
78 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
79 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
80 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
81 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
82 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
83 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
86 static const uint8_t h263_chroma_roundtab[16] = {
87 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
88 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
91 static const uint8_t ff_default_chroma_qscale_table[32]={
92 // 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
93 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
96 #ifdef CONFIG_ENCODERS
97 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
98 static uint8_t default_fcode_tab[MAX_MV*2+1];
100 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
102 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
103 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
107 for(qscale=qmin; qscale<=qmax; qscale++){
109 if (dsp->fdct == ff_jpeg_fdct_islow
110 #ifdef FAAN_POSTSCALE
111 || dsp->fdct == ff_faandct
115 const int j= dsp->idct_permutation[i];
116 /* 16 <= qscale * quant_matrix[i] <= 7905 */
117 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
118 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
119 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
121 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
122 (qscale * quant_matrix[j]));
124 } else if (dsp->fdct == fdct_ifast
125 #ifndef FAAN_POSTSCALE
126 || dsp->fdct == ff_faandct
130 const int j= dsp->idct_permutation[i];
131 /* 16 <= qscale * quant_matrix[i] <= 7905 */
132 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
133 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
134 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
136 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
137 (aanscales[i] * qscale * quant_matrix[j]));
141 const int j= dsp->idct_permutation[i];
142 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
143 So 16 <= qscale * quant_matrix[i] <= 7905
144 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
145 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
147 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
148 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
149 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
151 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
152 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
158 static inline void update_qscale(MpegEncContext *s){
159 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
160 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
162 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
164 #endif //CONFIG_ENCODERS
166 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
170 st->scantable= src_scantable;
174 j = src_scantable[i];
175 st->permutated[i] = permutation[j];
184 j = st->permutated[i];
186 st->raster_end[i]= end;
190 #ifdef CONFIG_ENCODERS
191 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
197 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
202 #endif //CONFIG_ENCODERS
204 /* init common dct for both encoder and decoder */
205 int DCT_common_init(MpegEncContext *s)
207 s->dct_unquantize_h263 = dct_unquantize_h263_c;
208 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
209 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
211 #ifdef CONFIG_ENCODERS
212 s->dct_quantize= dct_quantize_c;
216 MPV_common_init_mmx(s);
219 MPV_common_init_axp(s);
222 MPV_common_init_mlib(s);
225 MPV_common_init_mmi(s);
228 MPV_common_init_armv4l(s);
231 MPV_common_init_ppc(s);
234 #ifdef CONFIG_ENCODERS
235 s->fast_dct_quantize= s->dct_quantize;
237 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
238 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
241 #endif //CONFIG_ENCODERS
243 /* load & permutate scantables
244 note: only wmv uses differnt ones
246 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
247 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
248 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
249 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
251 s->picture_structure= PICT_FRAME;
256 static void copy_picture(Picture *dst, Picture *src){
258 dst->type= FF_BUFFER_TYPE_COPY;
262 * allocates a Picture
263 * The pixels are allocated/set by calling get_buffer() if shared=0
265 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
266 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
267 const int mb_array_size= s->mb_stride*s->mb_height;
268 const int b8_array_size= s->b8_stride*s->mb_height*2;
269 const int b4_array_size= s->b4_stride*s->mb_height*4;
273 assert(pic->data[0]);
274 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
275 pic->type= FF_BUFFER_TYPE_SHARED;
279 assert(!pic->data[0]);
281 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
283 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
284 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
288 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
289 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
293 if(pic->linesize[1] != pic->linesize[2]){
294 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
298 s->linesize = pic->linesize[0];
299 s->uvlinesize= pic->linesize[1];
302 if(pic->qscale_table==NULL){
304 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
305 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
306 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
309 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
310 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
311 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(int))
312 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
313 if(s->out_format == FMT_H264){
315 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+1) * sizeof(uint16_t))
316 pic->motion_val[i]= pic->motion_val_base[i]+1;
317 CHECKED_ALLOCZ(pic->ref_index[i] , b8_array_size * sizeof(uint8_t))
319 pic->motion_subsample_log2= 2;
320 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&(FF_DEBUG_VIS_MV|FF_DEBUG_MV))){
322 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+1) * sizeof(uint16_t)*2) //FIXME
323 pic->motion_val[i]= pic->motion_val_base[i]+1;
325 pic->motion_subsample_log2= 3;
327 pic->qstride= s->mb_stride;
328 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
331 //it might be nicer if the application would keep track of these but it would require a API change
332 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
333 s->prev_pict_types[0]= s->pict_type;
334 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
335 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
338 fail: //for the CHECKED_ALLOCZ macro
343 * deallocates a picture
345 static void free_picture(MpegEncContext *s, Picture *pic){
348 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
349 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
352 av_freep(&pic->mb_var);
353 av_freep(&pic->mc_mb_var);
354 av_freep(&pic->mb_mean);
355 av_freep(&pic->mbskip_table);
356 av_freep(&pic->qscale_table);
357 av_freep(&pic->mb_type_base);
358 av_freep(&pic->pan_scan);
361 av_freep(&pic->motion_val_base[i]);
362 av_freep(&pic->ref_index[i]);
365 if(pic->type == FF_BUFFER_TYPE_SHARED){
374 /* init common structure for both encoder and decoder */
375 int MPV_common_init(MpegEncContext *s)
377 int y_size, c_size, yc_size, i, mb_array_size, x, y;
379 dsputil_init(&s->dsp, s->avctx);
382 s->flags= s->avctx->flags;
384 s->mb_width = (s->width + 15) / 16;
385 s->mb_height = (s->height + 15) / 16;
386 s->mb_stride = s->mb_width + 1;
387 s->b8_stride = s->mb_width*2 + 1;
388 s->b4_stride = s->mb_width*4 + 1;
389 mb_array_size= s->mb_height * s->mb_stride;
391 /* set default edge pos, will be overriden in decode_header if needed */
392 s->h_edge_pos= s->mb_width*16;
393 s->v_edge_pos= s->mb_height*16;
395 s->mb_num = s->mb_width * s->mb_height;
400 s->block_wrap[3]= s->mb_width*2 + 2;
402 s->block_wrap[5]= s->mb_width + 2;
405 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
406 s->chroma_qscale_table= ff_default_chroma_qscale_table;
408 s->progressive_sequence= 1;
409 s->progressive_frame= 1;
411 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
412 c_size = (s->mb_width + 2) * (s->mb_height + 2);
413 yc_size = y_size + 2 * c_size;
415 /* convert fourcc to upper case */
416 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
417 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
418 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
419 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
421 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
422 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
423 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
424 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
426 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
427 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
429 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
431 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
432 for(y=0; y<s->mb_height; y++){
433 for(x=0; x<s->mb_width; x++){
434 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
437 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
440 int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
442 /* Allocate MV tables */
443 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
444 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
445 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
446 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
447 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
448 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
449 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
450 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
451 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
452 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
453 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
454 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
456 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
457 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t))
459 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
460 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
462 if(s->codec_id==CODEC_ID_MPEG4){
463 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
464 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
467 if(s->msmpeg4_version){
468 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
470 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
472 /* Allocate MB type table */
473 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint8_t)) //needed for encoding
475 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
477 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
478 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
479 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
480 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
481 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
482 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
484 if(s->avctx->noise_reduction){
485 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
486 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
489 CHECKED_ALLOCZ(s->blocks, 64*6*2 * sizeof(DCTELEM))
491 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
493 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
495 if(s->codec_id==CODEC_ID_MPEG4){
496 /* interlaced direct mode decoding tables */
497 CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
498 CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
500 if (s->out_format == FMT_H263) {
502 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
503 s->ac_val[1] = s->ac_val[0] + y_size;
504 s->ac_val[2] = s->ac_val[1] + c_size;
507 CHECKED_ALLOCZ(s->coded_block, y_size);
509 /* divx501 bitstream reorder buffer */
510 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
512 /* cbp, ac_pred, pred_dir */
513 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
514 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
517 if (s->h263_pred || s->h263_plus || !s->encoding) {
519 //MN: we need these for error resilience of intra-frames
520 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
521 s->dc_val[1] = s->dc_val[0] + y_size;
522 s->dc_val[2] = s->dc_val[1] + c_size;
523 for(i=0;i<yc_size;i++)
524 s->dc_val[0][i] = 1024;
527 /* which mb is a intra block */
528 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
529 memset(s->mbintra_table, 1, mb_array_size);
531 /* default structure is frame */
532 s->picture_structure = PICT_FRAME;
534 /* init macroblock skip table */
535 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
536 //Note the +1 is for a quicker mpeg4 slice_end detection
537 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
539 s->block= s->blocks[0];
542 s->pblocks[i] = (short *)(&s->block[i]);
545 s->parse_context.state= -1;
547 s->context_initialized = 1;
557 /* init common structure for both encoder and decoder */
558 void MPV_common_end(MpegEncContext *s)
562 av_freep(&s->parse_context.buffer);
563 s->parse_context.buffer_size=0;
565 av_freep(&s->mb_type);
566 av_freep(&s->p_mv_table_base);
567 av_freep(&s->b_forw_mv_table_base);
568 av_freep(&s->b_back_mv_table_base);
569 av_freep(&s->b_bidir_forw_mv_table_base);
570 av_freep(&s->b_bidir_back_mv_table_base);
571 av_freep(&s->b_direct_mv_table_base);
573 s->b_forw_mv_table= NULL;
574 s->b_back_mv_table= NULL;
575 s->b_bidir_forw_mv_table= NULL;
576 s->b_bidir_back_mv_table= NULL;
577 s->b_direct_mv_table= NULL;
579 av_freep(&s->dc_val[0]);
580 av_freep(&s->ac_val[0]);
581 av_freep(&s->coded_block);
582 av_freep(&s->mbintra_table);
583 av_freep(&s->cbp_table);
584 av_freep(&s->pred_dir_table);
585 av_freep(&s->me.scratchpad);
586 av_freep(&s->me.map);
587 av_freep(&s->me.score_map);
589 av_freep(&s->mbskip_table);
590 av_freep(&s->prev_pict_types);
591 av_freep(&s->bitstream_buffer);
592 av_freep(&s->tex_pb_buffer);
593 av_freep(&s->pb2_buffer);
594 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
595 av_freep(&s->field_mv_table);
596 av_freep(&s->field_select_table);
597 av_freep(&s->avctx->stats_out);
598 av_freep(&s->ac_stats);
599 av_freep(&s->error_status_table);
600 av_freep(&s->mb_index2xy);
601 av_freep(&s->lambda_table);
602 av_freep(&s->q_intra_matrix);
603 av_freep(&s->q_inter_matrix);
604 av_freep(&s->q_intra_matrix16);
605 av_freep(&s->q_inter_matrix16);
606 av_freep(&s->blocks);
607 av_freep(&s->input_picture);
608 av_freep(&s->reordered_input_picture);
609 av_freep(&s->dct_error_sum);
610 av_freep(&s->dct_offset);
613 for(i=0; i<MAX_PICTURE_COUNT; i++){
614 free_picture(s, &s->picture[i]);
617 av_freep(&s->picture);
618 avcodec_default_free_buffers(s->avctx);
619 s->context_initialized = 0;
622 s->current_picture_ptr= NULL;
625 #ifdef CONFIG_ENCODERS
627 /* init video encoder */
628 int MPV_encode_init(AVCodecContext *avctx)
630 MpegEncContext *s = avctx->priv_data;
632 int chroma_h_shift, chroma_v_shift;
634 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
636 s->bit_rate = avctx->bit_rate;
637 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
638 s->width = avctx->width;
639 s->height = avctx->height;
640 if(avctx->gop_size > 600){
641 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
644 s->gop_size = avctx->gop_size;
645 s->max_qdiff= avctx->max_qdiff;
646 s->qcompress= avctx->qcompress;
647 s->qblur= avctx->qblur;
649 s->flags= avctx->flags;
650 s->max_b_frames= avctx->max_b_frames;
651 s->b_frame_strategy= avctx->b_frame_strategy;
652 s->codec_id= avctx->codec->id;
653 s->luma_elim_threshold = avctx->luma_elim_threshold;
654 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
655 s->strict_std_compliance= avctx->strict_std_compliance;
656 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
657 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
658 s->mpeg_quant= avctx->mpeg_quant;
659 s->rtp_mode= !!avctx->rtp_payload_size;
661 if (s->gop_size <= 1) {
668 s->me_method = avctx->me_method;
671 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
673 s->adaptive_quant= ( s->avctx->lumi_masking
674 || s->avctx->dark_masking
675 || s->avctx->temporal_cplx_masking
676 || s->avctx->spatial_cplx_masking
677 || s->avctx->p_masking
678 || (s->flags&CODEC_FLAG_QP_RD))
681 s->obmc= (s->flags & CODEC_FLAG_OBMC);
682 s->loop_filter= (s->flags & CODEC_FLAG_LOOP_FILTER);
684 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
685 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
686 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
690 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
691 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
695 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
696 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
700 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
701 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
705 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
706 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
710 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
711 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
715 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
716 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
720 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
721 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
725 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
726 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
730 if(s->codec_id==CODEC_ID_MJPEG){
731 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
732 s->inter_quant_bias= 0;
733 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
734 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
735 s->inter_quant_bias= 0;
737 s->intra_quant_bias=0;
738 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
741 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
742 s->intra_quant_bias= avctx->intra_quant_bias;
743 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
744 s->inter_quant_bias= avctx->inter_quant_bias;
746 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
748 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
749 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
751 switch(avctx->codec->id) {
752 case CODEC_ID_MPEG1VIDEO:
753 s->out_format = FMT_MPEG1;
754 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
755 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
757 case CODEC_ID_MPEG2VIDEO:
758 s->out_format = FMT_MPEG1;
759 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
760 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
765 s->out_format = FMT_MJPEG;
766 s->intra_only = 1; /* force intra only for jpeg */
767 s->mjpeg_write_tables = 1; /* write all tables */
768 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
769 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
770 s->mjpeg_vsample[1] = 1;
771 s->mjpeg_vsample[2] = 1;
772 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
773 s->mjpeg_hsample[1] = 1;
774 s->mjpeg_hsample[2] = 1;
775 if (mjpeg_init(s) < 0)
782 if (h263_get_picture_format(s->width, s->height) == 7) {
783 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
786 s->out_format = FMT_H263;
787 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
792 s->out_format = FMT_H263;
795 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
796 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
797 s->modified_quant= s->h263_aic;
798 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
799 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
800 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
801 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
802 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
805 /* These are just to be sure */
810 s->out_format = FMT_H263;
811 s->h263_flv = 2; /* format = 1; 11-bit codes */
812 s->unrestricted_mv = 1;
813 s->rtp_mode=0; /* don't allow GOB */
818 s->out_format = FMT_H263;
823 s->out_format = FMT_H263;
825 s->unrestricted_mv = 1;
826 s->low_delay= s->max_b_frames ? 0 : 1;
827 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
829 case CODEC_ID_MSMPEG4V1:
830 s->out_format = FMT_H263;
833 s->unrestricted_mv = 1;
834 s->msmpeg4_version= 1;
838 case CODEC_ID_MSMPEG4V2:
839 s->out_format = FMT_H263;
842 s->unrestricted_mv = 1;
843 s->msmpeg4_version= 2;
847 case CODEC_ID_MSMPEG4V3:
848 s->out_format = FMT_H263;
851 s->unrestricted_mv = 1;
852 s->msmpeg4_version= 3;
853 s->flipflop_rounding=1;
858 s->out_format = FMT_H263;
861 s->unrestricted_mv = 1;
862 s->msmpeg4_version= 4;
863 s->flipflop_rounding=1;
868 s->out_format = FMT_H263;
871 s->unrestricted_mv = 1;
872 s->msmpeg4_version= 5;
873 s->flipflop_rounding=1;
882 { /* set up some save defaults, some codecs might override them later */
888 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
889 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
890 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
892 for(i=-16; i<16; i++){
893 default_fcode_tab[i + MAX_MV]= 1;
897 s->me.mv_penalty= default_mv_penalty;
898 s->fcode_tab= default_fcode_tab;
900 /* dont use mv_penalty table for crap MV as it would be confused */
901 //FIXME remove after fixing / removing old ME
902 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
907 if (MPV_common_init(s) < 0)
910 if(s->modified_quant)
911 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
912 s->progressive_frame=
913 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
917 #ifdef CONFIG_ENCODERS
919 if (s->out_format == FMT_H263)
921 if(s->msmpeg4_version)
922 ff_msmpeg4_encode_init(s);
924 if (s->out_format == FMT_MPEG1)
925 ff_mpeg1_encode_init(s);
928 /* init default q matrix */
930 int j= s->dsp.idct_permutation[i];
932 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
933 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
934 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
935 }else if(s->out_format == FMT_H263){
937 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
941 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
942 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
944 if(s->avctx->intra_matrix)
945 s->intra_matrix[j] = s->avctx->intra_matrix[i];
946 if(s->avctx->inter_matrix)
947 s->inter_matrix[j] = s->avctx->inter_matrix[i];
950 /* precompute matrix */
951 /* for mjpeg, we do include qscale in the matrix */
952 if (s->out_format != FMT_MJPEG) {
953 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
954 s->intra_matrix, s->intra_quant_bias, 1, 31);
955 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
956 s->inter_matrix, s->inter_quant_bias, 1, 31);
959 if(ff_rate_control_init(s) < 0)
962 s->picture_number = 0;
963 s->picture_in_gop_number = 0;
964 s->fake_picture_number = 0;
965 /* motion detector init */
972 int MPV_encode_end(AVCodecContext *avctx)
974 MpegEncContext *s = avctx->priv_data;
980 ff_rate_control_uninit(s);
983 if (s->out_format == FMT_MJPEG)
986 av_freep(&avctx->extradata);
991 #endif //CONFIG_ENCODERS
993 void init_rl(RLTable *rl)
995 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
996 uint8_t index_run[MAX_RUN+1];
997 int last, run, level, start, end, i;
999 /* compute max_level[], max_run[] and index_run[] */
1000 for(last=0;last<2;last++) {
1009 memset(max_level, 0, MAX_RUN + 1);
1010 memset(max_run, 0, MAX_LEVEL + 1);
1011 memset(index_run, rl->n, MAX_RUN + 1);
1012 for(i=start;i<end;i++) {
1013 run = rl->table_run[i];
1014 level = rl->table_level[i];
1015 if (index_run[run] == rl->n)
1017 if (level > max_level[run])
1018 max_level[run] = level;
1019 if (run > max_run[level])
1020 max_run[level] = run;
1022 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1023 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1024 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1025 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1026 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1027 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1031 /* draw the edges of width 'w' of an image of size width, height */
1032 //FIXME check that this is ok for mpeg4 interlaced
1033 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1035 uint8_t *ptr, *last_line;
1038 last_line = buf + (height - 1) * wrap;
1040 /* top and bottom */
1041 memcpy(buf - (i + 1) * wrap, buf, width);
1042 memcpy(last_line + (i + 1) * wrap, last_line, width);
1044 /* left and right */
1046 for(i=0;i<height;i++) {
1047 memset(ptr - w, ptr[0], w);
1048 memset(ptr + width, ptr[width-1], w);
1053 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1054 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1055 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1056 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1060 int ff_find_unused_picture(MpegEncContext *s, int shared){
1064 for(i=0; i<MAX_PICTURE_COUNT; i++){
1065 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1068 for(i=0; i<MAX_PICTURE_COUNT; i++){
1069 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1071 for(i=0; i<MAX_PICTURE_COUNT; i++){
1072 if(s->picture[i].data[0]==NULL) return i;
1080 static void update_noise_reduction(MpegEncContext *s){
1083 for(intra=0; intra<2; intra++){
1084 if(s->dct_count[intra] > (1<<16)){
1085 for(i=0; i<64; i++){
1086 s->dct_error_sum[intra][i] >>=1;
1088 s->dct_count[intra] >>= 1;
1091 for(i=0; i<64; i++){
1092 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);
1098 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1100 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1106 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1108 /* mark&release old frames */
1109 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
1110 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1112 /* release forgotten pictures */
1113 /* if(mpeg124/h263) */
1115 for(i=0; i<MAX_PICTURE_COUNT; i++){
1116 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1117 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1118 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1125 /* release non refernce frames */
1126 for(i=0; i<MAX_PICTURE_COUNT; i++){
1127 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1128 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1132 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1133 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1135 i= ff_find_unused_picture(s, 0);
1136 pic= (AVFrame*)&s->picture[i];
1139 pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1141 if(s->current_picture_ptr) //FIXME broken, we need a coded_picture_number in MpegEncContext
1142 pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
1144 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1147 s->current_picture_ptr= (Picture*)pic;
1148 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1149 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1152 s->current_picture_ptr->pict_type= s->pict_type;
1153 // if(s->flags && CODEC_FLAG_QSCALE)
1154 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1155 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1157 copy_picture(&s->current_picture, s->current_picture_ptr);
1159 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1160 if (s->pict_type != B_TYPE) {
1161 s->last_picture_ptr= s->next_picture_ptr;
1162 s->next_picture_ptr= s->current_picture_ptr;
1165 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1166 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1168 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1169 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1170 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1174 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1176 if(s->picture_structure!=PICT_FRAME){
1179 if(s->picture_structure == PICT_BOTTOM_FIELD){
1180 s->current_picture.data[i] += s->current_picture.linesize[i];
1182 s->current_picture.linesize[i] *= 2;
1183 s->last_picture.linesize[i] *=2;
1184 s->next_picture.linesize[i] *=2;
1189 s->hurry_up= s->avctx->hurry_up;
1190 s->error_resilience= avctx->error_resilience;
1192 /* set dequantizer, we cant do it during init as it might change for mpeg4
1193 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1194 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO)
1195 s->dct_unquantize = s->dct_unquantize_mpeg2;
1196 else if(s->out_format == FMT_H263)
1197 s->dct_unquantize = s->dct_unquantize_h263;
1199 s->dct_unquantize = s->dct_unquantize_mpeg1;
1201 if(s->dct_error_sum){
1202 assert(s->avctx->noise_reduction && s->encoding);
1204 update_noise_reduction(s);
1208 if(s->avctx->xvmc_acceleration)
1209 return XVMC_field_start(s, avctx);
1214 /* generic function for encode/decode called after a frame has been coded/decoded */
1215 void MPV_frame_end(MpegEncContext *s)
1218 /* draw edge for correct motion prediction if outside */
1220 //just to make sure that all data is rendered.
1221 if(s->avctx->xvmc_acceleration){
1225 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1226 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1227 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1228 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1232 s->last_pict_type = s->pict_type;
1233 if(s->pict_type!=B_TYPE){
1234 s->last_non_b_pict_type= s->pict_type;
1237 /* copy back current_picture variables */
1238 for(i=0; i<MAX_PICTURE_COUNT; i++){
1239 if(s->picture[i].data[0] == s->current_picture.data[0]){
1240 s->picture[i]= s->current_picture;
1244 assert(i<MAX_PICTURE_COUNT);
1248 /* release non refernce frames */
1249 for(i=0; i<MAX_PICTURE_COUNT; i++){
1250 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1251 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1255 // clear copies, to avoid confusion
1257 memset(&s->last_picture, 0, sizeof(Picture));
1258 memset(&s->next_picture, 0, sizeof(Picture));
1259 memset(&s->current_picture, 0, sizeof(Picture));
1264 * draws an line from (ex, ey) -> (sx, sy).
1265 * @param w width of the image
1266 * @param h height of the image
1267 * @param stride stride/linesize of the image
1268 * @param color color of the arrow
1270 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1273 sx= clip(sx, 0, w-1);
1274 sy= clip(sy, 0, h-1);
1275 ex= clip(ex, 0, w-1);
1276 ey= clip(ey, 0, h-1);
1278 buf[sy*stride + sx]+= color;
1280 if(ABS(ex - sx) > ABS(ey - sy)){
1285 buf+= sx + sy*stride;
1287 f= ((ey-sy)<<16)/ex;
1288 for(x= 0; x <= ex; x++){
1289 y= ((x*f) + (1<<15))>>16;
1290 buf[y*stride + x]+= color;
1297 buf+= sx + sy*stride;
1299 if(ey) f= ((ex-sx)<<16)/ey;
1301 for(y= 0; y <= ey; y++){
1302 x= ((y*f) + (1<<15))>>16;
1303 buf[y*stride + x]+= color;
1309 * draws an arrow from (ex, ey) -> (sx, sy).
1310 * @param w width of the image
1311 * @param h height of the image
1312 * @param stride stride/linesize of the image
1313 * @param color color of the arrow
1315 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1318 sx= clip(sx, -100, w+100);
1319 sy= clip(sy, -100, h+100);
1320 ex= clip(ex, -100, w+100);
1321 ey= clip(ey, -100, h+100);
1326 if(dx*dx + dy*dy > 3*3){
1329 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1331 //FIXME subpixel accuracy
1332 rx= ROUNDED_DIV(rx*3<<4, length);
1333 ry= ROUNDED_DIV(ry*3<<4, length);
1335 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1336 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1338 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1342 * prints debuging info for the given picture.
1344 void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1346 if(!pict || !pict->mb_type) return;
1348 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1351 for(y=0; y<s->mb_height; y++){
1352 for(x=0; x<s->mb_width; x++){
1353 if(s->avctx->debug&FF_DEBUG_SKIP){
1354 int count= s->mbskip_table[x + y*s->mb_stride];
1355 if(count>9) count=9;
1356 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1358 if(s->avctx->debug&FF_DEBUG_QP){
1359 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1361 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1362 int mb_type= pict->mb_type[x + y*s->mb_stride];
1364 //Type & MV direction
1366 av_log(s->avctx, AV_LOG_DEBUG, "P");
1367 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1368 av_log(s->avctx, AV_LOG_DEBUG, "A");
1369 else if(IS_INTRA4x4(mb_type))
1370 av_log(s->avctx, AV_LOG_DEBUG, "i");
1371 else if(IS_INTRA16x16(mb_type))
1372 av_log(s->avctx, AV_LOG_DEBUG, "I");
1373 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1374 av_log(s->avctx, AV_LOG_DEBUG, "d");
1375 else if(IS_DIRECT(mb_type))
1376 av_log(s->avctx, AV_LOG_DEBUG, "D");
1377 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1378 av_log(s->avctx, AV_LOG_DEBUG, "g");
1379 else if(IS_GMC(mb_type))
1380 av_log(s->avctx, AV_LOG_DEBUG, "G");
1381 else if(IS_SKIP(mb_type))
1382 av_log(s->avctx, AV_LOG_DEBUG, "S");
1383 else if(!USES_LIST(mb_type, 1))
1384 av_log(s->avctx, AV_LOG_DEBUG, ">");
1385 else if(!USES_LIST(mb_type, 0))
1386 av_log(s->avctx, AV_LOG_DEBUG, "<");
1388 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1389 av_log(s->avctx, AV_LOG_DEBUG, "X");
1394 av_log(s->avctx, AV_LOG_DEBUG, "+");
1395 else if(IS_16X8(mb_type))
1396 av_log(s->avctx, AV_LOG_DEBUG, "-");
1397 else if(IS_8X16(mb_type))
1398 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1399 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1400 av_log(s->avctx, AV_LOG_DEBUG, " ");
1402 av_log(s->avctx, AV_LOG_DEBUG, "?");
1405 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1406 av_log(s->avctx, AV_LOG_DEBUG, "=");
1408 av_log(s->avctx, AV_LOG_DEBUG, " ");
1410 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1412 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1416 if((s->avctx->debug&FF_DEBUG_VIS_MV) && pict->motion_val){
1417 const int shift= 1 + s->quarter_sample;
1419 uint8_t *ptr= pict->data[0];
1420 s->low_delay=0; //needed to see the vectors without trashing the buffers
1422 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1424 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1425 const int mb_index= mb_x + mb_y*s->mb_stride;
1426 if(IS_8X8(pict->mb_type[mb_index])){
1429 int sx= mb_x*16 + 4 + 8*(i&1);
1430 int sy= mb_y*16 + 4 + 8*(i>>1);
1431 int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1432 int mx= (pict->motion_val[0][xy][0]>>shift) + sx;
1433 int my= (pict->motion_val[0][xy][1]>>shift) + sy;
1434 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1436 }else if(IS_16X8(pict->mb_type[mb_index])){
1440 int sy=mb_y*16 + 4 + 8*i;
1441 int xy=1 + mb_x*2 + (mb_y*2 + 1 + i)*(s->mb_width*2 + 2);
1442 int mx=(pict->motion_val[0][xy][0]>>shift) + sx;
1443 int my=(pict->motion_val[0][xy][1]>>shift) + sy;
1444 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1447 int sx= mb_x*16 + 8;
1448 int sy= mb_y*16 + 8;
1449 int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1450 int mx= (pict->motion_val[0][xy][0]>>shift) + sx;
1451 int my= (pict->motion_val[0][xy][1]>>shift) + sy;
1452 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1454 s->mbskip_table[mb_index]=0;
1460 #ifdef CONFIG_ENCODERS
1462 static int get_sae(uint8_t *src, int ref, int stride){
1466 for(y=0; y<16; y++){
1467 for(x=0; x<16; x++){
1468 acc+= ABS(src[x+y*stride] - ref);
1475 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1482 for(y=0; y<h; y+=16){
1483 for(x=0; x<w; x+=16){
1484 int offset= x + y*stride;
1485 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1486 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1487 int sae = get_sae(src + offset, mean, stride);
1489 acc+= sae + 500 < sad;
1496 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1499 const int encoding_delay= s->max_b_frames;
1503 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1504 if(pic_arg->linesize[0] != s->linesize) direct=0;
1505 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1506 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1508 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1511 i= ff_find_unused_picture(s, 1);
1513 pic= (AVFrame*)&s->picture[i];
1517 pic->data[i]= pic_arg->data[i];
1518 pic->linesize[i]= pic_arg->linesize[i];
1520 alloc_picture(s, (Picture*)pic, 1);
1523 i= ff_find_unused_picture(s, 0);
1525 pic= (AVFrame*)&s->picture[i];
1528 alloc_picture(s, (Picture*)pic, 0);
1530 if( pic->data[0] + offset == pic_arg->data[0]
1531 && pic->data[1] + offset == pic_arg->data[1]
1532 && pic->data[2] + offset == pic_arg->data[2]){
1535 int h_chroma_shift, v_chroma_shift;
1536 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1539 int src_stride= pic_arg->linesize[i];
1540 int dst_stride= i ? s->uvlinesize : s->linesize;
1541 int h_shift= i ? h_chroma_shift : 0;
1542 int v_shift= i ? v_chroma_shift : 0;
1543 int w= s->width >>h_shift;
1544 int h= s->height>>v_shift;
1545 uint8_t *src= pic_arg->data[i];
1546 uint8_t *dst= pic->data[i] + offset;
1548 if(src_stride==dst_stride)
1549 memcpy(dst, src, src_stride*h);
1552 memcpy(dst, src, w);
1560 pic->quality= pic_arg->quality;
1561 pic->pict_type= pic_arg->pict_type;
1562 pic->pts = pic_arg->pts;
1563 pic->interlaced_frame = pic_arg->interlaced_frame;
1564 pic->top_field_first = pic_arg->top_field_first;
1566 if(s->input_picture[encoding_delay])
1567 pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1571 /* shift buffer entries */
1572 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1573 s->input_picture[i-1]= s->input_picture[i];
1575 s->input_picture[encoding_delay]= (Picture*)pic;
1580 static void select_input_picture(MpegEncContext *s){
1582 int coded_pic_num=0;
1584 if(s->reordered_input_picture[0])
1585 coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1587 for(i=1; i<MAX_PICTURE_COUNT; i++)
1588 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1589 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1591 /* set next picture types & ordering */
1592 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1593 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1594 s->reordered_input_picture[0]= s->input_picture[0];
1595 s->reordered_input_picture[0]->pict_type= I_TYPE;
1596 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1600 if(s->flags&CODEC_FLAG_PASS2){
1601 for(i=0; i<s->max_b_frames+1; i++){
1602 int pict_num= s->input_picture[0]->display_picture_number + i;
1603 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1604 s->input_picture[i]->pict_type= pict_type;
1606 if(i + 1 >= s->rc_context.num_entries) break;
1610 if(s->input_picture[0]->pict_type){
1611 /* user selected pict_type */
1612 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1613 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1616 if(b_frames > s->max_b_frames){
1617 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
1618 b_frames = s->max_b_frames;
1620 }else if(s->b_frame_strategy==0){
1621 b_frames= s->max_b_frames;
1622 while(b_frames && !s->input_picture[b_frames]) b_frames--;
1623 }else if(s->b_frame_strategy==1){
1624 for(i=1; i<s->max_b_frames+1; i++){
1625 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1626 s->input_picture[i]->b_frame_score=
1627 get_intra_count(s, s->input_picture[i ]->data[0],
1628 s->input_picture[i-1]->data[0], s->linesize) + 1;
1631 for(i=0; i<s->max_b_frames; i++){
1632 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1635 b_frames= FFMAX(0, i-1);
1638 for(i=0; i<b_frames+1; i++){
1639 s->input_picture[i]->b_frame_score=0;
1642 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1647 //static int b_count=0;
1648 //b_count+= b_frames;
1649 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
1651 s->reordered_input_picture[0]= s->input_picture[b_frames];
1652 if( s->picture_in_gop_number + b_frames >= s->gop_size
1653 || s->reordered_input_picture[0]->pict_type== I_TYPE)
1654 s->reordered_input_picture[0]->pict_type= I_TYPE;
1656 s->reordered_input_picture[0]->pict_type= P_TYPE;
1657 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1658 for(i=0; i<b_frames; i++){
1660 s->reordered_input_picture[i+1]= s->input_picture[i];
1661 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1662 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1667 if(s->reordered_input_picture[0]){
1668 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1670 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
1672 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1673 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1675 int i= ff_find_unused_picture(s, 0);
1676 Picture *pic= &s->picture[i];
1678 /* mark us unused / free shared pic */
1680 s->reordered_input_picture[0]->data[i]= NULL;
1681 s->reordered_input_picture[0]->type= 0;
1683 //FIXME bad, copy * except
1684 pic->pict_type = s->reordered_input_picture[0]->pict_type;
1685 pic->quality = s->reordered_input_picture[0]->quality;
1686 pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1687 pic->reference = s->reordered_input_picture[0]->reference;
1688 pic->pts = s->reordered_input_picture[0]->pts;
1690 alloc_picture(s, pic, 0);
1692 s->current_picture_ptr= pic;
1694 // input is not a shared pix -> reuse buffer for current_pix
1696 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1697 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1699 s->current_picture_ptr= s->reordered_input_picture[0];
1701 s->new_picture.data[i]+=16;
1704 copy_picture(&s->current_picture, s->current_picture_ptr);
1706 s->picture_number= s->new_picture.display_picture_number;
1707 //printf("dpn:%d\n", s->picture_number);
1709 memset(&s->new_picture, 0, sizeof(Picture));
1713 int MPV_encode_picture(AVCodecContext *avctx,
1714 unsigned char *buf, int buf_size, void *data)
1716 MpegEncContext *s = avctx->priv_data;
1717 AVFrame *pic_arg = data;
1718 int i, stuffing_count;
1720 if(avctx->pix_fmt != PIX_FMT_YUV420P){
1721 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
1725 init_put_bits(&s->pb, buf, buf_size);
1727 s->picture_in_gop_number++;
1729 load_input_picture(s, pic_arg);
1731 select_input_picture(s);
1734 if(s->new_picture.data[0]){
1736 s->pict_type= s->new_picture.pict_type;
1738 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1739 MPV_frame_start(s, avctx);
1741 encode_picture(s, s->picture_number);
1743 avctx->real_pict_num = s->picture_number;
1744 avctx->header_bits = s->header_bits;
1745 avctx->mv_bits = s->mv_bits;
1746 avctx->misc_bits = s->misc_bits;
1747 avctx->i_tex_bits = s->i_tex_bits;
1748 avctx->p_tex_bits = s->p_tex_bits;
1749 avctx->i_count = s->i_count;
1750 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1751 avctx->skip_count = s->skip_count;
1755 if (s->out_format == FMT_MJPEG)
1756 mjpeg_picture_trailer(s);
1758 if(s->flags&CODEC_FLAG_PASS1)
1759 ff_write_pass1_stats(s);
1762 avctx->error[i] += s->current_picture_ptr->error[i];
1766 s->input_picture_number++;
1768 flush_put_bits(&s->pb);
1769 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1771 stuffing_count= ff_vbv_update(s, s->frame_bits);
1773 switch(s->codec_id){
1774 case CODEC_ID_MPEG1VIDEO:
1775 case CODEC_ID_MPEG2VIDEO:
1776 while(stuffing_count--){
1777 put_bits(&s->pb, 8, 0);
1780 case CODEC_ID_MPEG4:
1781 put_bits(&s->pb, 16, 0);
1782 put_bits(&s->pb, 16, 0x1C3);
1783 stuffing_count -= 4;
1784 while(stuffing_count--){
1785 put_bits(&s->pb, 8, 0xFF);
1789 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1791 flush_put_bits(&s->pb);
1792 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1795 s->total_bits += s->frame_bits;
1796 avctx->frame_bits = s->frame_bits;
1798 return s->frame_bits/8;
1801 #endif //CONFIG_ENCODERS
1803 static inline void gmc1_motion(MpegEncContext *s,
1804 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1806 uint8_t **ref_picture, int src_offset)
1809 int offset, src_x, src_y, linesize, uvlinesize;
1810 int motion_x, motion_y;
1813 motion_x= s->sprite_offset[0][0];
1814 motion_y= s->sprite_offset[0][1];
1815 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1816 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1817 motion_x<<=(3-s->sprite_warping_accuracy);
1818 motion_y<<=(3-s->sprite_warping_accuracy);
1819 src_x = clip(src_x, -16, s->width);
1820 if (src_x == s->width)
1822 src_y = clip(src_y, -16, s->height);
1823 if (src_y == s->height)
1826 linesize = s->linesize;
1827 uvlinesize = s->uvlinesize;
1829 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1831 dest_y+=dest_offset;
1832 if(s->flags&CODEC_FLAG_EMU_EDGE){
1833 if( (unsigned)src_x >= s->h_edge_pos - 17
1834 || (unsigned)src_y >= s->v_edge_pos - 17){
1835 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1836 ptr= s->edge_emu_buffer;
1840 if((motion_x|motion_y)&7){
1841 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1842 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1846 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1847 if (s->no_rounding){
1848 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1850 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
1854 if(s->flags&CODEC_FLAG_GRAY) return;
1856 motion_x= s->sprite_offset[1][0];
1857 motion_y= s->sprite_offset[1][1];
1858 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1859 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1860 motion_x<<=(3-s->sprite_warping_accuracy);
1861 motion_y<<=(3-s->sprite_warping_accuracy);
1862 src_x = clip(src_x, -8, s->width>>1);
1863 if (src_x == s->width>>1)
1865 src_y = clip(src_y, -8, s->height>>1);
1866 if (src_y == s->height>>1)
1869 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1870 ptr = ref_picture[1] + offset;
1871 if(s->flags&CODEC_FLAG_EMU_EDGE){
1872 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
1873 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
1874 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);
1875 ptr= s->edge_emu_buffer;
1879 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1881 ptr = ref_picture[2] + offset;
1883 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);
1884 ptr= s->edge_emu_buffer;
1886 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1891 static inline void gmc_motion(MpegEncContext *s,
1892 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1894 uint8_t **ref_picture, int src_offset)
1897 int linesize, uvlinesize;
1898 const int a= s->sprite_warping_accuracy;
1901 linesize = s->linesize;
1902 uvlinesize = s->uvlinesize;
1904 ptr = ref_picture[0] + src_offset;
1906 dest_y+=dest_offset;
1908 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1909 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1911 s->dsp.gmc(dest_y, ptr, linesize, 16,
1914 s->sprite_delta[0][0], s->sprite_delta[0][1],
1915 s->sprite_delta[1][0], s->sprite_delta[1][1],
1916 a+1, (1<<(2*a+1)) - s->no_rounding,
1917 s->h_edge_pos, s->v_edge_pos);
1918 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1919 ox + s->sprite_delta[0][0]*8,
1920 oy + s->sprite_delta[1][0]*8,
1921 s->sprite_delta[0][0], s->sprite_delta[0][1],
1922 s->sprite_delta[1][0], s->sprite_delta[1][1],
1923 a+1, (1<<(2*a+1)) - s->no_rounding,
1924 s->h_edge_pos, s->v_edge_pos);
1926 if(s->flags&CODEC_FLAG_GRAY) return;
1929 dest_cb+=dest_offset>>1;
1930 dest_cr+=dest_offset>>1;
1932 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1933 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1935 ptr = ref_picture[1] + (src_offset>>1);
1936 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1939 s->sprite_delta[0][0], s->sprite_delta[0][1],
1940 s->sprite_delta[1][0], s->sprite_delta[1][1],
1941 a+1, (1<<(2*a+1)) - s->no_rounding,
1942 s->h_edge_pos>>1, s->v_edge_pos>>1);
1944 ptr = ref_picture[2] + (src_offset>>1);
1945 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1948 s->sprite_delta[0][0], s->sprite_delta[0][1],
1949 s->sprite_delta[1][0], s->sprite_delta[1][1],
1950 a+1, (1<<(2*a+1)) - s->no_rounding,
1951 s->h_edge_pos>>1, s->v_edge_pos>>1);
1955 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1956 * @param buf destination buffer
1957 * @param src source buffer
1958 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1959 * @param block_w width of block
1960 * @param block_h height of block
1961 * @param src_x x coordinate of the top left sample of the block in the source buffer
1962 * @param src_y y coordinate of the top left sample of the block in the source buffer
1963 * @param w width of the source buffer
1964 * @param h height of the source buffer
1966 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1967 int src_x, int src_y, int w, int h){
1969 int start_y, start_x, end_y, end_x;
1972 src+= (h-1-src_y)*linesize;
1974 }else if(src_y<=-block_h){
1975 src+= (1-block_h-src_y)*linesize;
1981 }else if(src_x<=-block_w){
1982 src+= (1-block_w-src_x);
1986 start_y= FFMAX(0, -src_y);
1987 start_x= FFMAX(0, -src_x);
1988 end_y= FFMIN(block_h, h-src_y);
1989 end_x= FFMIN(block_w, w-src_x);
1991 // copy existing part
1992 for(y=start_y; y<end_y; y++){
1993 for(x=start_x; x<end_x; x++){
1994 buf[x + y*linesize]= src[x + y*linesize];
1999 for(y=0; y<start_y; y++){
2000 for(x=start_x; x<end_x; x++){
2001 buf[x + y*linesize]= buf[x + start_y*linesize];
2006 for(y=end_y; y<block_h; y++){
2007 for(x=start_x; x<end_x; x++){
2008 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2012 for(y=0; y<block_h; y++){
2014 for(x=0; x<start_x; x++){
2015 buf[x + y*linesize]= buf[start_x + y*linesize];
2019 for(x=end_x; x<block_w; x++){
2020 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2025 static inline int hpel_motion(MpegEncContext *s,
2026 uint8_t *dest, uint8_t *src,
2027 int src_x, int src_y,
2028 int width, int height, int stride,
2029 int h_edge_pos, int v_edge_pos,
2030 int w, int h, op_pixels_func *pix_op,
2031 int motion_x, int motion_y)
2036 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2037 src_x += motion_x >> 1;
2038 src_y += motion_y >> 1;
2040 /* WARNING: do no forget half pels */
2041 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2044 src_y = clip(src_y, -16, height);
2045 if (src_y == height)
2047 src += src_y * stride + src_x;
2049 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2050 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2051 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2052 ff_emulated_edge_mc(s->edge_emu_buffer, src, stride, w+1, h+1,
2053 src_x, src_y, h_edge_pos, v_edge_pos);
2054 src= s->edge_emu_buffer;
2058 pix_op[dxy](dest, src, stride, h);
2062 /* apply one mpeg motion vector to the three components */
2063 static inline void mpeg_motion(MpegEncContext *s,
2064 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2066 uint8_t **ref_picture, int src_offset,
2067 int field_based, op_pixels_func (*pix_op)[4],
2068 int motion_x, int motion_y, int h)
2071 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, uvlinesize;
2074 if(s->quarter_sample)
2081 height = s->height >> field_based;
2082 v_edge_pos = s->v_edge_pos >> field_based;
2083 uvlinesize = s->current_picture.linesize[1] << field_based;
2086 dest_y + dest_offset, ref_picture[0] + src_offset,
2087 s->mb_x * 16, s->mb_y * (16 >> field_based),
2088 s->width, height, s->current_picture.linesize[0] << field_based,
2089 s->h_edge_pos, v_edge_pos,
2091 motion_x, motion_y);
2094 if(s->flags&CODEC_FLAG_GRAY) return;
2096 if (s->out_format == FMT_H263) {
2098 if ((motion_x & 3) != 0)
2100 if ((motion_y & 3) != 0)
2107 dxy = ((my & 1) << 1) | (mx & 1);
2112 src_x = s->mb_x * 8 + mx;
2113 src_y = s->mb_y * (8 >> field_based) + my;
2114 src_x = clip(src_x, -8, s->width >> 1);
2115 if (src_x == (s->width >> 1))
2117 src_y = clip(src_y, -8, height >> 1);
2118 if (src_y == (height >> 1))
2120 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2121 ptr = ref_picture[1] + offset;
2123 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
2124 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2125 ptr= s->edge_emu_buffer + (src_offset >> 1);
2127 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2129 ptr = ref_picture[2] + offset;
2131 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
2132 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2133 ptr= s->edge_emu_buffer + (src_offset >> 1);
2135 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2137 //FIXME move to dsputil, avg variant, 16x16 version
2138 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2140 uint8_t * const top = src[1];
2141 uint8_t * const left = src[2];
2142 uint8_t * const mid = src[0];
2143 uint8_t * const right = src[3];
2144 uint8_t * const bottom= src[4];
2145 #define OBMC_FILTER(x, t, l, m, r, b)\
2146 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2147 #define OBMC_FILTER4(x, t, l, m, r, b)\
2148 OBMC_FILTER(x , t, l, m, r, b);\
2149 OBMC_FILTER(x+1 , t, l, m, r, b);\
2150 OBMC_FILTER(x +stride, t, l, m, r, b);\
2151 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2154 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2155 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2156 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2157 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2158 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2159 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2161 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2162 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2163 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2164 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2166 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2167 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2168 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2169 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2171 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2172 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2173 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2174 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2176 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2177 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2178 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2179 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2180 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2181 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2183 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2184 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2185 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2186 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2189 /* obmc for 1 8x8 luma block */
2190 static inline void obmc_motion(MpegEncContext *s,
2191 uint8_t *dest, uint8_t *src,
2192 int src_x, int src_y,
2193 op_pixels_func *pix_op,
2194 int16_t mv[5][2]/* mid top left right bottom*/)
2200 assert(s->quarter_sample==0);
2203 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2206 ptr[i]= s->edge_emu_buffer + 16 + 8*(i&1) + s->linesize*8*(i>>1);
2207 hpel_motion(s, ptr[i], src,
2209 s->width, s->height, s->linesize,
2210 s->h_edge_pos, s->v_edge_pos,
2212 mv[i][0], mv[i][1]);
2216 put_obmc(dest, ptr, s->linesize);
2219 static inline void qpel_motion(MpegEncContext *s,
2220 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2222 uint8_t **ref_picture, int src_offset,
2223 int field_based, op_pixels_func (*pix_op)[4],
2224 qpel_mc_func (*qpix_op)[16],
2225 int motion_x, int motion_y, int h)
2228 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
2231 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2232 src_x = s->mb_x * 16 + (motion_x >> 2);
2233 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2235 height = s->height >> field_based;
2236 v_edge_pos = s->v_edge_pos >> field_based;
2237 src_x = clip(src_x, -16, s->width);
2238 if (src_x == s->width)
2240 src_y = clip(src_y, -16, height);
2241 if (src_y == height)
2243 linesize = s->linesize << field_based;
2244 uvlinesize = s->uvlinesize << field_based;
2245 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
2246 dest_y += dest_offset;
2247 //printf("%d %d %d\n", src_x, src_y, dxy);
2249 if(s->flags&CODEC_FLAG_EMU_EDGE){
2250 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
2251 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
2252 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,
2253 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2254 ptr= s->edge_emu_buffer + src_offset;
2259 qpix_op[0][dxy](dest_y, ptr, linesize);
2261 //damn interlaced mode
2262 //FIXME boundary mirroring is not exactly correct here
2263 qpix_op[1][dxy](dest_y , ptr , linesize);
2264 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2267 if(s->flags&CODEC_FLAG_GRAY) return;
2272 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2273 static const int rtab[8]= {0,0,1,1,0,0,0,1};
2274 mx= (motion_x>>1) + rtab[motion_x&7];
2275 my= (motion_y>>1) + rtab[motion_y&7];
2276 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2277 mx= (motion_x>>1)|(motion_x&1);
2278 my= (motion_y>>1)|(motion_y&1);
2286 dxy= (mx&1) | ((my&1)<<1);
2290 src_x = s->mb_x * 8 + mx;
2291 src_y = s->mb_y * (8 >> field_based) + my;
2292 src_x = clip(src_x, -8, s->width >> 1);
2293 if (src_x == (s->width >> 1))
2295 src_y = clip(src_y, -8, height >> 1);
2296 if (src_y == (height >> 1))
2299 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2300 ptr = ref_picture[1] + offset;
2302 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
2303 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2304 ptr= s->edge_emu_buffer + (src_offset >> 1);
2306 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2308 ptr = ref_picture[2] + offset;
2310 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
2311 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2312 ptr= s->edge_emu_buffer + (src_offset >> 1);
2314 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2317 inline int ff_h263_round_chroma(int x){
2319 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2322 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2327 * h263 chorma 4mv motion compensation.
2329 static inline void chroma_4mv_motion(MpegEncContext *s,
2330 uint8_t *dest_cb, uint8_t *dest_cr,
2331 uint8_t **ref_picture,
2332 op_pixels_func *pix_op,
2334 int dxy, emu=0, src_x, src_y, offset;
2337 /* In case of 8X8, we construct a single chroma motion vector
2338 with a special rounding */
2339 mx= ff_h263_round_chroma(mx);
2340 my= ff_h263_round_chroma(my);
2342 dxy = ((my & 1) << 1) | (mx & 1);
2346 src_x = s->mb_x * 8 + mx;
2347 src_y = s->mb_y * 8 + my;
2348 src_x = clip(src_x, -8, s->width/2);
2349 if (src_x == s->width/2)
2351 src_y = clip(src_y, -8, s->height/2);
2352 if (src_y == s->height/2)
2355 offset = (src_y * (s->uvlinesize)) + src_x;
2356 ptr = ref_picture[1] + offset;
2357 if(s->flags&CODEC_FLAG_EMU_EDGE){
2358 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2359 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2360 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);
2361 ptr= s->edge_emu_buffer;
2365 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2367 ptr = ref_picture[2] + offset;
2369 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);
2370 ptr= s->edge_emu_buffer;
2372 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2376 * motion compesation of a single macroblock
2378 * @param dest_y luma destination pointer
2379 * @param dest_cb chroma cb/u destination pointer
2380 * @param dest_cr chroma cr/v destination pointer
2381 * @param dir direction (0->forward, 1->backward)
2382 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2383 * @param pic_op halfpel motion compensation function (average or put normally)
2384 * @param pic_op qpel motion compensation function (average or put normally)
2385 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2387 static inline void MPV_motion(MpegEncContext *s,
2388 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2389 int dir, uint8_t **ref_picture,
2390 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2392 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2394 uint8_t *ptr, *dest;
2399 if(s->obmc && s->pict_type != B_TYPE){
2400 int16_t mv_cache[4][4][2];
2401 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2402 const int mot_stride= s->mb_width*2 + 2;
2403 const int mot_xy= 1 + mb_x*2 + (mb_y*2 + 1)*mot_stride;
2405 assert(!s->mb_skiped);
2407 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
2408 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2409 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2411 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2412 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2414 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2417 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2418 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2419 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2421 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2422 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2425 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2426 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2427 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2429 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2430 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2436 const int x= (i&1)+1;
2437 const int y= (i>>1)+1;
2439 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
2440 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
2441 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
2442 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
2443 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
2445 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2447 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2454 if(!(s->flags&CODEC_FLAG_GRAY))
2455 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2460 switch(s->mv_type) {
2464 if(s->real_sprite_warping_points==1){
2465 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2468 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2471 }else if(s->quarter_sample){
2472 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2475 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2477 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2478 ref_picture, pix_op,
2479 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2483 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2486 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2492 if(s->quarter_sample){
2494 motion_x = s->mv[dir][i][0];
2495 motion_y = s->mv[dir][i][1];
2497 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2498 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2499 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2501 /* WARNING: do no forget half pels */
2502 src_x = clip(src_x, -16, s->width);
2503 if (src_x == s->width)
2505 src_y = clip(src_y, -16, s->height);
2506 if (src_y == s->height)
2509 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2510 if(s->flags&CODEC_FLAG_EMU_EDGE){
2511 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
2512 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
2513 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2514 ptr= s->edge_emu_buffer;
2517 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2518 qpix_op[1][dxy](dest, ptr, s->linesize);
2520 mx += s->mv[dir][i][0]/2;
2521 my += s->mv[dir][i][1]/2;
2525 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
2527 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
2528 s->width, s->height, s->linesize,
2529 s->h_edge_pos, s->v_edge_pos,
2531 s->mv[dir][i][0], s->mv[dir][i][1]);
2533 mx += s->mv[dir][i][0];
2534 my += s->mv[dir][i][1];
2538 if(!(s->flags&CODEC_FLAG_GRAY))
2539 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
2542 if (s->picture_structure == PICT_FRAME) {
2543 if(s->quarter_sample){
2545 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2546 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2548 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2550 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2551 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2553 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2556 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2557 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2559 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2561 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2562 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2564 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2568 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2569 offset= s->field_select[dir][0] ? s->linesize : 0;
2571 ref_picture= s->current_picture.data;
2572 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2575 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2576 ref_picture, offset,
2578 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2583 uint8_t ** ref2picture;
2585 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2586 ref2picture= ref_picture;
2587 offset= s->field_select[dir][0] ? s->linesize : 0;
2589 ref2picture= s->current_picture.data;
2590 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2593 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2594 ref2picture, offset,
2596 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2599 if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2600 ref2picture= ref_picture;
2601 offset= s->field_select[dir][1] ? s->linesize : 0;
2603 ref2picture= s->current_picture.data;
2604 offset= s->field_select[dir][1] ? s->linesize : -s->linesize;
2606 // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2607 mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2609 ref2picture, offset,
2611 s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2617 op_pixels_func (*dmv_pix_op)[4];
2620 dmv_pix_op = s->dsp.put_pixels_tab;
2622 if(s->picture_structure == PICT_FRAME){
2623 //put top field from top field
2624 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2627 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2628 //put bottom field from bottom field
2629 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2630 ref_picture, s->linesize,
2632 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2634 dmv_pix_op = s->dsp.avg_pixels_tab;
2636 //avg top field from bottom field
2637 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2638 ref_picture, s->linesize,
2640 s->mv[dir][2][0], s->mv[dir][2][1], 8);
2641 //avg bottom field from top field
2642 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2645 s->mv[dir][3][0], s->mv[dir][3][1], 8);
2648 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2651 //put field from the same parity
2652 //same parity is never in the same frame
2653 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2656 s->mv[dir][0][0],s->mv[dir][0][1],16);
2658 // after put we make avg of the same block
2659 dmv_pix_op=s->dsp.avg_pixels_tab;
2661 //opposite parity is always in the same frame if this is second field
2662 if(!s->first_field){
2663 ref_picture = s->current_picture.data;
2664 //top field is one linesize from frame beginig
2665 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2666 -s->linesize : s->linesize;
2668 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2671 //avg field from the opposite parity
2672 mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2673 ref_picture, offset,
2675 s->mv[dir][2][0],s->mv[dir][2][1],16);
2684 /* put block[] to dest[] */
2685 static inline void put_dct(MpegEncContext *s,
2686 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2688 s->dct_unquantize(s, block, i, qscale);
2689 s->dsp.idct_put (dest, line_size, block);
2692 /* add block[] to dest[] */
2693 static inline void add_dct(MpegEncContext *s,
2694 DCTELEM *block, int i, uint8_t *dest, int line_size)
2696 if (s->block_last_index[i] >= 0) {
2697 s->dsp.idct_add (dest, line_size, block);
2701 static inline void add_dequant_dct(MpegEncContext *s,
2702 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2704 if (s->block_last_index[i] >= 0) {
2705 s->dct_unquantize(s, block, i, qscale);
2707 s->dsp.idct_add (dest, line_size, block);
2712 * cleans dc, ac, coded_block for the current non intra MB
2714 void ff_clean_intra_table_entries(MpegEncContext *s)
2716 int wrap = s->block_wrap[0];
2717 int xy = s->block_index[0];
2720 s->dc_val[0][xy + 1 ] =
2721 s->dc_val[0][xy + wrap] =
2722 s->dc_val[0][xy + 1 + wrap] = 1024;
2724 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2725 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2726 if (s->msmpeg4_version>=3) {
2727 s->coded_block[xy ] =
2728 s->coded_block[xy + 1 ] =
2729 s->coded_block[xy + wrap] =
2730 s->coded_block[xy + 1 + wrap] = 0;
2733 wrap = s->block_wrap[4];
2734 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2736 s->dc_val[2][xy] = 1024;
2738 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2739 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2741 s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2744 /* generic function called after a macroblock has been parsed by the
2745 decoder or after it has been encoded by the encoder.
2747 Important variables used:
2748 s->mb_intra : true if intra macroblock
2749 s->mv_dir : motion vector direction
2750 s->mv_type : motion vector type
2751 s->mv : motion vector
2752 s->interlaced_dct : true if interlaced dct used (mpeg2)
2754 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2757 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2759 if(s->avctx->xvmc_acceleration){
2760 XVMC_decode_mb(s);//xvmc uses pblocks
2768 s->current_picture.qscale_table[mb_xy]= s->qscale;
2770 /* update DC predictors for P macroblocks */
2772 if (s->h263_pred || s->h263_aic) {
2773 if(s->mbintra_table[mb_xy])
2774 ff_clean_intra_table_entries(s);
2778 s->last_dc[2] = 128 << s->intra_dc_precision;
2781 else if (s->h263_pred || s->h263_aic)
2782 s->mbintra_table[mb_xy]=1;
2784 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2785 uint8_t *dest_y, *dest_cb, *dest_cr;
2786 int dct_linesize, dct_offset;
2787 op_pixels_func (*op_pix)[4];
2788 qpel_mc_func (*op_qpix)[16];
2789 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2790 const int uvlinesize= s->current_picture.linesize[1];
2791 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band;
2793 /* avoid copy if macroblock skipped in last frame too */
2794 /* skip only during decoding as we might trash the buffers during encoding a bit */
2796 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2797 const int age= s->current_picture.age;
2803 assert(s->pict_type!=I_TYPE);
2805 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2806 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2808 /* if previous was skipped too, then nothing to do ! */
2809 if (*mbskip_ptr >= age && s->current_picture.reference){
2812 } else if(!s->current_picture.reference){
2813 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2814 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2816 *mbskip_ptr = 0; /* not skipped */
2820 if (s->interlaced_dct) {
2821 dct_linesize = linesize * 2;
2822 dct_offset = linesize;
2824 dct_linesize = linesize;
2825 dct_offset = linesize * 8;
2829 dest_cb= s->dest[1];
2830 dest_cr= s->dest[2];
2832 dest_y = s->edge_emu_buffer+32; //FIXME cleanup scratchpad pointers
2833 dest_cb= s->edge_emu_buffer+48;
2834 dest_cr= s->edge_emu_buffer+56;
2837 /* motion handling */
2838 /* decoding or more than one mb_type (MC was allready done otherwise) */
2840 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2841 op_pix = s->dsp.put_pixels_tab;
2842 op_qpix= s->dsp.put_qpel_pixels_tab;
2844 op_pix = s->dsp.put_no_rnd_pixels_tab;
2845 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2848 if (s->mv_dir & MV_DIR_FORWARD) {
2849 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2850 op_pix = s->dsp.avg_pixels_tab;
2851 op_qpix= s->dsp.avg_qpel_pixels_tab;
2853 if (s->mv_dir & MV_DIR_BACKWARD) {
2854 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2858 /* skip dequant / idct if we are really late ;) */
2859 if(s->hurry_up>1) return;
2861 /* add dct residue */
2862 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2863 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2864 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
2865 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
2866 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
2867 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
2869 if(!(s->flags&CODEC_FLAG_GRAY)){
2870 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2871 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2873 } else if(s->codec_id != CODEC_ID_WMV2){
2874 add_dct(s, block[0], 0, dest_y, dct_linesize);
2875 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2876 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2877 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2879 if(!(s->flags&CODEC_FLAG_GRAY)){
2880 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2881 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2886 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2890 /* dct only in intra block */
2891 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2892 put_dct(s, block[0], 0, dest_y, dct_linesize, s->qscale);
2893 put_dct(s, block[1], 1, dest_y + 8, dct_linesize, s->qscale);
2894 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize, s->qscale);
2895 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize, s->qscale);
2897 if(!(s->flags&CODEC_FLAG_GRAY)){
2898 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2899 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2902 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2903 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]);
2904 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2905 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2907 if(!(s->flags&CODEC_FLAG_GRAY)){
2908 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2909 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2914 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2915 s->dsp.put_pixels_tab[1][0](s->dest[1], dest_cb, uvlinesize, 8);
2916 s->dsp.put_pixels_tab[1][0](s->dest[2], dest_cr, uvlinesize, 8);
2921 #ifdef CONFIG_ENCODERS
2923 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2925 static const char tab[64]=
2937 DCTELEM *block= s->block[n];
2938 const int last_index= s->block_last_index[n];
2943 threshold= -threshold;
2947 /* are all which we could set to zero are allready zero? */
2948 if(last_index<=skip_dc - 1) return;
2950 for(i=0; i<=last_index; i++){
2951 const int j = s->intra_scantable.permutated[i];
2952 const int level = ABS(block[j]);
2954 if(skip_dc && i==0) continue;
2963 if(score >= threshold) return;
2964 for(i=skip_dc; i<=last_index; i++){
2965 const int j = s->intra_scantable.permutated[i];
2968 if(block[0]) s->block_last_index[n]= 0;
2969 else s->block_last_index[n]= -1;
2972 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2975 const int maxlevel= s->max_qcoeff;
2976 const int minlevel= s->min_qcoeff;
2979 i=1; //skip clipping of intra dc
2983 for(;i<=last_index; i++){
2984 const int j= s->intra_scantable.permutated[i];
2985 int level = block[j];
2987 if (level>maxlevel) level=maxlevel;
2988 else if(level<minlevel) level=minlevel;
2995 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
3000 for(x=0; x<16; x+=4){
3001 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
3002 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
3010 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
3015 for(x=0; x<16; x++){
3016 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
3025 #define SQ(a) ((a)*(a))
3027 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
3032 for(x=0; x<16; x+=4){
3033 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
3034 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
3042 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
3047 for(x=0; x<16; x++){
3048 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
3059 #endif //CONFIG_ENCODERS
3063 * @param h is the normal height, this will be reduced automatically if needed for the last row
3065 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3066 if (s->avctx->draw_horiz_band) {
3070 if(s->picture_structure != PICT_FRAME){
3073 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3076 h= FFMIN(h, s->height - y);
3078 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
3079 src= (AVFrame*)s->current_picture_ptr;
3080 else if(s->last_picture_ptr)
3081 src= (AVFrame*)s->last_picture_ptr;
3085 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3091 offset[0]= y * s->linesize;;
3093 offset[2]= (y>>1) * s->uvlinesize;;
3099 s->avctx->draw_horiz_band(s->avctx, src, offset,
3100 y, s->picture_structure, h);
3104 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3105 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3106 const int uvlinesize= s->current_picture.linesize[1];
3108 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3109 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
3110 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
3111 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
3112 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3113 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
3115 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
3116 s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
3117 s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
3118 s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
3120 s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize ) + s->mb_x * 16 - 16;
3121 s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3122 s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
3126 #ifdef CONFIG_ENCODERS
3128 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3130 const int mb_x= s->mb_x;
3131 const int mb_y= s->mb_y;
3134 int dct_offset = s->linesize*8; //default for progressive frames
3136 for(i=0; i<6; i++) skip_dct[i]=0;
3138 if(s->adaptive_quant){
3139 const int last_qp= s->qscale;
3140 const int mb_xy= mb_x + mb_y*s->mb_stride;
3142 s->lambda= s->lambda_table[mb_xy];
3145 if(!(s->flags&CODEC_FLAG_QP_RD)){
3146 s->dquant= s->qscale - last_qp;
3148 if(s->out_format==FMT_H263)
3149 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3151 if(s->codec_id==CODEC_ID_MPEG4){
3153 if((s->mv_dir&MV_DIRECT) || s->mv_type==MV_TYPE_8X8)
3158 ff_set_qscale(s, last_qp + s->dquant);
3166 wrap_y = s->linesize;
3167 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3169 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3170 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3171 ptr= s->edge_emu_buffer;
3175 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3176 int progressive_score, interlaced_score;
3178 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
3179 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
3181 if(progressive_score > interlaced_score + 100){
3182 s->interlaced_dct=1;
3187 s->interlaced_dct=0;
3190 s->dsp.get_pixels(s->block[0], ptr , wrap_y);
3191 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y);
3192 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y);
3193 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
3195 if(s->flags&CODEC_FLAG_GRAY){
3199 int wrap_c = s->uvlinesize;
3200 ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3202 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3203 ptr= s->edge_emu_buffer;
3205 s->dsp.get_pixels(s->block[4], ptr, wrap_c);
3207 ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3209 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3210 ptr= s->edge_emu_buffer;
3212 s->dsp.get_pixels(s->block[5], ptr, wrap_c);
3215 op_pixels_func (*op_pix)[4];
3216 qpel_mc_func (*op_qpix)[16];
3217 uint8_t *dest_y, *dest_cb, *dest_cr;
3218 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3222 dest_y = s->dest[0];
3223 dest_cb = s->dest[1];
3224 dest_cr = s->dest[2];
3225 wrap_y = s->linesize;
3226 wrap_c = s->uvlinesize;
3227 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3228 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3229 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3231 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3232 op_pix = s->dsp.put_pixels_tab;
3233 op_qpix= s->dsp.put_qpel_pixels_tab;
3235 op_pix = s->dsp.put_no_rnd_pixels_tab;
3236 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3239 if (s->mv_dir & MV_DIR_FORWARD) {
3240 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3241 op_pix = s->dsp.avg_pixels_tab;
3242 op_qpix= s->dsp.avg_qpel_pixels_tab;
3244 if (s->mv_dir & MV_DIR_BACKWARD) {
3245 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3248 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3249 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
3250 ptr_y= s->edge_emu_buffer;
3254 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3255 int progressive_score, interlaced_score;
3257 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
3258 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
3259 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
3260 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
3262 if(progressive_score > interlaced_score + 600){
3263 s->interlaced_dct=1;
3268 s->interlaced_dct=0;
3271 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
3272 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
3273 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
3274 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3276 if(s->flags&CODEC_FLAG_GRAY){
3281 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3282 ptr_cb= s->edge_emu_buffer;
3284 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3286 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3287 ptr_cr= s->edge_emu_buffer;
3289 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3291 /* pre quantization */
3292 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3294 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
3295 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
3296 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
3297 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
3298 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
3299 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
3305 if(skip_dct[i]) num++;
3308 if(s->mb_x==0 && s->mb_y==0){
3310 printf("%6d %1d\n", stat[i], i);
3319 /* DCT & quantize */
3320 if(s->out_format==FMT_MJPEG){
3323 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3324 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3330 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3331 // FIXME we could decide to change to quantizer instead of clipping
3332 // JS: I don't think that would be a good idea it could lower quality instead
3333 // of improve it. Just INTRADC clipping deserves changes in quantizer
3334 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3336 s->block_last_index[i]= -1;
3339 if(s->luma_elim_threshold && !s->mb_intra)
3341 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3342 if(s->chroma_elim_threshold && !s->mb_intra)
3344 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3346 if(s->flags & CODEC_FLAG_CBP_RD){
3348 if(s->block_last_index[i] == -1)
3349 s->coded_score[i]= INT_MAX/256;
3354 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3355 s->block_last_index[4]=
3356 s->block_last_index[5]= 0;
3358 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3361 /* huffman encode */
3362 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3363 case CODEC_ID_MPEG1VIDEO:
3364 case CODEC_ID_MPEG2VIDEO:
3365 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3367 case CODEC_ID_MPEG4:
3368 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3369 case CODEC_ID_MSMPEG4V2:
3370 case CODEC_ID_MSMPEG4V3:
3372 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3374 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3376 case CODEC_ID_H263P:
3379 h263_encode_mb(s, s->block, motion_x, motion_y); break;
3381 case CODEC_ID_MJPEG:
3382 mjpeg_encode_mb(s, s->block); break;
3388 #endif //CONFIG_ENCODERS
3391 * combines the (truncated) bitstream to a complete frame
3392 * @returns -1 if no complete frame could be created
3394 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3395 ParseContext *pc= &s->parse_context;
3399 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3400 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3404 /* copy overreaded byes from last frame into buffer */
3405 for(; pc->overread>0; pc->overread--){
3406 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3409 pc->last_index= pc->index;
3411 /* copy into buffer end return */
3412 if(next == END_NOT_FOUND){
3413 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3415 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3416 pc->index += *buf_size;
3421 pc->overread_index= pc->index + next;
3423 /* append to buffer */
3425 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3427 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3432 /* store overread bytes */
3433 for(;next < 0; next++){
3434 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3440 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3441 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3448 void ff_mpeg_flush(AVCodecContext *avctx){
3450 MpegEncContext *s = avctx->priv_data;
3452 for(i=0; i<MAX_PICTURE_COUNT; i++){
3453 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3454 || s->picture[i].type == FF_BUFFER_TYPE_USER))
3455 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3457 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3459 s->parse_context.state= -1;
3460 s->parse_context.frame_start_found= 0;
3461 s->parse_context.overread= 0;
3462 s->parse_context.overread_index= 0;
3463 s->parse_context.index= 0;
3464 s->parse_context.last_index= 0;
3467 #ifdef CONFIG_ENCODERS
3468 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3470 int bytes= length>>4;
3471 int bits= length&15;
3474 if(length==0) return;
3476 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3477 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3480 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3483 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3486 d->mb_skip_run= s->mb_skip_run;
3488 d->last_dc[i]= s->last_dc[i];
3491 d->mv_bits= s->mv_bits;
3492 d->i_tex_bits= s->i_tex_bits;
3493 d->p_tex_bits= s->p_tex_bits;
3494 d->i_count= s->i_count;
3495 d->f_count= s->f_count;
3496 d->b_count= s->b_count;
3497 d->skip_count= s->skip_count;
3498 d->misc_bits= s->misc_bits;
3502 d->qscale= s->qscale;
3503 d->dquant= s->dquant;
3506 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3509 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
3510 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3513 d->mb_skip_run= s->mb_skip_run;
3515 d->last_dc[i]= s->last_dc[i];
3518 d->mv_bits= s->mv_bits;
3519 d->i_tex_bits= s->i_tex_bits;
3520 d->p_tex_bits= s->p_tex_bits;
3521 d->i_count= s->i_count;
3522 d->f_count= s->f_count;
3523 d->b_count= s->b_count;
3524 d->skip_count= s->skip_count;
3525 d->misc_bits= s->misc_bits;
3527 d->mb_intra= s->mb_intra;
3528 d->mb_skiped= s->mb_skiped;
3529 d->mv_type= s->mv_type;
3530 d->mv_dir= s->mv_dir;
3532 if(s->data_partitioning){
3534 d->tex_pb= s->tex_pb;
3538 d->block_last_index[i]= s->block_last_index[i];
3539 d->interlaced_dct= s->interlaced_dct;
3540 d->qscale= s->qscale;
3543 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
3544 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3545 int *dmin, int *next_block, int motion_x, int motion_y)
3548 uint8_t *dest_backup[3];
3550 copy_context_before_encode(s, backup, type);
3552 s->block= s->blocks[*next_block];
3553 s->pb= pb[*next_block];
3554 if(s->data_partitioning){
3555 s->pb2 = pb2 [*next_block];
3556 s->tex_pb= tex_pb[*next_block];
3560 memcpy(dest_backup, s->dest, sizeof(s->dest));
3561 s->dest[0] = s->me.scratchpad;
3562 s->dest[1] = s->me.scratchpad + 16;
3563 s->dest[2] = s->me.scratchpad + 16 + 8;
3564 assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3565 assert(s->linesize >= 64); //FIXME
3568 encode_mb(s, motion_x, motion_y);
3570 score= get_bit_count(&s->pb);
3571 if(s->data_partitioning){
3572 score+= get_bit_count(&s->pb2);
3573 score+= get_bit_count(&s->tex_pb);
3576 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3577 MPV_decode_mb(s, s->block);
3579 score *= s->lambda2;
3580 score += sse_mb(s) << FF_LAMBDA_SHIFT;
3584 memcpy(s->dest, dest_backup, sizeof(s->dest));
3591 copy_context_after_encode(best, s, type);
3595 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3596 uint32_t *sq = squareTbl + 256;
3601 return s->dsp.sse[0](NULL, src1, src2, stride);
3602 else if(w==8 && h==8)
3603 return s->dsp.sse[1](NULL, src1, src2, stride);
3607 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3616 static int sse_mb(MpegEncContext *s){
3620 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3621 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3624 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize)
3625 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize)
3626 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize);
3628 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
3629 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
3630 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
3633 static void encode_picture(MpegEncContext *s, int picture_number)
3635 int mb_x, mb_y, pdif = 0;
3638 MpegEncContext best_s, backup_s;
3639 uint8_t bit_buf[2][3000];
3640 uint8_t bit_buf2[2][3000];
3641 uint8_t bit_buf_tex[2][3000];
3642 PutBitContext pb[2], pb2[2], tex_pb[2];
3645 init_put_bits(&pb [i], bit_buf [i], 3000);
3646 init_put_bits(&pb2 [i], bit_buf2 [i], 3000);
3647 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
3650 s->picture_number = picture_number;
3652 /* Reset the average MB variance */
3653 s->current_picture.mb_var_sum = 0;
3654 s->current_picture.mc_mb_var_sum = 0;
3657 /* we need to initialize some time vars before we can encode b-frames */
3658 // RAL: Condition added for MPEG1VIDEO
3659 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3660 ff_set_mpeg4_time(s, s->picture_number);
3663 s->scene_change_score=0;
3665 s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
3667 if(s->pict_type==I_TYPE){
3668 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3669 else s->no_rounding=0;
3670 }else if(s->pict_type!=B_TYPE){
3671 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3672 s->no_rounding ^= 1;
3675 /* Estimate motion for every MB */
3676 s->mb_intra=0; //for the rate distoration & bit compare functions
3677 if(s->pict_type != I_TYPE){
3678 if(s->pict_type != B_TYPE){
3679 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3681 s->me.dia_size= s->avctx->pre_dia_size;
3683 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3684 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3687 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3694 s->me.dia_size= s->avctx->dia_size;
3695 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3696 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3697 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3698 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3699 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3700 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3703 s->block_index[0]+=2;
3704 s->block_index[1]+=2;
3705 s->block_index[2]+=2;
3706 s->block_index[3]+=2;
3708 /* compute motion vector & mb_type and store in context */
3709 if(s->pict_type==B_TYPE)
3710 ff_estimate_b_frame_motion(s, mb_x, mb_y);
3712 ff_estimate_p_frame_motion(s, mb_x, mb_y);
3715 }else /* if(s->pict_type == I_TYPE) */{
3717 //FIXME do we need to zero them?
3718 memset(s->current_picture.motion_val[0][0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3719 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3720 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3722 if(!s->fixed_qscale){
3723 /* finding spatial complexity for I-frame rate control */
3724 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3725 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3728 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3730 int sum = s->dsp.pix_sum(pix, s->linesize);
3732 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3734 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3735 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3736 s->current_picture.mb_var_sum += varc;
3743 if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3744 s->pict_type= I_TYPE;
3745 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3746 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3750 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3751 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3753 ff_fix_long_p_mvs(s);
3756 if(s->pict_type==B_TYPE){
3759 a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3760 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3761 s->f_code = FFMAX(a, b);
3763 a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3764 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3765 s->b_code = FFMAX(a, b);
3767 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3768 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3769 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3770 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3774 if (!s->fixed_qscale)
3775 s->current_picture.quality = ff_rate_estimate_qscale(s);
3777 if(s->adaptive_quant){
3779 switch(s->codec_id){
3780 case CODEC_ID_MPEG4:
3781 ff_clean_mpeg4_qscales(s);
3784 case CODEC_ID_H263P:
3786 ff_clean_h263_qscales(s);
3791 s->lambda= s->lambda_table[0];
3794 s->lambda= s->current_picture.quality;
3795 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
3798 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
3799 s->qscale= 3; //reduce cliping problems
3801 if (s->out_format == FMT_MJPEG) {
3802 /* for mjpeg, we do include qscale in the matrix */
3803 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3805 int j= s->dsp.idct_permutation[i];
3807 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3809 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3810 s->intra_matrix, s->intra_quant_bias, 8, 8);
3813 //FIXME var duplication
3814 s->current_picture.key_frame= s->pict_type == I_TYPE;
3815 s->current_picture.pict_type= s->pict_type;
3817 if(s->current_picture.key_frame)
3818 s->picture_in_gop_number=0;
3820 s->last_bits= get_bit_count(&s->pb);
3821 switch(s->out_format) {
3823 mjpeg_picture_header(s);
3827 if (s->codec_id == CODEC_ID_WMV2)
3828 ff_wmv2_encode_picture_header(s, picture_number);
3829 else if (s->h263_msmpeg4)
3830 msmpeg4_encode_picture_header(s, picture_number);
3831 else if (s->h263_pred)
3832 mpeg4_encode_picture_header(s, picture_number);
3833 else if (s->codec_id == CODEC_ID_RV10)
3834 rv10_encode_picture_header(s, picture_number);
3835 else if (s->codec_id == CODEC_ID_FLV1)
3836 ff_flv_encode_picture_header(s, picture_number);
3838 h263_encode_picture_header(s, picture_number);
3842 mpeg1_encode_picture_header(s, picture_number);
3847 bits= get_bit_count(&s->pb);
3848 s->header_bits= bits - s->last_bits;
3860 /* init last dc values */
3861 /* note: quant matrix value (8) is implied here */
3862 s->last_dc[i] = 128;
3864 s->current_picture_ptr->error[i] = 0;
3867 s->last_mv[0][0][0] = 0;
3868 s->last_mv[0][0][1] = 0;
3869 s->last_mv[1][0][0] = 0;
3870 s->last_mv[1][0][1] = 0;
3875 switch(s->codec_id){
3877 case CODEC_ID_H263P:
3879 s->gob_index = ff_h263_get_gob_height(s);
3881 case CODEC_ID_MPEG4:
3882 if(s->partitioned_frame)
3883 ff_mpeg4_init_partitions(s);
3890 s->first_slice_line = 1;
3891 s->ptr_lastgob = s->pb.buf;
3892 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3896 ff_set_qscale(s, s->qscale);
3897 ff_init_block_index(s);
3899 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3900 const int xy= mb_y*s->mb_stride + mb_x;
3901 int mb_type= s->mb_type[xy];
3906 ff_update_block_index(s);
3908 /* write gob / video packet header */
3911 int current_packet_size, is_gob_start;
3913 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3915 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
3917 switch(s->codec_id){
3919 case CODEC_ID_H263P:
3920 if(!s->h263_slice_structured)
3921 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3923 case CODEC_ID_MPEG2VIDEO:
3924 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3925 case CODEC_ID_MPEG1VIDEO:
3926 if(s->mb_skip_run) is_gob_start=0;
3931 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
3932 ff_mpeg4_merge_partitions(s);
3933 ff_mpeg4_init_partitions(s);
3936 if(s->codec_id==CODEC_ID_MPEG4)
3937 ff_mpeg4_stuffing(&s->pb);
3939 align_put_bits(&s->pb);
3940 flush_put_bits(&s->pb);
3942 assert((get_bit_count(&s->pb)&7) == 0);
3943 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3945 if (s->avctx->rtp_callback)
3946 s->avctx->rtp_callback(s->ptr_lastgob, current_packet_size, 0);
3948 switch(s->codec_id){
3949 case CODEC_ID_MPEG4:
3950 ff_mpeg4_encode_video_packet_header(s);
3951 ff_mpeg4_clean_buffers(s);
3953 case CODEC_ID_MPEG1VIDEO:
3954 case CODEC_ID_MPEG2VIDEO:
3955 ff_mpeg1_encode_slice_header(s);
3956 ff_mpeg1_clean_buffers(s);
3959 case CODEC_ID_H263P:
3960 h263_encode_gob_header(s, mb_y);
3964 if(s->flags&CODEC_FLAG_PASS1){
3965 int bits= get_bit_count(&s->pb);
3966 s->misc_bits+= bits - s->last_bits;
3970 s->ptr_lastgob += current_packet_size;
3971 s->first_slice_line=1;
3972 s->resync_mb_x=mb_x;
3973 s->resync_mb_y=mb_y;
3978 if( (s->resync_mb_x == s->mb_x)
3979 && s->resync_mb_y+1 == s->mb_y){
3980 s->first_slice_line=0;
3984 s->dquant=0; //only for QP_RD
3986 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible
3988 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3990 copy_context_before_encode(&backup_s, s, -1);
3992 best_s.data_partitioning= s->data_partitioning;
3993 best_s.partitioned_frame= s->partitioned_frame;
3994 if(s->data_partitioning){
3995 backup_s.pb2= s->pb2;
3996 backup_s.tex_pb= s->tex_pb;
3999 if(mb_type&MB_TYPE_INTER){
4000 s->mv_dir = MV_DIR_FORWARD;
4001 s->mv_type = MV_TYPE_16X16;
4003 s->mv[0][0][0] = s->p_mv_table[xy][0];
4004 s->mv[0][0][1] = s->p_mv_table[xy][1];
4005 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
4006 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4008 if(mb_type&MB_TYPE_SKIPED){
4009 s->mv_dir = MV_DIR_FORWARD;
4010 s->mv_type = MV_TYPE_16X16;
4014 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_SKIPED, pb, pb2, tex_pb,
4015 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4017 if(mb_type&MB_TYPE_INTER4V){
4018 s->mv_dir = MV_DIR_FORWARD;
4019 s->mv_type = MV_TYPE_8X8;
4022 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4023 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4025 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
4026 &dmin, &next_block, 0, 0);
4028 if(mb_type&MB_TYPE_FORWARD){
4029 s->mv_dir = MV_DIR_FORWARD;
4030 s->mv_type = MV_TYPE_16X16;
4032 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4033 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4034 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
4035 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4037 if(mb_type&MB_TYPE_BACKWARD){
4038 s->mv_dir = MV_DIR_BACKWARD;
4039 s->mv_type = MV_TYPE_16X16;
4041 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4042 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4043 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
4044 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4046 if(mb_type&MB_TYPE_BIDIR){
4047 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4048 s->mv_type = MV_TYPE_16X16;
4050 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4051 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4052 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4053 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4054 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
4055 &dmin, &next_block, 0, 0);
4057 if(mb_type&MB_TYPE_DIRECT){
4058 int mx= s->b_direct_mv_table[xy][0];
4059 int my= s->b_direct_mv_table[xy][1];
4061 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4064 ff_mpeg4_set_direct_mv(s, mx, my);
4066 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
4067 &dmin, &next_block, mx, my);
4069 if(mb_type&MB_TYPE_INTRA){
4071 s->mv_type = MV_TYPE_16X16;
4075 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
4076 &dmin, &next_block, 0, 0);
4077 if(s->h263_pred || s->h263_aic){
4079 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4081 ff_clean_intra_table_entries(s); //old mode?
4085 if(s->flags & CODEC_FLAG_QP_RD){
4086 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4087 const int last_qp= backup_s.qscale;
4088 int dquant, dir, qp, dc[6];
4090 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4092 assert(backup_s.dquant == 0);
4095 s->mv_dir= best_s.mv_dir;
4096 s->mv_type = MV_TYPE_16X16;
4097 s->mb_intra= best_s.mb_intra;
4098 s->mv[0][0][0] = best_s.mv[0][0][0];
4099 s->mv[0][0][1] = best_s.mv[0][0][1];
4100 s->mv[1][0][0] = best_s.mv[1][0][0];
4101 s->mv[1][0][1] = best_s.mv[1][0][1];
4103 dir= s->pict_type == B_TYPE ? 2 : 1;
4104 if(last_qp + dir > s->avctx->qmax) dir= -dir;
4105 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4106 qp= last_qp + dquant;
4107 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4109 backup_s.dquant= dquant;
4112 dc[i]= s->dc_val[0][ s->block_index[i] ];
4113 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4117 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
4118 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4119 if(best_s.qscale != qp){
4122 s->dc_val[0][ s->block_index[i] ]= dc[i];
4123 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4126 if(dir > 0 && dquant==dir){
4134 s->current_picture.qscale_table[xy]= qp;
4138 copy_context_after_encode(s, &best_s, -1);
4140 pb_bits_count= get_bit_count(&s->pb);
4141 flush_put_bits(&s->pb);
4142 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4145 if(s->data_partitioning){
4146 pb2_bits_count= get_bit_count(&s->pb2);
4147 flush_put_bits(&s->pb2);
4148 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4149 s->pb2= backup_s.pb2;
4151 tex_pb_bits_count= get_bit_count(&s->tex_pb);
4152 flush_put_bits(&s->tex_pb);
4153 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4154 s->tex_pb= backup_s.tex_pb;
4156 s->last_bits= get_bit_count(&s->pb);
4159 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4160 ff_h263_update_motion_val(s);
4164 s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad , s->linesize ,16);
4165 s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
4166 s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
4169 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4170 MPV_decode_mb(s, s->block);
4172 int motion_x, motion_y;
4173 s->mv_type=MV_TYPE_16X16;
4174 // only one MB-Type possible
4180 motion_x= s->mv[0][0][0] = 0;
4181 motion_y= s->mv[0][0][1] = 0;
4184 s->mv_dir = MV_DIR_FORWARD;
4186 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4187 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4189 case MB_TYPE_INTER4V:
4190 s->mv_dir = MV_DIR_FORWARD;
4191 s->mv_type = MV_TYPE_8X8;
4194 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4195 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4197 motion_x= motion_y= 0;
4199 case MB_TYPE_DIRECT:
4200 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4202 motion_x=s->b_direct_mv_table[xy][0];
4203 motion_y=s->b_direct_mv_table[xy][1];
4205 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4209 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4213 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4214 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4215 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4216 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4218 case MB_TYPE_BACKWARD:
4219 s->mv_dir = MV_DIR_BACKWARD;
4221 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4222 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4224 case MB_TYPE_FORWARD:
4225 s->mv_dir = MV_DIR_FORWARD;
4227 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4228 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4229 // printf(" %d %d ", motion_x, motion_y);
4232 motion_x=motion_y=0; //gcc warning fix
4233 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4236 encode_mb(s, motion_x, motion_y);
4238 // RAL: Update last macrobloc type
4239 s->last_mv_dir = s->mv_dir;
4242 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4243 ff_h263_update_motion_val(s);
4246 MPV_decode_mb(s, s->block);
4249 /* clean the MV table in IPS frames for direct mode in B frames */
4250 if(s->mb_intra /* && I,P,S_TYPE */){
4251 s->p_mv_table[xy][0]=0;
4252 s->p_mv_table[xy][1]=0;
4255 if(s->flags&CODEC_FLAG_PSNR){
4259 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4260 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4262 s->current_picture_ptr->error[0] += sse(
4263 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4264 s->dest[0], w, h, s->linesize);
4265 s->current_picture_ptr->error[1] += sse(
4266 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
4267 s->dest[1], w>>1, h>>1, s->uvlinesize);
4268 s->current_picture_ptr->error[2] += sse(
4269 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
4270 s->dest[2], w>>1, h>>1, s->uvlinesize);
4273 ff_h263_loop_filter(s);
4274 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
4280 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
4281 ff_mpeg4_merge_partitions(s);
4283 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4284 msmpeg4_encode_ext_header(s);
4286 if(s->codec_id==CODEC_ID_MPEG4)
4287 ff_mpeg4_stuffing(&s->pb);
4290 /* Send the last GOB if RTP */
4291 if (s->avctx->rtp_callback) {
4292 flush_put_bits(&s->pb);
4293 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4294 /* Call the RTP callback to send the last GOB */
4295 s->avctx->rtp_callback(s->ptr_lastgob, pdif, 0);
4299 void ff_denoise_dct(MpegEncContext *s, DCTELEM *block){
4300 const int intra= s->mb_intra;
4303 s->dct_count[intra]++;
4305 for(i=0; i<64; i++){
4306 int level= block[i];
4310 s->dct_error_sum[intra][i] += level;
4311 level -= s->dct_offset[intra][i];
4312 if(level<0) level=0;
4314 s->dct_error_sum[intra][i] -= level;
4315 level += s->dct_offset[intra][i];
4316 if(level>0) level=0;
4323 static int dct_quantize_trellis_c(MpegEncContext *s,
4324 DCTELEM *block, int n,
4325 int qscale, int *overflow){
4327 const uint8_t *scantable= s->intra_scantable.scantable;
4329 unsigned int threshold1, threshold2;
4338 int not_coded_score= 0;
4340 int coeff_count[64];
4341 int qmul, qadd, start_i, last_non_zero, i, dc;
4342 const int esc_length= s->ac_esc_length;
4344 uint8_t * last_length;
4347 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4348 const int patch_table= s->out_format == FMT_MPEG1 && !s->mb_intra;
4350 s->dsp.fdct (block);
4352 if(s->dct_error_sum)
4353 ff_denoise_dct(s, block);
4356 qadd= ((qscale-1)|1)*8;
4367 /* For AIC we skip quant/dequant of INTRADC */
4372 /* note: block[0] is assumed to be positive */
4373 block[0] = (block[0] + (q >> 1)) / q;
4376 qmat = s->q_intra_matrix[qscale];
4377 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4378 bias= 1<<(QMAT_SHIFT-1);
4379 length = s->intra_ac_vlc_length;
4380 last_length= s->intra_ac_vlc_last_length;
4384 qmat = s->q_inter_matrix[qscale];
4385 length = s->inter_ac_vlc_length;
4386 last_length= s->inter_ac_vlc_last_length;
4389 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4390 threshold2= (threshold1<<1);
4392 for(i=start_i; i<64; i++) {
4393 const int j = scantable[i];
4394 const int k= i-start_i;
4395 int level = block[j];
4396 level = level * qmat[j];
4398 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4399 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4400 if(((unsigned)(level+threshold1))>threshold2){
4402 level= (bias + level)>>QMAT_SHIFT;
4404 coeff[1][k]= level-1;
4405 // coeff[2][k]= level-2;
4407 level= (bias - level)>>QMAT_SHIFT;
4408 coeff[0][k]= -level;
4409 coeff[1][k]= -level+1;
4410 // coeff[2][k]= -level+2;
4412 coeff_count[k]= FFMIN(level, 2);
4413 assert(coeff_count[k]);
4417 coeff[0][k]= (level>>31)|1;
4422 *overflow= s->max_qcoeff < max; //overflow might have happend
4424 if(last_non_zero < start_i){
4425 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4426 return last_non_zero;
4432 // length[UNI_AC_ENC_INDEX(0, 63)]=
4433 // length[UNI_AC_ENC_INDEX(0, 65)]= 2;
4436 for(i=0; i<=last_non_zero - start_i; i++){
4437 int level_index, run, j;
4438 const int dct_coeff= block[ scantable[i + start_i] ];
4439 const int zero_distoration= dct_coeff*dct_coeff;
4440 int best_score=256*256*256*120;
4442 last_score += zero_distoration;
4443 not_coded_score += zero_distoration;
4444 for(level_index=0; level_index < coeff_count[i]; level_index++){
4446 int level= coeff[level_index][i];
4451 if(s->out_format == FMT_H263){
4453 unquant_coeff= level*qmul + qadd;
4455 unquant_coeff= level*qmul - qadd;
4458 j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
4461 unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
4462 unquant_coeff = -((unquant_coeff - 1) | 1);
4464 unquant_coeff = (int)( level * qscale * s->intra_matrix[j]) >> 3;
4465 unquant_coeff = (unquant_coeff - 1) | 1;
4469 unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4470 unquant_coeff = -((unquant_coeff - 1) | 1);
4472 unquant_coeff = ((( level << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4473 unquant_coeff = (unquant_coeff - 1) | 1;
4479 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4481 if((level&(~127)) == 0){
4482 for(run=0; run<=i - left_limit; run++){
4483 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4484 score += score_tab[i-run];
4486 if(score < best_score){
4488 score_tab[i+1]= score;
4490 level_tab[i+1]= level-64;
4494 if(s->out_format == FMT_H263){
4495 for(run=0; run<=i - left_limit; run++){
4496 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4497 score += score_tab[i-run];
4498 if(score < last_score){
4501 last_level= level-64;
4507 distoration += esc_length*lambda;
4508 for(run=0; run<=i - left_limit; run++){
4509 int score= distoration + score_tab[i-run];
4511 if(score < best_score){
4513 score_tab[i+1]= score;
4515 level_tab[i+1]= level-64;
4519 if(s->out_format == FMT_H263){
4520 for(run=0; run<=i - left_limit; run++){
4521 int score= distoration + score_tab[i-run];
4522 if(score < last_score){
4525 last_level= level-64;
4533 for(j=left_limit; j<=i; j++){
4534 score_tab[j] += zero_distoration;
4536 score_limit+= zero_distoration;
4537 if(score_tab[i+1] < score_limit)
4538 score_limit= score_tab[i+1];
4540 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4541 while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4544 // length[UNI_AC_ENC_INDEX(0, 63)]=
4545 // length[UNI_AC_ENC_INDEX(0, 65)]= 3;
4549 if(s->out_format != FMT_H263){
4550 last_score= 256*256*256*120;
4551 for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
4552 int score= score_tab[i];
4553 if(i) score += lambda*2; //FIXME exacter?
4555 if(score < last_score){
4558 last_level= level_tab[i];
4559 last_run= run_tab[i];
4564 s->coded_score[n] = last_score - not_coded_score;
4567 last_non_zero= last_i - 1 + start_i;
4568 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4570 if(last_non_zero < start_i)
4571 return last_non_zero;
4573 if(last_non_zero == 0 && start_i == 0){
4575 int best_score= dc * dc;
4577 for(i=0; i<coeff_count[0]; i++){
4578 int level= coeff[i][0];
4579 int unquant_coeff, score, distoration;
4581 if(s->out_format == FMT_H263){
4583 unquant_coeff= (level*qmul + qadd)>>3;
4585 unquant_coeff= (level*qmul - qadd)>>3;
4589 unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
4590 unquant_coeff = -((unquant_coeff - 1) | 1);
4592 unquant_coeff = ((( level << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
4593 unquant_coeff = (unquant_coeff - 1) | 1;
4596 unquant_coeff = (unquant_coeff + 4) >> 3;
4597 unquant_coeff<<= 3 + 3;
4599 distoration= (unquant_coeff - dc) * (unquant_coeff - dc);
4601 if((level&(~127)) == 0)
4602 score= distoration + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4604 score= distoration + esc_length*lambda;
4606 if(score < best_score){
4608 best_level= level - 64;
4611 block[0]= best_level;
4612 s->coded_score[n] = best_score - dc*dc;
4613 if(best_level == 0) return -1;
4614 else return last_non_zero;
4619 //FIXME use permutated scantable
4620 block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
4623 for(;i>0 ; i -= run_tab[i] + 1){
4624 const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
4626 block[j]= level_tab[i];
4630 return last_non_zero;
4633 static int dct_quantize_c(MpegEncContext *s,
4634 DCTELEM *block, int n,
4635 int qscale, int *overflow)
4637 int i, j, level, last_non_zero, q;
4639 const uint8_t *scantable= s->intra_scantable.scantable;
4642 unsigned int threshold1, threshold2;
4644 s->dsp.fdct (block);
4646 if(s->dct_error_sum)
4647 ff_denoise_dct(s, block);
4657 /* For AIC we skip quant/dequant of INTRADC */
4660 /* note: block[0] is assumed to be positive */
4661 block[0] = (block[0] + (q >> 1)) / q;
4664 qmat = s->q_intra_matrix[qscale];
4665 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4669 qmat = s->q_inter_matrix[qscale];
4670 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4672 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4673 threshold2= (threshold1<<1);
4678 level = level * qmat[j];
4680 // if( bias+level >= (1<<QMAT_SHIFT)
4681 // || bias-level >= (1<<QMAT_SHIFT)){
4682 if(((unsigned)(level+threshold1))>threshold2){
4684 level= (bias + level)>>QMAT_SHIFT;
4687 level= (bias - level)>>QMAT_SHIFT;
4696 *overflow= s->max_qcoeff < max; //overflow might have happend
4698 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4699 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4700 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4702 return last_non_zero;
4705 #endif //CONFIG_ENCODERS
4707 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
4708 DCTELEM *block, int n, int qscale)
4710 int i, level, nCoeffs;
4711 const uint16_t *quant_matrix;
4713 nCoeffs= s->block_last_index[n];
4717 block[0] = block[0] * s->y_dc_scale;
4719 block[0] = block[0] * s->c_dc_scale;
4720 /* XXX: only mpeg1 */
4721 quant_matrix = s->intra_matrix;
4722 for(i=1;i<=nCoeffs;i++) {
4723 int j= s->intra_scantable.permutated[i];
4728 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4729 level = (level - 1) | 1;
4732 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4733 level = (level - 1) | 1;
4736 if (level < -2048 || level > 2047)
4737 fprintf(stderr, "unquant error %d %d\n", i, level);
4744 quant_matrix = s->inter_matrix;
4745 for(;i<=nCoeffs;i++) {
4746 int j= s->intra_scantable.permutated[i];
4751 level = (((level << 1) + 1) * qscale *
4752 ((int) (quant_matrix[j]))) >> 4;
4753 level = (level - 1) | 1;
4756 level = (((level << 1) + 1) * qscale *
4757 ((int) (quant_matrix[j]))) >> 4;
4758 level = (level - 1) | 1;
4761 if (level < -2048 || level > 2047)
4762 fprintf(stderr, "unquant error %d %d\n", i, level);
4770 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
4771 DCTELEM *block, int n, int qscale)
4773 int i, level, nCoeffs;
4774 const uint16_t *quant_matrix;
4776 if(s->alternate_scan) nCoeffs= 63;
4777 else nCoeffs= s->block_last_index[n];
4781 block[0] = block[0] * s->y_dc_scale;
4783 block[0] = block[0] * s->c_dc_scale;
4784 quant_matrix = s->intra_matrix;
4785 for(i=1;i<=nCoeffs;i++) {
4786 int j= s->intra_scantable.permutated[i];
4791 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4794 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4797 if (level < -2048 || level > 2047)
4798 fprintf(stderr, "unquant error %d %d\n", i, level);
4806 quant_matrix = s->inter_matrix;
4807 for(;i<=nCoeffs;i++) {
4808 int j= s->intra_scantable.permutated[i];
4813 level = (((level << 1) + 1) * qscale *
4814 ((int) (quant_matrix[j]))) >> 4;
4817 level = (((level << 1) + 1) * qscale *
4818 ((int) (quant_matrix[j]))) >> 4;
4821 if (level < -2048 || level > 2047)
4822 fprintf(stderr, "unquant error %d %d\n", i, level);
4833 static void dct_unquantize_h263_c(MpegEncContext *s,
4834 DCTELEM *block, int n, int qscale)
4836 int i, level, qmul, qadd;
4839 assert(s->block_last_index[n]>=0);
4841 qadd = (qscale - 1) | 1;
4847 block[0] = block[0] * s->y_dc_scale;
4849 block[0] = block[0] * s->c_dc_scale;
4853 nCoeffs= 63; //does not allways use zigzag table
4856 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4859 for(;i<=nCoeffs;i++) {
4863 level = level * qmul - qadd;
4865 level = level * qmul + qadd;
4868 if (level < -2048 || level > 2047)
4869 fprintf(stderr, "unquant error %d %d\n", i, level);
4877 static const AVOption mpeg4_options[] =
4879 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4880 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4881 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4882 bit_rate_tolerance, 4, 240000000, 8000),
4883 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4884 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4885 AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4886 rc_eq, "tex^qComp,option1,options2", 0),
4887 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4888 rc_min_rate, 4, 24000000, 0),
4889 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4890 rc_max_rate, 4, 24000000, 0),
4891 AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4892 rc_buffer_aggressivity, 4, 24000000, 0),
4893 AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4894 rc_initial_cplx, 0., 9999999., 0),
4895 AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4896 i_quant_factor, 0., 0., 0),
4897 AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4898 i_quant_factor, -999999., 999999., 0),
4899 AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4900 dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4901 AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4902 lumi_masking, 0., 999999., 0),
4903 AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4904 temporal_cplx_masking, 0., 999999., 0),
4905 AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4906 spatial_cplx_masking, 0., 999999., 0),
4907 AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4908 p_masking, 0., 999999., 0),
4909 AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4910 dark_masking, 0., 999999., 0),
4911 AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4912 idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4914 AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4916 AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4919 AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4920 me_cmp, 0, 24000000, 0),
4921 AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4922 me_sub_cmp, 0, 24000000, 0),
4925 AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4926 dia_size, 0, 24000000, 0),
4927 AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4928 last_predictor_count, 0, 24000000, 0),
4930 AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4931 pre_me, 0, 24000000, 0),
4932 AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4933 me_pre_cmp, 0, 24000000, 0),
4935 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4936 me_range, 0, 24000000, 0),
4937 AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4938 pre_dia_size, 0, 24000000, 0),
4939 AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4940 me_subpel_quality, 0, 24000000, 0),
4941 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4942 me_range, 0, 24000000, 0),
4943 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4944 flags, CODEC_FLAG_PSNR, 0),
4945 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4947 AVOPTION_SUB(avoptions_common),
4951 #ifdef CONFIG_ENCODERS
4953 AVCodec mpeg1video_encoder = {
4956 CODEC_ID_MPEG1VIDEO,
4957 sizeof(MpegEncContext),
4965 AVCodec mpeg2video_encoder = {
4968 CODEC_ID_MPEG2VIDEO,
4969 sizeof(MpegEncContext),
4975 AVCodec h263_encoder = {
4979 sizeof(MpegEncContext),
4985 AVCodec h263p_encoder = {
4989 sizeof(MpegEncContext),
4995 AVCodec flv_encoder = {
4999 sizeof(MpegEncContext),
5005 AVCodec rv10_encoder = {
5009 sizeof(MpegEncContext),
5015 AVCodec mpeg4_encoder = {
5019 sizeof(MpegEncContext),
5023 .options = mpeg4_options,
5026 AVCodec msmpeg4v1_encoder = {
5030 sizeof(MpegEncContext),
5034 .options = mpeg4_options,
5037 AVCodec msmpeg4v2_encoder = {
5041 sizeof(MpegEncContext),
5045 .options = mpeg4_options,
5048 AVCodec msmpeg4v3_encoder = {
5052 sizeof(MpegEncContext),
5056 .options = mpeg4_options,
5059 AVCodec wmv1_encoder = {
5063 sizeof(MpegEncContext),
5067 .options = mpeg4_options,
5072 AVCodec mjpeg_encoder = {
5076 sizeof(MpegEncContext),
5082 #endif //CONFIG_ENCODERS