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"
33 #include "fastmemcpy.h"
39 #ifdef CONFIG_ENCODERS
40 static void encode_picture(MpegEncContext *s, int picture_number);
41 #endif //CONFIG_ENCODERS
42 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
43 DCTELEM *block, int n, int qscale);
44 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_h263_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
49 #ifdef CONFIG_ENCODERS
50 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
51 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
52 static int sse_mb(MpegEncContext *s);
53 #endif //CONFIG_ENCODERS
56 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
57 extern void XVMC_field_end(MpegEncContext *s);
58 extern void XVMC_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
61 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
64 /* enable all paranoid tests for rounding, overflows, etc... */
70 /* for jpeg fast DCT */
73 static const uint16_t aanscales[64] = {
74 /* precomputed values scaled up by 14 bits */
75 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
76 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
77 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
78 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
79 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
80 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
81 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
82 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
85 static const uint8_t h263_chroma_roundtab[16] = {
86 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
87 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
90 #ifdef CONFIG_ENCODERS
91 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
92 static uint8_t default_fcode_tab[MAX_MV*2+1];
94 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
96 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
97 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
101 for(qscale=qmin; qscale<=qmax; qscale++){
103 if (s->dsp.fdct == ff_jpeg_fdct_islow) {
105 const int j= s->dsp.idct_permutation[i];
106 /* 16 <= qscale * quant_matrix[i] <= 7905 */
107 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
108 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
109 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
111 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
112 (qscale * quant_matrix[j]));
114 } else if (s->dsp.fdct == fdct_ifast) {
116 const int j= s->dsp.idct_permutation[i];
117 /* 16 <= qscale * quant_matrix[i] <= 7905 */
118 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
119 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
120 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
122 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
123 (aanscales[i] * qscale * quant_matrix[j]));
127 const int j= s->dsp.idct_permutation[i];
128 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
129 So 16 <= qscale * quant_matrix[i] <= 7905
130 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
131 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
133 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
134 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
135 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
137 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
138 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
143 #endif //CONFIG_ENCODERS
145 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
149 st->scantable= src_scantable;
153 j = src_scantable[i];
154 st->permutated[i] = permutation[j];
163 j = st->permutated[i];
165 st->raster_end[i]= end;
169 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
175 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
181 /* init common dct for both encoder and decoder */
182 int DCT_common_init(MpegEncContext *s)
184 s->dct_unquantize_h263 = dct_unquantize_h263_c;
185 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
186 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
188 #ifdef CONFIG_ENCODERS
189 s->dct_quantize= dct_quantize_c;
193 MPV_common_init_mmx(s);
196 MPV_common_init_axp(s);
199 MPV_common_init_mlib(s);
202 MPV_common_init_mmi(s);
205 MPV_common_init_armv4l(s);
208 MPV_common_init_ppc(s);
211 #ifdef CONFIG_ENCODERS
212 s->fast_dct_quantize= s->dct_quantize;
214 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
215 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
218 #endif //CONFIG_ENCODERS
220 /* load & permutate scantables
221 note: only wmv uses differnt ones
223 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
224 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
225 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
226 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
228 s->picture_structure= PICT_FRAME;
234 * allocates a Picture
235 * The pixels are allocated/set by calling get_buffer() if shared=0
237 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
238 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
239 const int mb_array_size= s->mb_stride*s->mb_height;
243 assert(pic->data[0]);
244 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
245 pic->type= FF_BUFFER_TYPE_SHARED;
249 assert(!pic->data[0]);
251 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
253 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
254 fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
258 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
259 fprintf(stderr, "get_buffer() failed (stride changed)\n");
263 if(pic->linesize[1] != pic->linesize[2]){
264 fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
268 s->linesize = pic->linesize[0];
269 s->uvlinesize= pic->linesize[1];
272 if(pic->qscale_table==NULL){
274 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
275 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
276 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
277 CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
280 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
281 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
282 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(int))
283 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
284 if(s->out_format == FMT_H264){
286 CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
287 CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
290 pic->qstride= s->mb_stride;
293 //it might be nicer if the application would keep track of these but it would require a API change
294 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
295 s->prev_pict_types[0]= s->pict_type;
296 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
297 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
300 fail: //for the CHECKED_ALLOCZ macro
305 * deallocates a picture
307 static void free_picture(MpegEncContext *s, Picture *pic){
310 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
311 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
314 av_freep(&pic->mb_var);
315 av_freep(&pic->mc_mb_var);
316 av_freep(&pic->mb_mean);
317 av_freep(&pic->mb_cmp_score);
318 av_freep(&pic->mbskip_table);
319 av_freep(&pic->qscale_table);
320 av_freep(&pic->mb_type_base);
323 av_freep(&pic->motion_val[i]);
324 av_freep(&pic->ref_index[i]);
327 if(pic->type == FF_BUFFER_TYPE_SHARED){
336 /* init common structure for both encoder and decoder */
337 int MPV_common_init(MpegEncContext *s)
339 int y_size, c_size, yc_size, i, mb_array_size, x, y;
341 dsputil_init(&s->dsp, s->avctx);
344 s->flags= s->avctx->flags;
346 s->mb_width = (s->width + 15) / 16;
347 s->mb_height = (s->height + 15) / 16;
348 s->mb_stride = s->mb_width + 1;
349 mb_array_size= s->mb_height * s->mb_stride;
351 /* set default edge pos, will be overriden in decode_header if needed */
352 s->h_edge_pos= s->mb_width*16;
353 s->v_edge_pos= s->mb_height*16;
355 s->mb_num = s->mb_width * s->mb_height;
360 s->block_wrap[3]= s->mb_width*2 + 2;
362 s->block_wrap[5]= s->mb_width + 2;
364 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
365 c_size = (s->mb_width + 2) * (s->mb_height + 2);
366 yc_size = y_size + 2 * c_size;
368 /* convert fourcc to upper case */
369 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
370 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
371 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
372 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
374 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
375 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
376 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
377 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
379 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
380 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
382 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
384 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
385 for(y=0; y<s->mb_height; y++){
386 for(x=0; x<s->mb_width; x++){
387 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
390 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
393 int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
395 /* Allocate MV tables */
396 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
397 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
398 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
399 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
400 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
401 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
402 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
403 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
404 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
405 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
406 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
407 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
409 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
410 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t))
412 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
413 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
415 if(s->codec_id==CODEC_ID_MPEG4){
416 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
417 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
420 if(s->msmpeg4_version){
421 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
423 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
425 /* Allocate MB type table */
426 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint8_t)) //needed for encoding
429 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
431 if (s->out_format == FMT_H263 || s->encoding) {
435 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
436 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
439 if(s->codec_id==CODEC_ID_MPEG4){
440 /* interlaced direct mode decoding tables */
441 CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
442 CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
444 if (s->out_format == FMT_H263) {
446 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
447 s->ac_val[1] = s->ac_val[0] + y_size;
448 s->ac_val[2] = s->ac_val[1] + c_size;
451 CHECKED_ALLOCZ(s->coded_block, y_size);
453 /* divx501 bitstream reorder buffer */
454 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
456 /* cbp, ac_pred, pred_dir */
457 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
458 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
461 if (s->h263_pred || s->h263_plus || !s->encoding) {
463 //MN: we need these for error resilience of intra-frames
464 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
465 s->dc_val[1] = s->dc_val[0] + y_size;
466 s->dc_val[2] = s->dc_val[1] + c_size;
467 for(i=0;i<yc_size;i++)
468 s->dc_val[0][i] = 1024;
471 /* which mb is a intra block */
472 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
473 memset(s->mbintra_table, 1, mb_array_size);
475 /* default structure is frame */
476 s->picture_structure = PICT_FRAME;
478 /* init macroblock skip table */
479 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
480 //Note the +1 is for a quicker mpeg4 slice_end detection
481 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
483 s->block= s->blocks[0];
485 s->parse_context.state= -1;
487 s->context_initialized = 1;
497 /* init common structure for both encoder and decoder */
498 void MPV_common_end(MpegEncContext *s)
502 av_freep(&s->parse_context.buffer);
503 s->parse_context.buffer_size=0;
505 av_freep(&s->mb_type);
506 av_freep(&s->p_mv_table_base);
507 av_freep(&s->b_forw_mv_table_base);
508 av_freep(&s->b_back_mv_table_base);
509 av_freep(&s->b_bidir_forw_mv_table_base);
510 av_freep(&s->b_bidir_back_mv_table_base);
511 av_freep(&s->b_direct_mv_table_base);
513 s->b_forw_mv_table= NULL;
514 s->b_back_mv_table= NULL;
515 s->b_bidir_forw_mv_table= NULL;
516 s->b_bidir_back_mv_table= NULL;
517 s->b_direct_mv_table= NULL;
519 av_freep(&s->motion_val);
520 av_freep(&s->dc_val[0]);
521 av_freep(&s->ac_val[0]);
522 av_freep(&s->coded_block);
523 av_freep(&s->mbintra_table);
524 av_freep(&s->cbp_table);
525 av_freep(&s->pred_dir_table);
526 av_freep(&s->me.scratchpad);
527 av_freep(&s->me.map);
528 av_freep(&s->me.score_map);
530 av_freep(&s->mbskip_table);
531 av_freep(&s->prev_pict_types);
532 av_freep(&s->bitstream_buffer);
533 av_freep(&s->tex_pb_buffer);
534 av_freep(&s->pb2_buffer);
535 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
536 av_freep(&s->field_mv_table);
537 av_freep(&s->field_select_table);
538 av_freep(&s->avctx->stats_out);
539 av_freep(&s->ac_stats);
540 av_freep(&s->error_status_table);
541 av_freep(&s->mb_index2xy);
543 for(i=0; i<MAX_PICTURE_COUNT; i++){
544 free_picture(s, &s->picture[i]);
546 avcodec_default_free_buffers(s->avctx);
547 s->context_initialized = 0;
550 #ifdef CONFIG_ENCODERS
552 /* init video encoder */
553 int MPV_encode_init(AVCodecContext *avctx)
555 MpegEncContext *s = avctx->priv_data;
557 int chroma_h_shift, chroma_v_shift;
559 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
561 s->bit_rate = avctx->bit_rate;
562 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
563 s->width = avctx->width;
564 s->height = avctx->height;
565 if(avctx->gop_size > 600){
566 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
569 s->gop_size = avctx->gop_size;
570 s->rtp_mode = avctx->rtp_mode;
571 s->rtp_payload_size = avctx->rtp_payload_size;
572 if (avctx->rtp_callback)
573 s->rtp_callback = avctx->rtp_callback;
574 s->max_qdiff= avctx->max_qdiff;
575 s->qcompress= avctx->qcompress;
576 s->qblur= avctx->qblur;
578 s->flags= avctx->flags;
579 s->max_b_frames= avctx->max_b_frames;
580 s->b_frame_strategy= avctx->b_frame_strategy;
581 s->codec_id= avctx->codec->id;
582 s->luma_elim_threshold = avctx->luma_elim_threshold;
583 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
584 s->strict_std_compliance= avctx->strict_std_compliance;
585 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
586 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
587 s->mpeg_quant= avctx->mpeg_quant;
589 if (s->gop_size <= 1) {
596 s->me_method = avctx->me_method;
599 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
601 s->adaptive_quant= ( s->avctx->lumi_masking
602 || s->avctx->dark_masking
603 || s->avctx->temporal_cplx_masking
604 || s->avctx->spatial_cplx_masking
605 || s->avctx->p_masking)
608 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
610 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
611 fprintf(stderr, "4MV not supporetd by codec\n");
615 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
616 fprintf(stderr, "qpel not supporetd by codec\n");
620 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
621 fprintf(stderr, "data partitioning not supporetd by codec\n");
625 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
626 fprintf(stderr, "b frames not supporetd by codec\n");
630 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
631 fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
635 if(s->codec_id==CODEC_ID_MJPEG){
636 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
637 s->inter_quant_bias= 0;
638 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
639 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
640 s->inter_quant_bias= 0;
642 s->intra_quant_bias=0;
643 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
646 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
647 s->intra_quant_bias= avctx->intra_quant_bias;
648 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
649 s->inter_quant_bias= avctx->inter_quant_bias;
651 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
653 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
654 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
656 switch(avctx->codec->id) {
657 case CODEC_ID_MPEG1VIDEO:
658 s->out_format = FMT_MPEG1;
659 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
660 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
662 case CODEC_ID_MPEG2VIDEO:
663 s->out_format = FMT_MPEG1;
664 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
665 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
666 s->rtp_mode= 1; // mpeg2 must have slices
667 if(s->rtp_payload_size == 0) s->rtp_payload_size= 256*256*256;
671 s->out_format = FMT_MJPEG;
672 s->intra_only = 1; /* force intra only for jpeg */
673 s->mjpeg_write_tables = 1; /* write all tables */
674 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
675 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
676 s->mjpeg_vsample[1] = 1;
677 s->mjpeg_vsample[2] = 1;
678 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
679 s->mjpeg_hsample[1] = 1;
680 s->mjpeg_hsample[2] = 1;
681 if (mjpeg_init(s) < 0)
688 if (h263_get_picture_format(s->width, s->height) == 7) {
689 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
692 s->out_format = FMT_H263;
697 s->out_format = FMT_H263;
700 s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
701 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
703 /* These are just to be sure */
709 s->out_format = FMT_H263;
710 s->h263_flv = 2; /* format = 1; 11-bit codes */
711 s->unrestricted_mv = 1;
712 s->rtp_mode=0; /* don't allow GOB */
717 s->out_format = FMT_H263;
723 s->out_format = FMT_H263;
725 s->unrestricted_mv = 1;
726 s->low_delay= s->max_b_frames ? 0 : 1;
727 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
729 case CODEC_ID_MSMPEG4V1:
730 s->out_format = FMT_H263;
733 s->unrestricted_mv = 1;
734 s->msmpeg4_version= 1;
738 case CODEC_ID_MSMPEG4V2:
739 s->out_format = FMT_H263;
742 s->unrestricted_mv = 1;
743 s->msmpeg4_version= 2;
747 case CODEC_ID_MSMPEG4V3:
748 s->out_format = FMT_H263;
751 s->unrestricted_mv = 1;
752 s->msmpeg4_version= 3;
753 s->flipflop_rounding=1;
758 s->out_format = FMT_H263;
761 s->unrestricted_mv = 1;
762 s->msmpeg4_version= 4;
763 s->flipflop_rounding=1;
768 s->out_format = FMT_H263;
771 s->unrestricted_mv = 1;
772 s->msmpeg4_version= 5;
773 s->flipflop_rounding=1;
782 { /* set up some save defaults, some codecs might override them later */
788 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
789 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
790 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
792 for(i=-16; i<16; i++){
793 default_fcode_tab[i + MAX_MV]= 1;
797 s->me.mv_penalty= default_mv_penalty;
798 s->fcode_tab= default_fcode_tab;
800 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
802 /* dont use mv_penalty table for crap MV as it would be confused */
803 //FIXME remove after fixing / removing old ME
804 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
809 if (MPV_common_init(s) < 0)
814 #ifdef CONFIG_ENCODERS
816 if (s->out_format == FMT_H263)
818 if(s->msmpeg4_version)
819 ff_msmpeg4_encode_init(s);
821 if (s->out_format == FMT_MPEG1)
822 ff_mpeg1_encode_init(s);
825 /* init default q matrix */
827 int j= s->dsp.idct_permutation[i];
829 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
830 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
831 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
832 }else if(s->out_format == FMT_H263){
834 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
838 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
839 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
841 if(s->avctx->intra_matrix)
842 s->intra_matrix[j] = s->avctx->intra_matrix[i];
843 if(s->avctx->inter_matrix)
844 s->inter_matrix[j] = s->avctx->inter_matrix[i];
847 /* precompute matrix */
848 /* for mjpeg, we do include qscale in the matrix */
849 if (s->out_format != FMT_MJPEG) {
850 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
851 s->intra_matrix, s->intra_quant_bias, 1, 31);
852 convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
853 s->inter_matrix, s->inter_quant_bias, 1, 31);
856 if(ff_rate_control_init(s) < 0)
859 s->picture_number = 0;
860 s->picture_in_gop_number = 0;
861 s->fake_picture_number = 0;
862 /* motion detector init */
869 int MPV_encode_end(AVCodecContext *avctx)
871 MpegEncContext *s = avctx->priv_data;
877 ff_rate_control_uninit(s);
880 if (s->out_format == FMT_MJPEG)
883 av_freep(&avctx->extradata);
888 #endif //CONFIG_ENCODERS
890 void init_rl(RLTable *rl)
892 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
893 uint8_t index_run[MAX_RUN+1];
894 int last, run, level, start, end, i;
896 /* compute max_level[], max_run[] and index_run[] */
897 for(last=0;last<2;last++) {
906 memset(max_level, 0, MAX_RUN + 1);
907 memset(max_run, 0, MAX_LEVEL + 1);
908 memset(index_run, rl->n, MAX_RUN + 1);
909 for(i=start;i<end;i++) {
910 run = rl->table_run[i];
911 level = rl->table_level[i];
912 if (index_run[run] == rl->n)
914 if (level > max_level[run])
915 max_level[run] = level;
916 if (run > max_run[level])
917 max_run[level] = run;
919 rl->max_level[last] = av_malloc(MAX_RUN + 1);
920 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
921 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
922 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
923 rl->index_run[last] = av_malloc(MAX_RUN + 1);
924 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
928 /* draw the edges of width 'w' of an image of size width, height */
929 //FIXME check that this is ok for mpeg4 interlaced
930 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
932 uint8_t *ptr, *last_line;
935 last_line = buf + (height - 1) * wrap;
938 memcpy(buf - (i + 1) * wrap, buf, width);
939 memcpy(last_line + (i + 1) * wrap, last_line, width);
943 for(i=0;i<height;i++) {
944 memset(ptr - w, ptr[0], w);
945 memset(ptr + width, ptr[width-1], w);
950 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
951 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
952 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
953 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
957 static int find_unused_picture(MpegEncContext *s, int shared){
961 for(i=0; i<MAX_PICTURE_COUNT; i++){
962 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
965 for(i=0; i<MAX_PICTURE_COUNT; i++){
966 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
968 for(i=0; i<MAX_PICTURE_COUNT; i++){
969 if(s->picture[i].data[0]==NULL) break;
973 assert(i<MAX_PICTURE_COUNT);
977 /* generic function for encode/decode called before a frame is coded/decoded */
978 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
985 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
987 /* mark&release old frames */
988 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
989 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
991 /* release forgotten pictures */
992 /* if(mpeg124/h263) */
994 for(i=0; i<MAX_PICTURE_COUNT; i++){
995 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
996 fprintf(stderr, "releasing zombie picture\n");
997 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1004 /* release non refernce frames */
1005 for(i=0; i<MAX_PICTURE_COUNT; i++){
1006 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1007 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1011 i= find_unused_picture(s, 0);
1013 pic= (AVFrame*)&s->picture[i];
1014 pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1016 if(s->current_picture_ptr)
1017 pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
1019 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1022 s->current_picture_ptr= &s->picture[i];
1025 s->current_picture_ptr->pict_type= s->pict_type;
1026 s->current_picture_ptr->quality= s->qscale;
1027 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1029 s->current_picture= *s->current_picture_ptr;
1031 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1032 if (s->pict_type != B_TYPE) {
1033 s->last_picture_ptr= s->next_picture_ptr;
1034 s->next_picture_ptr= s->current_picture_ptr;
1037 if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
1038 if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
1039 if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
1041 if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
1042 fprintf(stderr, "warning: first frame is no keyframe\n");
1043 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1047 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1049 if(s->picture_structure!=PICT_FRAME){
1052 if(s->picture_structure == PICT_BOTTOM_FIELD){
1053 s->current_picture.data[i] += s->current_picture.linesize[i];
1055 s->current_picture.linesize[i] *= 2;
1056 s->last_picture.linesize[i] *=2;
1057 s->next_picture.linesize[i] *=2;
1062 s->hurry_up= s->avctx->hurry_up;
1063 s->error_resilience= avctx->error_resilience;
1065 /* set dequantizer, we cant do it during init as it might change for mpeg4
1066 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1067 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO)
1068 s->dct_unquantize = s->dct_unquantize_mpeg2;
1069 else if(s->out_format == FMT_H263)
1070 s->dct_unquantize = s->dct_unquantize_h263;
1072 s->dct_unquantize = s->dct_unquantize_mpeg1;
1075 if(s->avctx->xvmc_acceleration)
1076 return XVMC_field_start(s, avctx);
1081 /* generic function for encode/decode called after a frame has been coded/decoded */
1082 void MPV_frame_end(MpegEncContext *s)
1085 /* draw edge for correct motion prediction if outside */
1087 //just to make sure that all data is rendered.
1088 if(s->avctx->xvmc_acceleration){
1092 if(s->codec_id!=CODEC_ID_SVQ1 && s->out_format != FMT_MPEG1){
1093 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1094 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1095 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1096 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1101 s->last_pict_type = s->pict_type;
1102 if(s->pict_type!=B_TYPE){
1103 s->last_non_b_pict_type= s->pict_type;
1106 /* copy back current_picture variables */
1107 for(i=0; i<MAX_PICTURE_COUNT; i++){
1108 if(s->picture[i].data[0] == s->current_picture.data[0]){
1109 s->picture[i]= s->current_picture;
1113 assert(i<MAX_PICTURE_COUNT);
1117 /* release non refernce frames */
1118 for(i=0; i<MAX_PICTURE_COUNT; i++){
1119 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1120 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1124 // clear copies, to avoid confusion
1126 memset(&s->last_picture, 0, sizeof(Picture));
1127 memset(&s->next_picture, 0, sizeof(Picture));
1128 memset(&s->current_picture, 0, sizeof(Picture));
1133 * draws an line from (ex, ey) -> (sx, sy).
1134 * @param w width of the image
1135 * @param h height of the image
1136 * @param stride stride/linesize of the image
1137 * @param color color of the arrow
1139 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1142 sx= clip(sx, 0, w-1);
1143 sy= clip(sy, 0, h-1);
1144 ex= clip(ex, 0, w-1);
1145 ey= clip(ey, 0, h-1);
1147 buf[sy*stride + sx]+= color;
1149 if(ABS(ex - sx) > ABS(ey - sy)){
1154 buf+= sx + sy*stride;
1156 f= ((ey-sy)<<16)/ex;
1157 for(x= 0; x <= ex; x++){
1158 y= ((x*f) + (1<<15))>>16;
1159 buf[y*stride + x]+= color;
1166 buf+= sx + sy*stride;
1168 if(ey) f= ((ex-sx)<<16)/ey;
1170 for(y= 0; y <= ey; y++){
1171 x= ((y*f) + (1<<15))>>16;
1172 buf[y*stride + x]+= color;
1178 * draws an arrow from (ex, ey) -> (sx, sy).
1179 * @param w width of the image
1180 * @param h height of the image
1181 * @param stride stride/linesize of the image
1182 * @param color color of the arrow
1184 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1187 sx= clip(sx, -100, w+100);
1188 sy= clip(sy, -100, h+100);
1189 ex= clip(ex, -100, w+100);
1190 ey= clip(ey, -100, h+100);
1195 if(dx*dx + dy*dy > 3*3){
1198 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1200 //FIXME subpixel accuracy
1201 rx= ROUNDED_DIV(rx*3<<4, length);
1202 ry= ROUNDED_DIV(ry*3<<4, length);
1204 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1205 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1207 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1211 * prints debuging info for the given picture.
1213 void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1215 if(!pict || !pict->mb_type) return;
1217 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1220 for(y=0; y<s->mb_height; y++){
1221 for(x=0; x<s->mb_width; x++){
1222 if(s->avctx->debug&FF_DEBUG_SKIP){
1223 int count= s->mbskip_table[x + y*s->mb_stride];
1224 if(count>9) count=9;
1225 printf("%1d", count);
1227 if(s->avctx->debug&FF_DEBUG_QP){
1228 printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1230 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1231 int mb_type= pict->mb_type[x + y*s->mb_stride];
1233 //Type & MV direction
1236 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1238 else if(IS_INTRA4x4(mb_type))
1240 else if(IS_INTRA16x16(mb_type))
1242 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1244 else if(IS_DIRECT(mb_type))
1246 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1248 else if(IS_GMC(mb_type))
1250 else if(IS_SKIP(mb_type))
1252 else if(!USES_LIST(mb_type, 1))
1254 else if(!USES_LIST(mb_type, 0))
1257 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1264 else if(IS_16X8(mb_type))
1266 else if(IS_8X16(mb_type))
1268 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1274 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1285 if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1286 const int shift= 1 + s->quarter_sample;
1288 uint8_t *ptr= pict->data[0];
1289 s->low_delay=0; //needed to see the vectors without trashing the buffers
1291 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1293 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1294 const int mb_index= mb_x + mb_y*s->mb_stride;
1295 if(IS_8X8(s->current_picture.mb_type[mb_index])){
1298 int sx= mb_x*16 + 4 + 8*(i&1);
1299 int sy= mb_y*16 + 4 + 8*(i>>1);
1300 int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1301 int mx= (s->motion_val[xy][0]>>shift) + sx;
1302 int my= (s->motion_val[xy][1]>>shift) + sy;
1303 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1306 int sx= mb_x*16 + 8;
1307 int sy= mb_y*16 + 8;
1308 int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1309 int mx= (s->motion_val[xy][0]>>shift) + sx;
1310 int my= (s->motion_val[xy][1]>>shift) + sy;
1311 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1313 s->mbskip_table[mb_index]=0;
1319 #ifdef CONFIG_ENCODERS
1321 static int get_sae(uint8_t *src, int ref, int stride){
1325 for(y=0; y<16; y++){
1326 for(x=0; x<16; x++){
1327 acc+= ABS(src[x+y*stride] - ref);
1334 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1341 for(y=0; y<h; y+=16){
1342 for(x=0; x<w; x+=16){
1343 int offset= x + y*stride;
1344 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1345 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1346 int sae = get_sae(src + offset, mean, stride);
1348 acc+= sae + 500 < sad;
1355 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1358 const int encoding_delay= s->max_b_frames;
1362 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1363 if(pic_arg->linesize[0] != s->linesize) direct=0;
1364 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1365 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1367 // printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1370 i= find_unused_picture(s, 1);
1372 pic= (AVFrame*)&s->picture[i];
1376 pic->data[i]= pic_arg->data[i];
1377 pic->linesize[i]= pic_arg->linesize[i];
1379 alloc_picture(s, (Picture*)pic, 1);
1381 i= find_unused_picture(s, 0);
1383 pic= (AVFrame*)&s->picture[i];
1386 alloc_picture(s, (Picture*)pic, 0);
1388 /* the input will be 16 pixels to the right relative to the actual buffer start
1389 * and the current_pic, so the buffer can be reused, yes its not beatifull
1394 if( pic->data[0] == pic_arg->data[0]
1395 && pic->data[1] == pic_arg->data[1]
1396 && pic->data[2] == pic_arg->data[2]){
1399 int h_chroma_shift, v_chroma_shift;
1400 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1403 int src_stride= pic_arg->linesize[i];
1404 int dst_stride= i ? s->uvlinesize : s->linesize;
1405 int h_shift= i ? h_chroma_shift : 0;
1406 int v_shift= i ? v_chroma_shift : 0;
1407 int w= s->width >>h_shift;
1408 int h= s->height>>v_shift;
1409 uint8_t *src= pic_arg->data[i];
1410 uint8_t *dst= pic->data[i];
1412 if(src_stride==dst_stride)
1413 memcpy(dst, src, src_stride*h);
1416 memcpy(dst, src, w);
1424 pic->quality= pic_arg->quality;
1425 pic->pict_type= pic_arg->pict_type;
1426 pic->pts = pic_arg->pts;
1428 if(s->input_picture[encoding_delay])
1429 pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1433 /* shift buffer entries */
1434 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1435 s->input_picture[i-1]= s->input_picture[i];
1437 s->input_picture[encoding_delay]= (Picture*)pic;
1442 static void select_input_picture(MpegEncContext *s){
1444 int coded_pic_num=0;
1446 if(s->reordered_input_picture[0])
1447 coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1449 for(i=1; i<MAX_PICTURE_COUNT; i++)
1450 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1451 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1453 /* set next picture types & ordering */
1454 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1455 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1456 s->reordered_input_picture[0]= s->input_picture[0];
1457 s->reordered_input_picture[0]->pict_type= I_TYPE;
1458 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1462 if(s->flags&CODEC_FLAG_PASS2){
1463 for(i=0; i<s->max_b_frames+1; i++){
1464 int pict_num= s->input_picture[0]->display_picture_number + i;
1465 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1466 s->input_picture[i]->pict_type= pict_type;
1468 if(i + 1 >= s->rc_context.num_entries) break;
1472 if(s->input_picture[0]->pict_type){
1473 /* user selected pict_type */
1474 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1475 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1478 if(b_frames > s->max_b_frames){
1479 fprintf(stderr, "warning, too many bframes in a row\n");
1480 b_frames = s->max_b_frames;
1482 }else if(s->b_frame_strategy==0){
1483 b_frames= s->max_b_frames;
1484 while(b_frames && !s->input_picture[b_frames]) b_frames--;
1485 }else if(s->b_frame_strategy==1){
1486 for(i=1; i<s->max_b_frames+1; i++){
1487 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1488 s->input_picture[i]->b_frame_score=
1489 get_intra_count(s, s->input_picture[i ]->data[0],
1490 s->input_picture[i-1]->data[0], s->linesize) + 1;
1493 for(i=0; i<s->max_b_frames; i++){
1494 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1497 b_frames= FFMAX(0, i-1);
1500 for(i=0; i<b_frames+1; i++){
1501 s->input_picture[i]->b_frame_score=0;
1504 fprintf(stderr, "illegal b frame strategy\n");
1509 //static int b_count=0;
1510 //b_count+= b_frames;
1511 //printf("b_frames: %d\n", b_count);
1513 s->reordered_input_picture[0]= s->input_picture[b_frames];
1514 if( s->picture_in_gop_number + b_frames >= s->gop_size
1515 || s->reordered_input_picture[0]->pict_type== I_TYPE)
1516 s->reordered_input_picture[0]->pict_type= I_TYPE;
1518 s->reordered_input_picture[0]->pict_type= P_TYPE;
1519 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1520 for(i=0; i<b_frames; i++){
1522 s->reordered_input_picture[i+1]= s->input_picture[i];
1523 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1524 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1529 if(s->reordered_input_picture[0]){
1530 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1532 s->new_picture= *s->reordered_input_picture[0];
1534 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1535 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1537 int i= find_unused_picture(s, 0);
1538 Picture *pic= &s->picture[i];
1540 /* mark us unused / free shared pic */
1542 s->reordered_input_picture[0]->data[i]= NULL;
1543 s->reordered_input_picture[0]->type= 0;
1545 //FIXME bad, copy * except
1546 pic->pict_type = s->reordered_input_picture[0]->pict_type;
1547 pic->quality = s->reordered_input_picture[0]->quality;
1548 pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1549 pic->reference = s->reordered_input_picture[0]->reference;
1550 pic->pts = s->reordered_input_picture[0]->pts;
1552 alloc_picture(s, pic, 0);
1554 s->current_picture_ptr= pic;
1556 // input is not a shared pix -> reuse buffer for current_pix
1558 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1559 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1561 s->current_picture_ptr= s->reordered_input_picture[0];
1563 //reverse the +16 we did before storing the input
1564 s->current_picture_ptr->data[i]-=16;
1567 s->current_picture= *s->current_picture_ptr;
1569 s->picture_number= s->new_picture.display_picture_number;
1570 //printf("dpn:%d\n", s->picture_number);
1572 memset(&s->new_picture, 0, sizeof(Picture));
1576 int MPV_encode_picture(AVCodecContext *avctx,
1577 unsigned char *buf, int buf_size, void *data)
1579 MpegEncContext *s = avctx->priv_data;
1580 AVFrame *pic_arg = data;
1583 if(avctx->pix_fmt != PIX_FMT_YUV420P){
1584 fprintf(stderr, "this codec supports only YUV420P\n");
1588 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1590 s->picture_in_gop_number++;
1592 load_input_picture(s, pic_arg);
1594 select_input_picture(s);
1597 if(s->new_picture.data[0]){
1599 s->pict_type= s->new_picture.pict_type;
1600 if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1601 s->qscale= (int)(s->new_picture.quality+0.5);
1605 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1606 MPV_frame_start(s, avctx);
1608 encode_picture(s, s->picture_number);
1610 avctx->real_pict_num = s->picture_number;
1611 avctx->header_bits = s->header_bits;
1612 avctx->mv_bits = s->mv_bits;
1613 avctx->misc_bits = s->misc_bits;
1614 avctx->i_tex_bits = s->i_tex_bits;
1615 avctx->p_tex_bits = s->p_tex_bits;
1616 avctx->i_count = s->i_count;
1617 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1618 avctx->skip_count = s->skip_count;
1622 if (s->out_format == FMT_MJPEG)
1623 mjpeg_picture_trailer(s);
1625 if(s->flags&CODEC_FLAG_PASS1)
1626 ff_write_pass1_stats(s);
1629 avctx->error[i] += s->current_picture_ptr->error[i];
1633 s->input_picture_number++;
1635 flush_put_bits(&s->pb);
1636 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1638 s->total_bits += s->frame_bits;
1639 avctx->frame_bits = s->frame_bits;
1641 return pbBufPtr(&s->pb) - s->pb.buf;
1644 #endif //CONFIG_ENCODERS
1646 static inline void gmc1_motion(MpegEncContext *s,
1647 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1649 uint8_t **ref_picture, int src_offset)
1652 int offset, src_x, src_y, linesize, uvlinesize;
1653 int motion_x, motion_y;
1656 motion_x= s->sprite_offset[0][0];
1657 motion_y= s->sprite_offset[0][1];
1658 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1659 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1660 motion_x<<=(3-s->sprite_warping_accuracy);
1661 motion_y<<=(3-s->sprite_warping_accuracy);
1662 src_x = clip(src_x, -16, s->width);
1663 if (src_x == s->width)
1665 src_y = clip(src_y, -16, s->height);
1666 if (src_y == s->height)
1669 linesize = s->linesize;
1670 uvlinesize = s->uvlinesize;
1672 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1674 dest_y+=dest_offset;
1675 if(s->flags&CODEC_FLAG_EMU_EDGE){
1676 if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1677 || src_y + 17 >= s->v_edge_pos){
1678 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1679 ptr= s->edge_emu_buffer;
1683 if((motion_x|motion_y)&7){
1684 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1685 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1689 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1690 if (s->no_rounding){
1691 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1693 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
1697 if(s->flags&CODEC_FLAG_GRAY) return;
1699 motion_x= s->sprite_offset[1][0];
1700 motion_y= s->sprite_offset[1][1];
1701 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1702 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1703 motion_x<<=(3-s->sprite_warping_accuracy);
1704 motion_y<<=(3-s->sprite_warping_accuracy);
1705 src_x = clip(src_x, -8, s->width>>1);
1706 if (src_x == s->width>>1)
1708 src_y = clip(src_y, -8, s->height>>1);
1709 if (src_y == s->height>>1)
1712 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1713 ptr = ref_picture[1] + offset;
1714 if(s->flags&CODEC_FLAG_EMU_EDGE){
1715 if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1716 || src_y + 9 >= s->v_edge_pos>>1){
1717 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);
1718 ptr= s->edge_emu_buffer;
1722 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1724 ptr = ref_picture[2] + offset;
1726 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);
1727 ptr= s->edge_emu_buffer;
1729 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1734 static inline void gmc_motion(MpegEncContext *s,
1735 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1737 uint8_t **ref_picture, int src_offset)
1740 int linesize, uvlinesize;
1741 const int a= s->sprite_warping_accuracy;
1744 linesize = s->linesize;
1745 uvlinesize = s->uvlinesize;
1747 ptr = ref_picture[0] + src_offset;
1749 dest_y+=dest_offset;
1751 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1752 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1754 s->dsp.gmc(dest_y, ptr, linesize, 16,
1757 s->sprite_delta[0][0], s->sprite_delta[0][1],
1758 s->sprite_delta[1][0], s->sprite_delta[1][1],
1759 a+1, (1<<(2*a+1)) - s->no_rounding,
1760 s->h_edge_pos, s->v_edge_pos);
1761 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1762 ox + s->sprite_delta[0][0]*8,
1763 oy + s->sprite_delta[1][0]*8,
1764 s->sprite_delta[0][0], s->sprite_delta[0][1],
1765 s->sprite_delta[1][0], s->sprite_delta[1][1],
1766 a+1, (1<<(2*a+1)) - s->no_rounding,
1767 s->h_edge_pos, s->v_edge_pos);
1769 if(s->flags&CODEC_FLAG_GRAY) return;
1772 dest_cb+=dest_offset>>1;
1773 dest_cr+=dest_offset>>1;
1775 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1776 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1778 ptr = ref_picture[1] + (src_offset>>1);
1779 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1782 s->sprite_delta[0][0], s->sprite_delta[0][1],
1783 s->sprite_delta[1][0], s->sprite_delta[1][1],
1784 a+1, (1<<(2*a+1)) - s->no_rounding,
1785 s->h_edge_pos>>1, s->v_edge_pos>>1);
1787 ptr = ref_picture[2] + (src_offset>>1);
1788 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1791 s->sprite_delta[0][0], s->sprite_delta[0][1],
1792 s->sprite_delta[1][0], s->sprite_delta[1][1],
1793 a+1, (1<<(2*a+1)) - s->no_rounding,
1794 s->h_edge_pos>>1, s->v_edge_pos>>1);
1798 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1799 * @param buf destination buffer
1800 * @param src source buffer
1801 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1802 * @param block_w width of block
1803 * @param block_h height of block
1804 * @param src_x x coordinate of the top left sample of the block in the source buffer
1805 * @param src_y y coordinate of the top left sample of the block in the source buffer
1806 * @param w width of the source buffer
1807 * @param h height of the source buffer
1809 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1810 int src_x, int src_y, int w, int h){
1812 int start_y, start_x, end_y, end_x;
1815 src+= (h-1-src_y)*linesize;
1817 }else if(src_y<=-block_h){
1818 src+= (1-block_h-src_y)*linesize;
1824 }else if(src_x<=-block_w){
1825 src+= (1-block_w-src_x);
1829 start_y= FFMAX(0, -src_y);
1830 start_x= FFMAX(0, -src_x);
1831 end_y= FFMIN(block_h, h-src_y);
1832 end_x= FFMIN(block_w, w-src_x);
1834 // copy existing part
1835 for(y=start_y; y<end_y; y++){
1836 for(x=start_x; x<end_x; x++){
1837 buf[x + y*linesize]= src[x + y*linesize];
1842 for(y=0; y<start_y; y++){
1843 for(x=start_x; x<end_x; x++){
1844 buf[x + y*linesize]= buf[x + start_y*linesize];
1849 for(y=end_y; y<block_h; y++){
1850 for(x=start_x; x<end_x; x++){
1851 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1855 for(y=0; y<block_h; y++){
1857 for(x=0; x<start_x; x++){
1858 buf[x + y*linesize]= buf[start_x + y*linesize];
1862 for(x=end_x; x<block_w; x++){
1863 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1869 /* apply one mpeg motion vector to the three components */
1870 static inline void mpeg_motion(MpegEncContext *s,
1871 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1873 uint8_t **ref_picture, int src_offset,
1874 int field_based, op_pixels_func (*pix_op)[4],
1875 int motion_x, int motion_y, int h)
1878 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1881 if(s->quarter_sample)
1887 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1888 src_x = s->mb_x * 16 + (motion_x >> 1);
1889 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1891 /* WARNING: do no forget half pels */
1892 height = s->height >> field_based;
1893 v_edge_pos = s->v_edge_pos >> field_based;
1894 src_x = clip(src_x, -16, s->width);
1895 if (src_x == s->width)
1897 src_y = clip(src_y, -16, height);
1898 if (src_y == height)
1900 linesize = s->current_picture.linesize[0] << field_based;
1901 uvlinesize = s->current_picture.linesize[1] << field_based;
1902 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1903 dest_y += dest_offset;
1905 if(s->flags&CODEC_FLAG_EMU_EDGE){
1906 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1907 || src_y + (motion_y&1) + h > v_edge_pos){
1908 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, //FIXME linesize? and uv below
1909 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1910 ptr= s->edge_emu_buffer + src_offset;
1914 pix_op[0][dxy](dest_y, ptr, linesize, h);
1916 if(s->flags&CODEC_FLAG_GRAY) return;
1918 if (s->out_format == FMT_H263) {
1920 if ((motion_x & 3) != 0)
1922 if ((motion_y & 3) != 0)
1929 dxy = ((my & 1) << 1) | (mx & 1);
1934 src_x = s->mb_x * 8 + mx;
1935 src_y = s->mb_y * (8 >> field_based) + my;
1936 src_x = clip(src_x, -8, s->width >> 1);
1937 if (src_x == (s->width >> 1))
1939 src_y = clip(src_y, -8, height >> 1);
1940 if (src_y == (height >> 1))
1942 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1943 ptr = ref_picture[1] + offset;
1945 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1946 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1947 ptr= s->edge_emu_buffer + (src_offset >> 1);
1949 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1951 ptr = ref_picture[2] + offset;
1953 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1954 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1955 ptr= s->edge_emu_buffer + (src_offset >> 1);
1957 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1960 static inline void qpel_motion(MpegEncContext *s,
1961 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1963 uint8_t **ref_picture, int src_offset,
1964 int field_based, op_pixels_func (*pix_op)[4],
1965 qpel_mc_func (*qpix_op)[16],
1966 int motion_x, int motion_y, int h)
1969 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1972 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1973 src_x = s->mb_x * 16 + (motion_x >> 2);
1974 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1976 height = s->height >> field_based;
1977 v_edge_pos = s->v_edge_pos >> field_based;
1978 src_x = clip(src_x, -16, s->width);
1979 if (src_x == s->width)
1981 src_y = clip(src_y, -16, height);
1982 if (src_y == height)
1984 linesize = s->linesize << field_based;
1985 uvlinesize = s->uvlinesize << field_based;
1986 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1987 dest_y += dest_offset;
1988 //printf("%d %d %d\n", src_x, src_y, dxy);
1990 if(s->flags&CODEC_FLAG_EMU_EDGE){
1991 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1992 || src_y + (motion_y&3) + h > v_edge_pos){
1993 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,
1994 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1995 ptr= s->edge_emu_buffer + src_offset;
2000 qpix_op[0][dxy](dest_y, ptr, linesize);
2002 //damn interlaced mode
2003 //FIXME boundary mirroring is not exactly correct here
2004 qpix_op[1][dxy](dest_y , ptr , linesize);
2005 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2008 if(s->flags&CODEC_FLAG_GRAY) return;
2013 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2014 static const int rtab[8]= {0,0,1,1,0,0,0,1};
2015 mx= (motion_x>>1) + rtab[motion_x&7];
2016 my= (motion_y>>1) + rtab[motion_y&7];
2017 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2018 mx= (motion_x>>1)|(motion_x&1);
2019 my= (motion_y>>1)|(motion_y&1);
2027 dxy= (mx&1) | ((my&1)<<1);
2031 src_x = s->mb_x * 8 + mx;
2032 src_y = s->mb_y * (8 >> field_based) + my;
2033 src_x = clip(src_x, -8, s->width >> 1);
2034 if (src_x == (s->width >> 1))
2036 src_y = clip(src_y, -8, height >> 1);
2037 if (src_y == (height >> 1))
2040 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2041 ptr = ref_picture[1] + offset;
2043 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
2044 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2045 ptr= s->edge_emu_buffer + (src_offset >> 1);
2047 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2049 ptr = ref_picture[2] + offset;
2051 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
2052 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2053 ptr= s->edge_emu_buffer + (src_offset >> 1);
2055 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2058 inline int ff_h263_round_chroma(int x){
2060 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2063 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2068 * motion compesation of a single macroblock
2070 * @param dest_y luma destination pointer
2071 * @param dest_cb chroma cb/u destination pointer
2072 * @param dest_cr chroma cr/v destination pointer
2073 * @param dir direction (0->forward, 1->backward)
2074 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2075 * @param pic_op halfpel motion compensation function (average or put normally)
2076 * @param pic_op qpel motion compensation function (average or put normally)
2077 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2079 static inline void MPV_motion(MpegEncContext *s,
2080 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2081 int dir, uint8_t **ref_picture,
2082 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2084 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2086 uint8_t *ptr, *dest;
2092 switch(s->mv_type) {
2096 if(s->real_sprite_warping_points==1){
2097 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2100 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2103 }else if(s->quarter_sample){
2104 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2107 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2109 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2110 ref_picture, pix_op,
2111 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2115 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2118 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2124 if(s->quarter_sample){
2126 motion_x = s->mv[dir][i][0];
2127 motion_y = s->mv[dir][i][1];
2129 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2130 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2131 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2133 /* WARNING: do no forget half pels */
2134 src_x = clip(src_x, -16, s->width);
2135 if (src_x == s->width)
2137 src_y = clip(src_y, -16, s->height);
2138 if (src_y == s->height)
2141 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2142 if(s->flags&CODEC_FLAG_EMU_EDGE){
2143 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
2144 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
2145 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);
2146 ptr= s->edge_emu_buffer;
2149 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2150 qpix_op[1][dxy](dest, ptr, s->linesize);
2152 mx += s->mv[dir][i][0]/2;
2153 my += s->mv[dir][i][1]/2;
2157 motion_x = s->mv[dir][i][0];
2158 motion_y = s->mv[dir][i][1];
2160 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2161 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2162 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2164 /* WARNING: do no forget half pels */
2165 src_x = clip(src_x, -16, s->width);
2166 if (src_x == s->width)
2168 src_y = clip(src_y, -16, s->height);
2169 if (src_y == s->height)
2172 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2173 if(s->flags&CODEC_FLAG_EMU_EDGE){
2174 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2175 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2176 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);
2177 ptr= s->edge_emu_buffer;
2180 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2181 pix_op[1][dxy](dest, ptr, s->linesize, 8);
2183 mx += s->mv[dir][i][0];
2184 my += s->mv[dir][i][1];
2188 if(s->flags&CODEC_FLAG_GRAY) break;
2189 /* In case of 8X8, we construct a single chroma motion vector
2190 with a special rounding */
2191 mx= ff_h263_round_chroma(mx);
2192 my= ff_h263_round_chroma(my);
2193 dxy = ((my & 1) << 1) | (mx & 1);
2197 src_x = mb_x * 8 + mx;
2198 src_y = mb_y * 8 + my;
2199 src_x = clip(src_x, -8, s->width/2);
2200 if (src_x == s->width/2)
2202 src_y = clip(src_y, -8, s->height/2);
2203 if (src_y == s->height/2)
2206 offset = (src_y * (s->uvlinesize)) + src_x;
2207 ptr = ref_picture[1] + offset;
2208 if(s->flags&CODEC_FLAG_EMU_EDGE){
2209 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2210 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2211 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);
2212 ptr= s->edge_emu_buffer;
2216 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2218 ptr = ref_picture[2] + offset;
2220 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);
2221 ptr= s->edge_emu_buffer;
2223 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2226 if (s->picture_structure == PICT_FRAME) {
2227 if(s->quarter_sample){
2229 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2230 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2232 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2234 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2235 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2237 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2240 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2241 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2243 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2245 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2246 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2248 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2252 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2253 offset= s->field_select[dir][0] ? s->linesize : 0;
2255 ref_picture= s->current_picture.data;
2256 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2259 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2260 ref_picture, offset,
2262 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2267 uint8_t ** ref2picture;
2269 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2270 ref2picture= ref_picture;
2271 offset= s->field_select[dir][0] ? s->linesize : 0;
2273 ref2picture= s->current_picture.data;
2274 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2277 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2278 ref2picture, offset,
2280 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2283 if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2284 ref2picture= ref_picture;
2285 offset= s->field_select[dir][1] ? s->linesize : 0;
2287 ref2picture= s->current_picture.data;
2288 offset= s->field_select[dir][1] ? s->linesize : -s->linesize;
2290 // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2291 mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2293 ref2picture, offset,
2295 s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2301 op_pixels_func (*dmv_pix_op)[4];
2304 dmv_pix_op = s->dsp.put_pixels_tab;
2306 if(s->picture_structure == PICT_FRAME){
2307 //put top field from top field
2308 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2311 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2312 //put bottom field from bottom field
2313 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2314 ref_picture, s->linesize,
2316 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2318 dmv_pix_op = s->dsp.avg_pixels_tab;
2320 //avg top field from bottom field
2321 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2322 ref_picture, s->linesize,
2324 s->mv[dir][2][0], s->mv[dir][2][1], 8);
2325 //avg bottom field from top field
2326 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2329 s->mv[dir][3][0], s->mv[dir][3][1], 8);
2332 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2335 //put field from the same parity
2336 //same parity is never in the same frame
2337 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2340 s->mv[dir][0][0],s->mv[dir][0][1],16);
2342 // after put we make avg of the same block
2343 dmv_pix_op=s->dsp.avg_pixels_tab;
2345 //opposite parity is always in the same frame if this is second field
2346 if(!s->first_field){
2347 ref_picture = s->current_picture.data;
2348 //top field is one linesize from frame beginig
2349 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2350 -s->linesize : s->linesize;
2352 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2355 //avg field from the opposite parity
2356 mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2357 ref_picture, offset,
2359 s->mv[dir][2][0],s->mv[dir][2][1],16);
2368 /* put block[] to dest[] */
2369 static inline void put_dct(MpegEncContext *s,
2370 DCTELEM *block, int i, uint8_t *dest, int line_size)
2372 s->dct_unquantize(s, block, i, s->qscale);
2373 s->dsp.idct_put (dest, line_size, block);
2376 /* add block[] to dest[] */
2377 static inline void add_dct(MpegEncContext *s,
2378 DCTELEM *block, int i, uint8_t *dest, int line_size)
2380 if (s->block_last_index[i] >= 0) {
2381 s->dsp.idct_add (dest, line_size, block);
2385 static inline void add_dequant_dct(MpegEncContext *s,
2386 DCTELEM *block, int i, uint8_t *dest, int line_size)
2388 if (s->block_last_index[i] >= 0) {
2389 s->dct_unquantize(s, block, i, s->qscale);
2391 s->dsp.idct_add (dest, line_size, block);
2396 * cleans dc, ac, coded_block for the current non intra MB
2398 void ff_clean_intra_table_entries(MpegEncContext *s)
2400 int wrap = s->block_wrap[0];
2401 int xy = s->block_index[0];
2404 s->dc_val[0][xy + 1 ] =
2405 s->dc_val[0][xy + wrap] =
2406 s->dc_val[0][xy + 1 + wrap] = 1024;
2408 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2409 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2410 if (s->msmpeg4_version>=3) {
2411 s->coded_block[xy ] =
2412 s->coded_block[xy + 1 ] =
2413 s->coded_block[xy + wrap] =
2414 s->coded_block[xy + 1 + wrap] = 0;
2417 wrap = s->block_wrap[4];
2418 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2420 s->dc_val[2][xy] = 1024;
2422 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2423 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2425 s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2428 /* generic function called after a macroblock has been parsed by the
2429 decoder or after it has been encoded by the encoder.
2431 Important variables used:
2432 s->mb_intra : true if intra macroblock
2433 s->mv_dir : motion vector direction
2434 s->mv_type : motion vector type
2435 s->mv : motion vector
2436 s->interlaced_dct : true if interlaced dct used (mpeg2)
2438 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2441 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2443 if(s->avctx->xvmc_acceleration){
2444 XVMC_decode_mb(s,block);
2452 s->current_picture.qscale_table[mb_xy]= s->qscale;
2454 /* update DC predictors for P macroblocks */
2456 if (s->h263_pred || s->h263_aic) {
2457 if(s->mbintra_table[mb_xy])
2458 ff_clean_intra_table_entries(s);
2462 s->last_dc[2] = 128 << s->intra_dc_precision;
2465 else if (s->h263_pred || s->h263_aic)
2466 s->mbintra_table[mb_xy]=1;
2468 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2469 uint8_t *dest_y, *dest_cb, *dest_cr;
2470 int dct_linesize, dct_offset;
2471 op_pixels_func (*op_pix)[4];
2472 qpel_mc_func (*op_qpix)[16];
2473 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2474 const int uvlinesize= s->current_picture.linesize[1];
2476 /* avoid copy if macroblock skipped in last frame too */
2477 /* skip only during decoding as we might trash the buffers during encoding a bit */
2479 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2480 const int age= s->current_picture.age;
2486 assert(s->pict_type!=I_TYPE);
2488 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2489 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2491 /* if previous was skipped too, then nothing to do ! */
2492 if (*mbskip_ptr >= age && s->current_picture.reference){
2495 } else if(!s->current_picture.reference){
2496 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2497 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2499 *mbskip_ptr = 0; /* not skipped */
2503 if (s->interlaced_dct) {
2504 dct_linesize = linesize * 2;
2505 dct_offset = linesize;
2507 dct_linesize = linesize;
2508 dct_offset = linesize * 8;
2512 dest_cb= s->dest[1];
2513 dest_cr= s->dest[2];
2516 /* motion handling */
2517 /* decoding or more than one mb_type (MC was allready done otherwise) */
2519 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2520 op_pix = s->dsp.put_pixels_tab;
2521 op_qpix= s->dsp.put_qpel_pixels_tab;
2523 op_pix = s->dsp.put_no_rnd_pixels_tab;
2524 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2527 if (s->mv_dir & MV_DIR_FORWARD) {
2528 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2529 op_pix = s->dsp.avg_pixels_tab;
2530 op_qpix= s->dsp.avg_qpel_pixels_tab;
2532 if (s->mv_dir & MV_DIR_BACKWARD) {
2533 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2537 /* skip dequant / idct if we are really late ;) */
2538 if(s->hurry_up>1) return;
2540 /* add dct residue */
2541 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2542 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2543 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2544 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2545 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2546 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2548 if(!(s->flags&CODEC_FLAG_GRAY)){
2549 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2550 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2552 } else if(s->codec_id != CODEC_ID_WMV2){
2553 add_dct(s, block[0], 0, dest_y, dct_linesize);
2554 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2555 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2556 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2558 if(!(s->flags&CODEC_FLAG_GRAY)){
2559 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2560 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2565 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2569 /* dct only in intra block */
2570 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2571 put_dct(s, block[0], 0, dest_y, dct_linesize);
2572 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2573 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2574 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2576 if(!(s->flags&CODEC_FLAG_GRAY)){
2577 put_dct(s, block[4], 4, dest_cb, uvlinesize);
2578 put_dct(s, block[5], 5, dest_cr, uvlinesize);
2581 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2582 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]);
2583 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2584 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2586 if(!(s->flags&CODEC_FLAG_GRAY)){
2587 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2588 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2595 #ifdef CONFIG_ENCODERS
2597 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2599 static const char tab[64]=
2611 DCTELEM *block= s->block[n];
2612 const int last_index= s->block_last_index[n];
2617 threshold= -threshold;
2621 /* are all which we could set to zero are allready zero? */
2622 if(last_index<=skip_dc - 1) return;
2624 for(i=0; i<=last_index; i++){
2625 const int j = s->intra_scantable.permutated[i];
2626 const int level = ABS(block[j]);
2628 if(skip_dc && i==0) continue;
2637 if(score >= threshold) return;
2638 for(i=skip_dc; i<=last_index; i++){
2639 const int j = s->intra_scantable.permutated[i];
2642 if(block[0]) s->block_last_index[n]= 0;
2643 else s->block_last_index[n]= -1;
2646 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2649 const int maxlevel= s->max_qcoeff;
2650 const int minlevel= s->min_qcoeff;
2653 i=1; //skip clipping of intra dc
2657 for(;i<=last_index; i++){
2658 const int j= s->intra_scantable.permutated[i];
2659 int level = block[j];
2661 if (level>maxlevel) level=maxlevel;
2662 else if(level<minlevel) level=minlevel;
2669 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2674 for(x=0; x<16; x+=4){
2675 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
2676 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2684 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2689 for(x=0; x<16; x++){
2690 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2699 #define SQ(a) ((a)*(a))
2701 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2706 for(x=0; x<16; x+=4){
2707 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
2708 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2716 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2721 for(x=0; x<16; x++){
2722 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2733 #endif //CONFIG_ENCODERS
2737 * @param h is the normal height, this will be reduced automatically if needed for the last row
2739 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2740 if (s->avctx->draw_horiz_band) {
2744 if(s->picture_structure != PICT_FRAME){
2747 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2750 h= FFMIN(h, s->height - y);
2752 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2753 src= (AVFrame*)s->current_picture_ptr;
2754 else if(s->last_picture_ptr)
2755 src= (AVFrame*)s->last_picture_ptr;
2759 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2765 offset[0]= y * s->linesize;;
2767 offset[2]= (y>>1) * s->uvlinesize;;
2773 s->avctx->draw_horiz_band(s->avctx, src, offset,
2774 y, s->picture_structure, h);
2778 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2779 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2780 const int uvlinesize= s->current_picture.linesize[1];
2782 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2783 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
2784 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2785 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
2786 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2787 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;
2789 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
2790 s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
2791 s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
2792 s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
2794 s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize ) + s->mb_x * 16 - 16;
2795 s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2796 s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2800 #ifdef CONFIG_ENCODERS
2802 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2804 const int mb_x= s->mb_x;
2805 const int mb_y= s->mb_y;
2808 int dct_offset = s->linesize*8; //default for progressive frames
2810 for(i=0; i<6; i++) skip_dct[i]=0;
2812 if(s->adaptive_quant){
2813 s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2815 if(s->out_format==FMT_H263){
2816 if (s->dquant> 2) s->dquant= 2;
2817 else if(s->dquant<-2) s->dquant=-2;
2820 if(s->codec_id==CODEC_ID_MPEG4){
2822 if(s->mv_dir&MV_DIRECT)
2825 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2828 s->qscale+= s->dquant;
2829 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2830 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2838 wrap_y = s->linesize;
2839 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2841 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2842 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2843 ptr= s->edge_emu_buffer;
2847 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2848 int progressive_score, interlaced_score;
2850 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2851 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
2853 if(progressive_score > interlaced_score + 100){
2854 s->interlaced_dct=1;
2859 s->interlaced_dct=0;
2862 s->dsp.get_pixels(s->block[0], ptr , wrap_y);
2863 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y);
2864 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y);
2865 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2867 if(s->flags&CODEC_FLAG_GRAY){
2871 int wrap_c = s->uvlinesize;
2872 ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2874 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);
2875 ptr= s->edge_emu_buffer;
2877 s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2879 ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2881 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);
2882 ptr= s->edge_emu_buffer;
2884 s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2887 op_pixels_func (*op_pix)[4];
2888 qpel_mc_func (*op_qpix)[16];
2889 uint8_t *dest_y, *dest_cb, *dest_cr;
2890 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2894 dest_y = s->dest[0];
2895 dest_cb = s->dest[1];
2896 dest_cr = s->dest[2];
2897 wrap_y = s->linesize;
2898 wrap_c = s->uvlinesize;
2899 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2900 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2901 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2903 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2904 op_pix = s->dsp.put_pixels_tab;
2905 op_qpix= s->dsp.put_qpel_pixels_tab;
2907 op_pix = s->dsp.put_no_rnd_pixels_tab;
2908 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2911 if (s->mv_dir & MV_DIR_FORWARD) {
2912 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2913 op_pix = s->dsp.avg_pixels_tab;
2914 op_qpix= s->dsp.avg_qpel_pixels_tab;
2916 if (s->mv_dir & MV_DIR_BACKWARD) {
2917 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2920 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2921 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2922 ptr_y= s->edge_emu_buffer;
2926 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2927 int progressive_score, interlaced_score;
2929 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
2930 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
2931 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
2932 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
2934 if(progressive_score > interlaced_score + 600){
2935 s->interlaced_dct=1;
2940 s->interlaced_dct=0;
2943 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
2944 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2945 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
2946 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2948 if(s->flags&CODEC_FLAG_GRAY){
2953 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);
2954 ptr_cb= s->edge_emu_buffer;
2956 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2958 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);
2959 ptr_cr= s->edge_emu_buffer;
2961 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2963 /* pre quantization */
2964 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2966 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2967 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2968 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2969 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2970 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2971 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2977 if(skip_dct[i]) num++;
2980 if(s->mb_x==0 && s->mb_y==0){
2982 printf("%6d %1d\n", stat[i], i);
2995 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2996 ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2998 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2999 (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P',
3000 s->qscale, adap_parm, s->qscale*adap_parm,
3001 s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
3004 /* DCT & quantize */
3005 if(s->out_format==FMT_MJPEG){
3008 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3009 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3015 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3016 // FIXME we could decide to change to quantizer instead of clipping
3017 // JS: I don't think that would be a good idea it could lower quality instead
3018 // of improve it. Just INTRADC clipping deserves changes in quantizer
3019 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3021 s->block_last_index[i]= -1;
3023 if(s->luma_elim_threshold && !s->mb_intra)
3025 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3026 if(s->chroma_elim_threshold && !s->mb_intra)
3028 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3031 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3032 s->block_last_index[4]=
3033 s->block_last_index[5]= 0;
3035 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3038 /* huffman encode */
3039 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3040 case CODEC_ID_MPEG1VIDEO:
3041 case CODEC_ID_MPEG2VIDEO:
3042 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3044 case CODEC_ID_MPEG4:
3045 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3046 case CODEC_ID_MSMPEG4V2:
3047 case CODEC_ID_MSMPEG4V3:
3049 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3051 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3053 case CODEC_ID_H263P:
3056 h263_encode_mb(s, s->block, motion_x, motion_y); break;
3058 case CODEC_ID_MJPEG:
3059 mjpeg_encode_mb(s, s->block); break;
3065 #endif //CONFIG_ENCODERS
3068 * combines the (truncated) bitstream to a complete frame
3069 * @returns -1 if no complete frame could be created
3071 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3072 ParseContext *pc= &s->parse_context;
3076 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3077 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3081 /* copy overreaded byes from last frame into buffer */
3082 for(; pc->overread>0; pc->overread--){
3083 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3086 pc->last_index= pc->index;
3088 /* copy into buffer end return */
3089 if(next == END_NOT_FOUND){
3090 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3092 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3093 pc->index += *buf_size;
3098 pc->overread_index= pc->index + next;
3100 /* append to buffer */
3102 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3104 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3109 /* store overread bytes */
3110 for(;next < 0; next++){
3111 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3117 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3118 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3125 void ff_mpeg_flush(AVCodecContext *avctx){
3127 MpegEncContext *s = avctx->priv_data;
3129 for(i=0; i<MAX_PICTURE_COUNT; i++){
3130 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3131 || s->picture[i].type == FF_BUFFER_TYPE_USER))
3132 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3134 s->last_picture_ptr = s->next_picture_ptr = NULL;
3136 s->parse_context.state= -1;
3137 s->parse_context.frame_start_found= 0;
3138 s->parse_context.overread= 0;
3139 s->parse_context.overread_index= 0;
3140 s->parse_context.index= 0;
3141 s->parse_context.last_index= 0;
3144 #ifdef CONFIG_ENCODERS
3145 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3147 int bytes= length>>4;
3148 int bits= length&15;
3151 if(length==0) return;
3153 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3154 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3157 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3160 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3163 d->mb_skip_run= s->mb_skip_run;
3165 d->last_dc[i]= s->last_dc[i];
3168 d->mv_bits= s->mv_bits;
3169 d->i_tex_bits= s->i_tex_bits;
3170 d->p_tex_bits= s->p_tex_bits;
3171 d->i_count= s->i_count;
3172 d->f_count= s->f_count;
3173 d->b_count= s->b_count;
3174 d->skip_count= s->skip_count;
3175 d->misc_bits= s->misc_bits;
3179 d->qscale= s->qscale;
3182 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3185 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
3186 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3189 d->mb_skip_run= s->mb_skip_run;
3191 d->last_dc[i]= s->last_dc[i];
3194 d->mv_bits= s->mv_bits;
3195 d->i_tex_bits= s->i_tex_bits;
3196 d->p_tex_bits= s->p_tex_bits;
3197 d->i_count= s->i_count;
3198 d->f_count= s->f_count;
3199 d->b_count= s->b_count;
3200 d->skip_count= s->skip_count;
3201 d->misc_bits= s->misc_bits;
3203 d->mb_intra= s->mb_intra;
3204 d->mb_skiped= s->mb_skiped;
3205 d->mv_type= s->mv_type;
3206 d->mv_dir= s->mv_dir;
3208 if(s->data_partitioning){
3210 d->tex_pb= s->tex_pb;
3214 d->block_last_index[i]= s->block_last_index[i];
3215 d->interlaced_dct= s->interlaced_dct;
3216 d->qscale= s->qscale;
3219 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
3220 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3221 int *dmin, int *next_block, int motion_x, int motion_y)
3224 uint8_t *dest_backup[3];
3226 copy_context_before_encode(s, backup, type);
3228 s->block= s->blocks[*next_block];
3229 s->pb= pb[*next_block];
3230 if(s->data_partitioning){
3231 s->pb2 = pb2 [*next_block];
3232 s->tex_pb= tex_pb[*next_block];
3236 memcpy(dest_backup, s->dest, sizeof(s->dest));
3237 s->dest[0] = s->me.scratchpad;
3238 s->dest[1] = s->me.scratchpad + 16;
3239 s->dest[2] = s->me.scratchpad + 16 + 8;
3240 assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3241 assert(s->linesize >= 64); //FIXME
3244 encode_mb(s, motion_x, motion_y);
3246 score= get_bit_count(&s->pb);
3247 if(s->data_partitioning){
3248 score+= get_bit_count(&s->pb2);
3249 score+= get_bit_count(&s->tex_pb);
3252 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3253 MPV_decode_mb(s, s->block);
3255 score *= s->qscale * s->qscale * 109;
3256 score += sse_mb(s) << 7;
3260 memcpy(s->dest, dest_backup, sizeof(s->dest));
3267 copy_context_after_encode(best, s, type);
3271 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3272 uint32_t *sq = squareTbl + 256;
3277 return s->dsp.sse[0](NULL, src1, src2, stride);
3278 else if(w==8 && h==8)
3279 return s->dsp.sse[1](NULL, src1, src2, stride);
3283 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3292 static int sse_mb(MpegEncContext *s){
3296 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3297 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3300 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)
3301 +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)
3302 +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);
3304 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)
3305 +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)
3306 +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);
3309 static void encode_picture(MpegEncContext *s, int picture_number)
3311 int mb_x, mb_y, pdif = 0;
3314 MpegEncContext best_s, backup_s;
3315 uint8_t bit_buf[2][3000];
3316 uint8_t bit_buf2[2][3000];
3317 uint8_t bit_buf_tex[2][3000];
3318 PutBitContext pb[2], pb2[2], tex_pb[2];
3321 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
3322 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
3323 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3326 s->picture_number = picture_number;
3328 /* Reset the average MB variance */
3329 s->current_picture.mb_var_sum = 0;
3330 s->current_picture.mc_mb_var_sum = 0;
3333 /* we need to initialize some time vars before we can encode b-frames */
3334 // RAL: Condition added for MPEG1VIDEO
3335 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3336 ff_set_mpeg4_time(s, s->picture_number);
3339 s->scene_change_score=0;
3341 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3343 if(s->pict_type==I_TYPE){
3344 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3345 else s->no_rounding=0;
3346 }else if(s->pict_type!=B_TYPE){
3347 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3348 s->no_rounding ^= 1;
3351 /* Estimate motion for every MB */
3352 s->mb_intra=0; //for the rate distoration & bit compare functions
3353 if(s->pict_type != I_TYPE){
3354 if(s->pict_type != B_TYPE){
3355 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3357 s->me.dia_size= s->avctx->pre_dia_size;
3359 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3360 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3363 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3370 s->me.dia_size= s->avctx->dia_size;
3371 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3372 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3373 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3374 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3375 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3376 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3379 s->block_index[0]+=2;
3380 s->block_index[1]+=2;
3381 s->block_index[2]+=2;
3382 s->block_index[3]+=2;
3384 /* compute motion vector & mb_type and store in context */
3385 if(s->pict_type==B_TYPE)
3386 ff_estimate_b_frame_motion(s, mb_x, mb_y);
3388 ff_estimate_p_frame_motion(s, mb_x, mb_y);
3391 }else /* if(s->pict_type == I_TYPE) */{
3393 //FIXME do we need to zero them?
3394 memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3395 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3396 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3398 if(!s->fixed_qscale){
3399 /* finding spatial complexity for I-frame rate control */
3400 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3401 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3404 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3406 int sum = s->dsp.pix_sum(pix, s->linesize);
3408 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3410 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3411 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3412 s->current_picture.mb_var_sum += varc;
3419 if(s->scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
3420 s->pict_type= I_TYPE;
3421 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3422 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3426 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3427 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3429 ff_fix_long_p_mvs(s);
3432 if(s->pict_type==B_TYPE){
3435 a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3436 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3437 s->f_code = FFMAX(a, b);
3439 a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3440 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3441 s->b_code = FFMAX(a, b);
3443 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3444 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3445 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3446 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3450 if (s->fixed_qscale)
3451 s->frame_qscale = s->current_picture.quality;
3453 s->frame_qscale = ff_rate_estimate_qscale(s);
3455 if(s->adaptive_quant){
3457 switch(s->codec_id){
3458 case CODEC_ID_MPEG4:
3459 ff_clean_mpeg4_qscales(s);
3462 case CODEC_ID_H263P:
3464 ff_clean_h263_qscales(s);
3469 s->qscale= s->current_picture.qscale_table[0];
3471 s->qscale= (int)(s->frame_qscale + 0.5);
3473 if (s->out_format == FMT_MJPEG) {
3474 /* for mjpeg, we do include qscale in the matrix */
3475 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3477 int j= s->dsp.idct_permutation[i];
3479 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3481 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3482 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3485 //FIXME var duplication
3486 s->current_picture.key_frame= s->pict_type == I_TYPE;
3487 s->current_picture.pict_type= s->pict_type;
3489 if(s->current_picture.key_frame)
3490 s->picture_in_gop_number=0;
3492 s->last_bits= get_bit_count(&s->pb);
3493 switch(s->out_format) {
3495 mjpeg_picture_header(s);
3499 if (s->codec_id == CODEC_ID_WMV2)
3500 ff_wmv2_encode_picture_header(s, picture_number);
3501 else if (s->h263_msmpeg4)
3502 msmpeg4_encode_picture_header(s, picture_number);
3503 else if (s->h263_pred)
3504 mpeg4_encode_picture_header(s, picture_number);
3505 else if (s->h263_rv10)
3506 rv10_encode_picture_header(s, picture_number);
3507 else if (s->codec_id == CODEC_ID_FLV1)
3508 ff_flv_encode_picture_header(s, picture_number);
3510 h263_encode_picture_header(s, picture_number);
3514 mpeg1_encode_picture_header(s, picture_number);
3519 bits= get_bit_count(&s->pb);
3520 s->header_bits= bits - s->last_bits;
3532 /* init last dc values */
3533 /* note: quant matrix value (8) is implied here */
3534 s->last_dc[i] = 128;
3536 s->current_picture_ptr->error[i] = 0;
3539 s->last_mv[0][0][0] = 0;
3540 s->last_mv[0][0][1] = 0;
3541 s->last_mv[1][0][0] = 0;
3542 s->last_mv[1][0][1] = 0;
3547 switch(s->codec_id){
3549 case CODEC_ID_H263P:
3551 s->gob_index = ff_h263_get_gob_height(s);
3553 case CODEC_ID_MPEG4:
3554 if(s->partitioned_frame)
3555 ff_mpeg4_init_partitions(s);
3562 s->first_slice_line = 1;
3563 s->ptr_lastgob = s->pb.buf;
3564 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3568 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3569 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3570 ff_init_block_index(s);
3572 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3573 const int xy= mb_y*s->mb_stride + mb_x;
3574 int mb_type= s->mb_type[xy];
3579 ff_update_block_index(s);
3581 /* write gob / video packet header */
3583 if(s->rtp_mode && mb_y + mb_x>0){
3584 int current_packet_size, is_gob_start;
3586 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3589 if(s->codec_id==CODEC_ID_MPEG4){
3590 if(current_packet_size >= s->rtp_payload_size){
3592 if(s->partitioned_frame){
3593 ff_mpeg4_merge_partitions(s);
3594 ff_mpeg4_init_partitions(s);
3596 ff_mpeg4_encode_video_packet_header(s);
3598 if(s->flags&CODEC_FLAG_PASS1){
3599 int bits= get_bit_count(&s->pb);
3600 s->misc_bits+= bits - s->last_bits;
3603 ff_mpeg4_clean_buffers(s);
3606 }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3607 if( current_packet_size >= s->rtp_payload_size
3608 && s->mb_skip_run==0){
3609 ff_mpeg1_encode_slice_header(s);
3610 ff_mpeg1_clean_buffers(s);
3613 }else if(s->codec_id==CODEC_ID_MPEG2VIDEO){
3614 if( ( current_packet_size >= s->rtp_payload_size || mb_x==0)
3615 && s->mb_skip_run==0){
3616 ff_mpeg1_encode_slice_header(s);
3617 ff_mpeg1_clean_buffers(s);
3621 if(current_packet_size >= s->rtp_payload_size
3622 && s->mb_x==0 && s->mb_y%s->gob_index==0){
3624 h263_encode_gob_header(s, mb_y);
3630 s->ptr_lastgob = pbBufPtr(&s->pb);
3631 s->first_slice_line=1;
3632 s->resync_mb_x=mb_x;
3633 s->resync_mb_y=mb_y;
3638 if( (s->resync_mb_x == s->mb_x)
3639 && s->resync_mb_y+1 == s->mb_y){
3640 s->first_slice_line=0;
3645 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3647 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3649 copy_context_before_encode(&backup_s, s, -1);
3651 best_s.data_partitioning= s->data_partitioning;
3652 best_s.partitioned_frame= s->partitioned_frame;
3653 if(s->data_partitioning){
3654 backup_s.pb2= s->pb2;
3655 backup_s.tex_pb= s->tex_pb;
3658 if(mb_type&MB_TYPE_INTER){
3659 s->mv_dir = MV_DIR_FORWARD;
3660 s->mv_type = MV_TYPE_16X16;
3662 s->mv[0][0][0] = s->p_mv_table[xy][0];
3663 s->mv[0][0][1] = s->p_mv_table[xy][1];
3664 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
3665 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3667 if(mb_type&MB_TYPE_INTER4V){
3668 s->mv_dir = MV_DIR_FORWARD;
3669 s->mv_type = MV_TYPE_8X8;
3672 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3673 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3675 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
3676 &dmin, &next_block, 0, 0);
3678 if(mb_type&MB_TYPE_FORWARD){
3679 s->mv_dir = MV_DIR_FORWARD;
3680 s->mv_type = MV_TYPE_16X16;
3682 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3683 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3684 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
3685 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3687 if(mb_type&MB_TYPE_BACKWARD){
3688 s->mv_dir = MV_DIR_BACKWARD;
3689 s->mv_type = MV_TYPE_16X16;
3691 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3692 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3693 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3694 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3696 if(mb_type&MB_TYPE_BIDIR){
3697 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3698 s->mv_type = MV_TYPE_16X16;
3700 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3701 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3702 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3703 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3704 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
3705 &dmin, &next_block, 0, 0);
3707 if(mb_type&MB_TYPE_DIRECT){
3708 int mx= s->b_direct_mv_table[xy][0];
3709 int my= s->b_direct_mv_table[xy][1];
3711 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3714 ff_mpeg4_set_direct_mv(s, mx, my);
3716 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
3717 &dmin, &next_block, mx, my);
3719 if(mb_type&MB_TYPE_INTRA){
3721 s->mv_type = MV_TYPE_16X16;
3725 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3726 &dmin, &next_block, 0, 0);
3727 if(s->h263_pred || s->h263_aic){
3729 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3731 ff_clean_intra_table_entries(s); //old mode?
3734 copy_context_after_encode(s, &best_s, -1);
3736 pb_bits_count= get_bit_count(&s->pb);
3737 flush_put_bits(&s->pb);
3738 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3741 if(s->data_partitioning){
3742 pb2_bits_count= get_bit_count(&s->pb2);
3743 flush_put_bits(&s->pb2);
3744 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3745 s->pb2= backup_s.pb2;
3747 tex_pb_bits_count= get_bit_count(&s->tex_pb);
3748 flush_put_bits(&s->tex_pb);
3749 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3750 s->tex_pb= backup_s.tex_pb;
3752 s->last_bits= get_bit_count(&s->pb);
3755 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3756 ff_h263_update_motion_val(s);
3760 s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad , s->linesize ,16);
3761 s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
3762 s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
3765 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3766 MPV_decode_mb(s, s->block);
3768 int motion_x, motion_y;
3770 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3772 if(s->avctx->mb_decision==FF_MB_DECISION_SIMPLE && s->pict_type==P_TYPE){ //FIXME check if the mess is usefull at all
3773 /* get luma score */
3774 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3775 intra_score= (s->current_picture.mb_var[mb_x + mb_y*s->mb_stride]<<8) - 500; //FIXME dont scale it down so we dont have to fix it
3779 int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3782 dest_y = s->new_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
3784 for(i=0; i<16; i++){
3785 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3786 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3787 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3788 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3792 intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3794 /* printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
3795 s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3796 s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3799 /* get chroma score */
3800 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3808 if(s->out_format == FMT_H263){
3809 mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3811 mean= (s->last_dc[i] + 4)>>3;
3813 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3817 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3818 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3821 intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3826 switch(s->avctx->mb_cmp&0xFF){
3829 intra_score+= 32*s->qscale;
3832 intra_score+= 24*s->qscale*s->qscale;
3835 intra_score+= 96*s->qscale;
3838 intra_score+= 48*s->qscale;
3845 intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3849 if(intra_score < inter_score)
3850 mb_type= MB_TYPE_INTRA;
3853 s->mv_type=MV_TYPE_16X16;
3854 // only one MB-Type possible
3860 motion_x= s->mv[0][0][0] = 0;
3861 motion_y= s->mv[0][0][1] = 0;
3864 s->mv_dir = MV_DIR_FORWARD;
3866 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3867 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3869 case MB_TYPE_INTER4V:
3870 s->mv_dir = MV_DIR_FORWARD;
3871 s->mv_type = MV_TYPE_8X8;
3874 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3875 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3877 motion_x= motion_y= 0;
3879 case MB_TYPE_DIRECT:
3880 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3882 motion_x=s->b_direct_mv_table[xy][0];
3883 motion_y=s->b_direct_mv_table[xy][1];
3885 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3889 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3893 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3894 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3895 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3896 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3898 case MB_TYPE_BACKWARD:
3899 s->mv_dir = MV_DIR_BACKWARD;
3901 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3902 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3904 case MB_TYPE_FORWARD:
3905 s->mv_dir = MV_DIR_FORWARD;
3907 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3908 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3909 // printf(" %d %d ", motion_x, motion_y);
3912 motion_x=motion_y=0; //gcc warning fix
3913 printf("illegal MB type\n");
3916 encode_mb(s, motion_x, motion_y);
3918 // RAL: Update last macrobloc type
3919 s->last_mv_dir = s->mv_dir;
3922 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3923 ff_h263_update_motion_val(s);
3926 MPV_decode_mb(s, s->block);
3929 /* clean the MV table in IPS frames for direct mode in B frames */
3930 if(s->mb_intra /* && I,P,S_TYPE */){
3931 s->p_mv_table[xy][0]=0;
3932 s->p_mv_table[xy][1]=0;
3935 if(s->flags&CODEC_FLAG_PSNR){
3939 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3940 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3942 s->current_picture_ptr->error[0] += sse(
3943 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3944 s->dest[0], w, h, s->linesize);
3945 s->current_picture_ptr->error[1] += sse(
3946 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3947 s->dest[1], w>>1, h>>1, s->uvlinesize);
3948 s->current_picture_ptr->error[2] += sse(
3949 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3950 s->dest[2], w>>1, h>>1, s->uvlinesize);
3952 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3958 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3959 ff_mpeg4_merge_partitions(s);
3961 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3962 msmpeg4_encode_ext_header(s);
3964 if(s->codec_id==CODEC_ID_MPEG4)
3965 ff_mpeg4_stuffing(&s->pb);
3968 //if (s->gob_number)
3969 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3971 /* Send the last GOB if RTP */
3973 flush_put_bits(&s->pb);
3974 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3975 /* Call the RTP callback to send the last GOB */
3976 if (s->rtp_callback)
3977 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3978 s->ptr_lastgob = pbBufPtr(&s->pb);
3979 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3983 static int dct_quantize_trellis_c(MpegEncContext *s,
3984 DCTELEM *block, int n,
3985 int qscale, int *overflow){
3987 const uint8_t *scantable= s->intra_scantable.scantable;
3989 unsigned int threshold1, threshold2;
3999 int coeff_count[64];
4000 int lambda, qmul, qadd, start_i, last_non_zero, i, dc;
4001 const int esc_length= s->ac_esc_length;
4003 uint8_t * last_length;
4007 s->dsp.fdct (block);
4010 qadd= ((qscale-1)|1)*8;
4021 /* For AIC we skip quant/dequant of INTRADC */
4026 /* note: block[0] is assumed to be positive */
4027 block[0] = (block[0] + (q >> 1)) / q;
4030 qmat = s->q_intra_matrix[qscale];
4031 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4032 bias= 1<<(QMAT_SHIFT-1);
4033 length = s->intra_ac_vlc_length;
4034 last_length= s->intra_ac_vlc_last_length;
4038 qmat = s->q_inter_matrix[qscale];
4039 length = s->inter_ac_vlc_length;
4040 last_length= s->inter_ac_vlc_last_length;
4043 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4044 threshold2= (threshold1<<1);
4046 for(i=start_i; i<64; i++) {
4047 const int j = scantable[i];
4048 const int k= i-start_i;
4049 int level = block[j];
4050 level = level * qmat[j];
4052 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4053 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4054 if(((unsigned)(level+threshold1))>threshold2){
4056 level= (bias + level)>>QMAT_SHIFT;
4058 coeff[1][k]= level-1;
4059 // coeff[2][k]= level-2;
4061 level= (bias - level)>>QMAT_SHIFT;
4062 coeff[0][k]= -level;
4063 coeff[1][k]= -level+1;
4064 // coeff[2][k]= -level+2;
4066 coeff_count[k]= FFMIN(level, 2);
4070 coeff[0][k]= (level>>31)|1;
4075 *overflow= s->max_qcoeff < max; //overflow might have happend
4077 if(last_non_zero < start_i){
4078 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4079 return last_non_zero;
4082 lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
4085 for(i=0; i<=last_non_zero - start_i; i++){
4086 int level_index, run, j;
4087 const int dct_coeff= block[ scantable[i + start_i] ];
4088 const int zero_distoration= dct_coeff*dct_coeff;
4089 int best_score=256*256*256*120;
4091 last_score += zero_distoration;
4092 for(level_index=0; level_index < coeff_count[i]; level_index++){
4094 int level= coeff[level_index][i];
4099 if(s->out_format == FMT_H263){
4101 unquant_coeff= level*qmul + qadd;
4103 unquant_coeff= level*qmul - qadd;
4106 j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
4109 unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
4110 unquant_coeff = -((unquant_coeff - 1) | 1);
4112 unquant_coeff = (int)( level * qscale * s->intra_matrix[j]) >> 3;
4113 unquant_coeff = (unquant_coeff - 1) | 1;
4117 unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4118 unquant_coeff = -((unquant_coeff - 1) | 1);
4120 unquant_coeff = ((( level << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
4121 unquant_coeff = (unquant_coeff - 1) | 1;
4127 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4129 if((level&(~127)) == 0){
4130 for(run=0; run<=i - left_limit; run++){
4131 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4132 score += score_tab[i-run];
4134 if(score < best_score){
4136 score_tab[i+1]= score;
4138 level_tab[i+1]= level-64;
4142 if(s->out_format == FMT_H263){
4143 for(run=0; run<=i - left_limit; run++){
4144 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4145 score += score_tab[i-run];
4146 if(score < last_score){
4149 last_level= level-64;
4155 distoration += esc_length*lambda;
4156 for(run=0; run<=i - left_limit; run++){
4157 int score= distoration + score_tab[i-run];
4159 if(score < best_score){
4161 score_tab[i+1]= score;
4163 level_tab[i+1]= level-64;
4167 if(s->out_format == FMT_H263){
4168 for(run=0; run<=i - left_limit; run++){
4169 int score= distoration + score_tab[i-run];
4170 if(score < last_score){
4173 last_level= level-64;
4181 for(j=left_limit; j<=i; j++){
4182 score_tab[j] += zero_distoration;
4184 score_limit+= zero_distoration;
4185 if(score_tab[i+1] < score_limit)
4186 score_limit= score_tab[i+1];
4188 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4189 while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4192 //FIXME add some cbp penalty
4194 if(s->out_format != FMT_H263){
4195 last_score= 256*256*256*120;
4196 for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
4197 int score= score_tab[i];
4198 if(i) score += lambda*2; //FIXME exacter?
4200 if(score < last_score){
4203 last_level= level_tab[i];
4204 last_run= run_tab[i];
4210 last_non_zero= last_i - 1 + start_i;
4211 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4213 if(last_non_zero < start_i)
4214 return last_non_zero;
4216 if(last_non_zero == 0 && start_i == 0){
4218 int best_score= dc * dc;
4220 for(i=0; i<coeff_count[0]; i++){
4221 const int level= coeff[i][0];
4222 int unquant_coeff, score, distoration;
4224 if(s->out_format == FMT_H263){
4226 unquant_coeff= (level*qmul + qadd)>>3;
4228 unquant_coeff= (level*qmul - qadd)>>3;
4232 unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
4233 unquant_coeff = -((unquant_coeff - 1) | 1);
4235 unquant_coeff = ((( level << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
4236 unquant_coeff = (unquant_coeff - 1) | 1;
4239 unquant_coeff = (unquant_coeff + 4) >> 3;
4240 unquant_coeff<<= 3 + 3;
4242 distoration= (unquant_coeff - dc) * (unquant_coeff - dc);
4243 score= distoration + last_length[UNI_AC_ENC_INDEX(0, level+64)]*lambda;
4244 if(score < best_score){
4249 block[0]= best_level;
4252 return last_non_zero;
4257 //FIXME use permutated scantable
4258 block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
4261 for(;i>0 ; i -= run_tab[i] + 1){
4262 const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
4264 block[j]= level_tab[i];
4268 return last_non_zero;
4271 static int dct_quantize_c(MpegEncContext *s,
4272 DCTELEM *block, int n,
4273 int qscale, int *overflow)
4275 int i, j, level, last_non_zero, q;
4277 const uint8_t *scantable= s->intra_scantable.scantable;
4280 unsigned int threshold1, threshold2;
4282 s->dsp.fdct (block);
4292 /* For AIC we skip quant/dequant of INTRADC */
4295 /* note: block[0] is assumed to be positive */
4296 block[0] = (block[0] + (q >> 1)) / q;
4299 qmat = s->q_intra_matrix[qscale];
4300 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4304 qmat = s->q_inter_matrix[qscale];
4305 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4307 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4308 threshold2= (threshold1<<1);
4313 level = level * qmat[j];
4315 // if( bias+level >= (1<<QMAT_SHIFT)
4316 // || bias-level >= (1<<QMAT_SHIFT)){
4317 if(((unsigned)(level+threshold1))>threshold2){
4319 level= (bias + level)>>QMAT_SHIFT;
4322 level= (bias - level)>>QMAT_SHIFT;
4331 *overflow= s->max_qcoeff < max; //overflow might have happend
4333 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4334 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4335 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4337 return last_non_zero;
4340 #endif //CONFIG_ENCODERS
4342 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
4343 DCTELEM *block, int n, int qscale)
4345 int i, level, nCoeffs;
4346 const uint16_t *quant_matrix;
4348 nCoeffs= s->block_last_index[n];
4352 block[0] = block[0] * s->y_dc_scale;
4354 block[0] = block[0] * s->c_dc_scale;
4355 /* XXX: only mpeg1 */
4356 quant_matrix = s->intra_matrix;
4357 for(i=1;i<=nCoeffs;i++) {
4358 int j= s->intra_scantable.permutated[i];
4363 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4364 level = (level - 1) | 1;
4367 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4368 level = (level - 1) | 1;
4371 if (level < -2048 || level > 2047)
4372 fprintf(stderr, "unquant error %d %d\n", i, level);
4379 quant_matrix = s->inter_matrix;
4380 for(;i<=nCoeffs;i++) {
4381 int j= s->intra_scantable.permutated[i];
4386 level = (((level << 1) + 1) * qscale *
4387 ((int) (quant_matrix[j]))) >> 4;
4388 level = (level - 1) | 1;
4391 level = (((level << 1) + 1) * qscale *
4392 ((int) (quant_matrix[j]))) >> 4;
4393 level = (level - 1) | 1;
4396 if (level < -2048 || level > 2047)
4397 fprintf(stderr, "unquant error %d %d\n", i, level);
4405 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
4406 DCTELEM *block, int n, int qscale)
4408 int i, level, nCoeffs;
4409 const uint16_t *quant_matrix;
4411 if(s->alternate_scan) nCoeffs= 63;
4412 else nCoeffs= s->block_last_index[n];
4416 block[0] = block[0] * s->y_dc_scale;
4418 block[0] = block[0] * s->c_dc_scale;
4419 quant_matrix = s->intra_matrix;
4420 for(i=1;i<=nCoeffs;i++) {
4421 int j= s->intra_scantable.permutated[i];
4426 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4429 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4432 if (level < -2048 || level > 2047)
4433 fprintf(stderr, "unquant error %d %d\n", i, level);
4441 quant_matrix = s->inter_matrix;
4442 for(;i<=nCoeffs;i++) {
4443 int j= s->intra_scantable.permutated[i];
4448 level = (((level << 1) + 1) * qscale *
4449 ((int) (quant_matrix[j]))) >> 4;
4452 level = (((level << 1) + 1) * qscale *
4453 ((int) (quant_matrix[j]))) >> 4;
4456 if (level < -2048 || level > 2047)
4457 fprintf(stderr, "unquant error %d %d\n", i, level);
4468 static void dct_unquantize_h263_c(MpegEncContext *s,
4469 DCTELEM *block, int n, int qscale)
4471 int i, level, qmul, qadd;
4474 assert(s->block_last_index[n]>=0);
4476 qadd = (qscale - 1) | 1;
4482 block[0] = block[0] * s->y_dc_scale;
4484 block[0] = block[0] * s->c_dc_scale;
4488 nCoeffs= 63; //does not allways use zigzag table
4491 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4494 for(;i<=nCoeffs;i++) {
4498 level = level * qmul - qadd;
4500 level = level * qmul + qadd;
4503 if (level < -2048 || level > 2047)
4504 fprintf(stderr, "unquant error %d %d\n", i, level);
4512 static const AVOption mpeg4_options[] =
4514 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4515 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4516 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4517 bit_rate_tolerance, 4, 240000000, 8000),
4518 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4519 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4520 AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4521 rc_eq, "tex^qComp,option1,options2", 0),
4522 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4523 rc_min_rate, 4, 24000000, 0),
4524 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4525 rc_max_rate, 4, 24000000, 0),
4526 AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4527 rc_buffer_aggressivity, 4, 24000000, 0),
4528 AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4529 rc_initial_cplx, 0., 9999999., 0),
4530 AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4531 i_quant_factor, 0., 0., 0),
4532 AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4533 i_quant_factor, -999999., 999999., 0),
4534 AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4535 dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4536 AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4537 lumi_masking, 0., 999999., 0),
4538 AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4539 temporal_cplx_masking, 0., 999999., 0),
4540 AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4541 spatial_cplx_masking, 0., 999999., 0),
4542 AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4543 p_masking, 0., 999999., 0),
4544 AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4545 dark_masking, 0., 999999., 0),
4546 AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4547 idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4549 AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4551 AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4554 AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4555 me_cmp, 0, 24000000, 0),
4556 AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4557 me_sub_cmp, 0, 24000000, 0),
4560 AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4561 dia_size, 0, 24000000, 0),
4562 AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4563 last_predictor_count, 0, 24000000, 0),
4565 AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4566 pre_me, 0, 24000000, 0),
4567 AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4568 me_pre_cmp, 0, 24000000, 0),
4570 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4571 me_range, 0, 24000000, 0),
4572 AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4573 pre_dia_size, 0, 24000000, 0),
4574 AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4575 me_subpel_quality, 0, 24000000, 0),
4576 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4577 me_range, 0, 24000000, 0),
4578 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4579 flags, CODEC_FLAG_PSNR, 0),
4580 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4582 AVOPTION_SUB(avoptions_common),
4586 #ifdef CONFIG_ENCODERS
4588 AVCodec mpeg1video_encoder = {
4591 CODEC_ID_MPEG1VIDEO,
4592 sizeof(MpegEncContext),
4600 AVCodec mpeg2video_encoder = {
4603 CODEC_ID_MPEG2VIDEO,
4604 sizeof(MpegEncContext),
4610 AVCodec h263_encoder = {
4614 sizeof(MpegEncContext),
4620 AVCodec h263p_encoder = {
4624 sizeof(MpegEncContext),
4630 AVCodec flv_encoder = {
4634 sizeof(MpegEncContext),
4640 AVCodec rv10_encoder = {
4644 sizeof(MpegEncContext),
4650 AVCodec mpeg4_encoder = {
4654 sizeof(MpegEncContext),
4658 .options = mpeg4_options,
4661 AVCodec msmpeg4v1_encoder = {
4665 sizeof(MpegEncContext),
4669 .options = mpeg4_options,
4672 AVCodec msmpeg4v2_encoder = {
4676 sizeof(MpegEncContext),
4680 .options = mpeg4_options,
4683 AVCodec msmpeg4v3_encoder = {
4687 sizeof(MpegEncContext),
4691 .options = mpeg4_options,
4694 AVCodec wmv1_encoder = {
4698 sizeof(MpegEncContext),
4702 .options = mpeg4_options,
4707 AVCodec mjpeg_encoder = {
4711 sizeof(MpegEncContext),
4717 #endif //CONFIG_ENCODERS