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!).
31 #include "mpegvideo.h"
34 #include "fastmemcpy.h"
40 #ifdef CONFIG_ENCODERS
41 static void encode_picture(MpegEncContext *s, int picture_number);
42 #endif //CONFIG_ENCODERS
43 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
44 DCTELEM *block, int n, int qscale);
45 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
46 DCTELEM *block, int n, int qscale);
47 static void dct_unquantize_h263_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
50 #ifdef CONFIG_ENCODERS
51 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
52 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
53 static int sse_mb(MpegEncContext *s);
54 #endif //CONFIG_ENCODERS
57 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58 extern void XVMC_field_end(MpegEncContext *s);
59 extern void XVMC_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
62 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
65 /* enable all paranoid tests for rounding, overflows, etc... */
71 /* for jpeg fast DCT */
74 static const uint16_t aanscales[64] = {
75 /* precomputed values scaled up by 14 bits */
76 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
77 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
78 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
79 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
80 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
81 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
82 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
83 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
86 static const uint8_t h263_chroma_roundtab[16] = {
87 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
88 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
91 #ifdef CONFIG_ENCODERS
92 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
93 static uint8_t default_fcode_tab[MAX_MV*2+1];
95 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
97 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
98 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
102 for(qscale=qmin; qscale<=qmax; qscale++){
104 if (s->dsp.fdct == ff_jpeg_fdct_islow) {
106 const int j= s->dsp.idct_permutation[i];
107 /* 16 <= qscale * quant_matrix[i] <= 7905 */
108 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
109 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
110 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
112 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
113 (qscale * quant_matrix[j]));
115 } else if (s->dsp.fdct == fdct_ifast) {
117 const int j= s->dsp.idct_permutation[i];
118 /* 16 <= qscale * quant_matrix[i] <= 7905 */
119 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
120 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
121 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
123 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
124 (aanscales[i] * qscale * quant_matrix[j]));
128 const int j= s->dsp.idct_permutation[i];
129 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
130 So 16 <= qscale * quant_matrix[i] <= 7905
131 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
132 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
134 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
135 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
136 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
138 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
139 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
144 #endif //CONFIG_ENCODERS
146 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
150 st->scantable= src_scantable;
154 j = src_scantable[i];
155 st->permutated[i] = permutation[j];
164 j = st->permutated[i];
166 st->raster_end[i]= end;
170 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
176 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
182 /* init common dct for both encoder and decoder */
183 int DCT_common_init(MpegEncContext *s)
185 s->dct_unquantize_h263 = dct_unquantize_h263_c;
186 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
187 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
189 #ifdef CONFIG_ENCODERS
190 s->dct_quantize= dct_quantize_c;
194 MPV_common_init_mmx(s);
197 MPV_common_init_axp(s);
200 MPV_common_init_mlib(s);
203 MPV_common_init_mmi(s);
206 MPV_common_init_armv4l(s);
209 MPV_common_init_ppc(s);
212 #ifdef CONFIG_ENCODERS
213 s->fast_dct_quantize= s->dct_quantize;
215 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
216 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
219 #endif //CONFIG_ENCODERS
221 /* load & permutate scantables
222 note: only wmv uses differnt ones
224 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
225 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
226 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
227 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
229 s->picture_structure= PICT_FRAME;
235 * allocates a Picture
236 * The pixels are allocated/set by calling get_buffer() if shared=0
238 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
239 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
240 const int mb_array_size= s->mb_stride*s->mb_height;
244 assert(pic->data[0]);
245 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
246 pic->type= FF_BUFFER_TYPE_SHARED;
250 assert(!pic->data[0]);
252 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
254 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
255 fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
259 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
260 fprintf(stderr, "get_buffer() failed (stride changed)\n");
264 if(pic->linesize[1] != pic->linesize[2]){
265 fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
269 s->linesize = pic->linesize[0];
270 s->uvlinesize= pic->linesize[1];
273 if(pic->qscale_table==NULL){
275 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
276 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
277 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
278 CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
281 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
282 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
283 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(int))
284 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
285 if(s->out_format == FMT_H264){
287 CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
288 CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
291 pic->qstride= s->mb_stride;
294 //it might be nicer if the application would keep track of these but it would require a API change
295 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
296 s->prev_pict_types[0]= s->pict_type;
297 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
298 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
301 fail: //for the CHECKED_ALLOCZ macro
306 * deallocates a picture
308 static void free_picture(MpegEncContext *s, Picture *pic){
311 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
312 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
315 av_freep(&pic->mb_var);
316 av_freep(&pic->mc_mb_var);
317 av_freep(&pic->mb_mean);
318 av_freep(&pic->mb_cmp_score);
319 av_freep(&pic->mbskip_table);
320 av_freep(&pic->qscale_table);
321 av_freep(&pic->mb_type_base);
324 av_freep(&pic->motion_val[i]);
325 av_freep(&pic->ref_index[i]);
328 if(pic->type == FF_BUFFER_TYPE_SHARED){
337 /* init common structure for both encoder and decoder */
338 int MPV_common_init(MpegEncContext *s)
340 int y_size, c_size, yc_size, i, mb_array_size, x, y;
342 dsputil_init(&s->dsp, s->avctx);
345 s->flags= s->avctx->flags;
347 s->mb_width = (s->width + 15) / 16;
348 s->mb_height = (s->height + 15) / 16;
349 s->mb_stride = s->mb_width + 1;
350 mb_array_size= s->mb_height * s->mb_stride;
352 /* set default edge pos, will be overriden in decode_header if needed */
353 s->h_edge_pos= s->mb_width*16;
354 s->v_edge_pos= s->mb_height*16;
356 s->mb_num = s->mb_width * s->mb_height;
361 s->block_wrap[3]= s->mb_width*2 + 2;
363 s->block_wrap[5]= s->mb_width + 2;
365 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
366 c_size = (s->mb_width + 2) * (s->mb_height + 2);
367 yc_size = y_size + 2 * c_size;
369 /* convert fourcc to upper case */
370 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
371 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
372 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
373 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
375 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
376 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
378 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
380 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
381 for(y=0; y<s->mb_height; y++){
382 for(x=0; x<s->mb_width; x++){
383 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
386 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
389 int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
391 /* Allocate MV tables */
392 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
393 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
394 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
395 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
396 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
397 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
398 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
399 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
400 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
401 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
402 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
403 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
405 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
406 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t))
408 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
409 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
411 if(s->codec_id==CODEC_ID_MPEG4){
412 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
413 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
416 if(s->msmpeg4_version){
417 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
419 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
421 /* Allocate MB type table */
422 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint8_t)) //needed for encoding
425 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
427 if (s->out_format == FMT_H263 || s->encoding) {
431 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
432 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
435 if(s->codec_id==CODEC_ID_MPEG4){
436 /* interlaced direct mode decoding tables */
437 CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
438 CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
440 if (s->out_format == FMT_H263) {
442 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
443 s->ac_val[1] = s->ac_val[0] + y_size;
444 s->ac_val[2] = s->ac_val[1] + c_size;
447 CHECKED_ALLOCZ(s->coded_block, y_size);
449 /* divx501 bitstream reorder buffer */
450 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
452 /* cbp, ac_pred, pred_dir */
453 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
454 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
457 if (s->h263_pred || s->h263_plus || !s->encoding) {
459 //MN: we need these for error resilience of intra-frames
460 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
461 s->dc_val[1] = s->dc_val[0] + y_size;
462 s->dc_val[2] = s->dc_val[1] + c_size;
463 for(i=0;i<yc_size;i++)
464 s->dc_val[0][i] = 1024;
467 /* which mb is a intra block */
468 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
469 memset(s->mbintra_table, 1, mb_array_size);
471 /* default structure is frame */
472 s->picture_structure = PICT_FRAME;
474 /* init macroblock skip table */
475 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
476 //Note the +1 is for a quicker mpeg4 slice_end detection
477 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
479 s->block= s->blocks[0];
481 s->parse_context.state= -1;
483 s->context_initialized = 1;
493 /* init common structure for both encoder and decoder */
494 void MPV_common_end(MpegEncContext *s)
498 av_freep(&s->parse_context.buffer);
499 s->parse_context.buffer_size=0;
501 av_freep(&s->mb_type);
502 av_freep(&s->p_mv_table_base);
503 av_freep(&s->b_forw_mv_table_base);
504 av_freep(&s->b_back_mv_table_base);
505 av_freep(&s->b_bidir_forw_mv_table_base);
506 av_freep(&s->b_bidir_back_mv_table_base);
507 av_freep(&s->b_direct_mv_table_base);
509 s->b_forw_mv_table= NULL;
510 s->b_back_mv_table= NULL;
511 s->b_bidir_forw_mv_table= NULL;
512 s->b_bidir_back_mv_table= NULL;
513 s->b_direct_mv_table= NULL;
515 av_freep(&s->motion_val);
516 av_freep(&s->dc_val[0]);
517 av_freep(&s->ac_val[0]);
518 av_freep(&s->coded_block);
519 av_freep(&s->mbintra_table);
520 av_freep(&s->cbp_table);
521 av_freep(&s->pred_dir_table);
522 av_freep(&s->me.scratchpad);
523 av_freep(&s->me.map);
524 av_freep(&s->me.score_map);
526 av_freep(&s->mbskip_table);
527 av_freep(&s->prev_pict_types);
528 av_freep(&s->bitstream_buffer);
529 av_freep(&s->tex_pb_buffer);
530 av_freep(&s->pb2_buffer);
531 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
532 av_freep(&s->field_mv_table);
533 av_freep(&s->field_select_table);
534 av_freep(&s->avctx->stats_out);
535 av_freep(&s->ac_stats);
536 av_freep(&s->error_status_table);
537 av_freep(&s->mb_index2xy);
539 for(i=0; i<MAX_PICTURE_COUNT; i++){
540 free_picture(s, &s->picture[i]);
542 avcodec_default_free_buffers(s->avctx);
543 s->context_initialized = 0;
546 #ifdef CONFIG_ENCODERS
548 /* init video encoder */
549 int MPV_encode_init(AVCodecContext *avctx)
551 MpegEncContext *s = avctx->priv_data;
553 int chroma_h_shift, chroma_v_shift;
555 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
557 s->bit_rate = avctx->bit_rate;
558 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
559 s->width = avctx->width;
560 s->height = avctx->height;
561 if(avctx->gop_size > 600){
562 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
565 s->gop_size = avctx->gop_size;
566 s->rtp_mode = avctx->rtp_mode;
567 s->rtp_payload_size = avctx->rtp_payload_size;
568 if (avctx->rtp_callback)
569 s->rtp_callback = avctx->rtp_callback;
570 s->max_qdiff= avctx->max_qdiff;
571 s->qcompress= avctx->qcompress;
572 s->qblur= avctx->qblur;
574 s->flags= avctx->flags;
575 s->max_b_frames= avctx->max_b_frames;
576 s->b_frame_strategy= avctx->b_frame_strategy;
577 s->codec_id= avctx->codec->id;
578 s->luma_elim_threshold = avctx->luma_elim_threshold;
579 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
580 s->strict_std_compliance= avctx->strict_std_compliance;
581 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
582 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
583 s->mpeg_quant= avctx->mpeg_quant;
585 if (s->gop_size <= 1) {
592 s->me_method = avctx->me_method;
595 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
597 s->adaptive_quant= ( s->avctx->lumi_masking
598 || s->avctx->dark_masking
599 || s->avctx->temporal_cplx_masking
600 || s->avctx->spatial_cplx_masking
601 || s->avctx->p_masking)
604 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
606 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
607 fprintf(stderr, "4MV not supporetd by codec\n");
611 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
612 fprintf(stderr, "qpel not supporetd by codec\n");
616 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
617 fprintf(stderr, "data partitioning not supporetd by codec\n");
621 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
622 fprintf(stderr, "b frames not supporetd by codec\n");
626 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
627 fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
631 if(s->codec_id==CODEC_ID_MJPEG){
632 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
633 s->inter_quant_bias= 0;
634 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
635 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
636 s->inter_quant_bias= 0;
638 s->intra_quant_bias=0;
639 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
642 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
643 s->intra_quant_bias= avctx->intra_quant_bias;
644 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
645 s->inter_quant_bias= avctx->inter_quant_bias;
647 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
649 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
650 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
652 switch(avctx->codec->id) {
653 case CODEC_ID_MPEG1VIDEO:
654 s->out_format = FMT_MPEG1;
655 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
656 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
658 case CODEC_ID_MPEG2VIDEO:
659 s->out_format = FMT_MPEG1;
660 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
661 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
662 s->rtp_mode= 1; // mpeg2 must have slices
663 if(s->rtp_payload_size == 0) s->rtp_payload_size= 256*256*256;
667 s->out_format = FMT_MJPEG;
668 s->intra_only = 1; /* force intra only for jpeg */
669 s->mjpeg_write_tables = 1; /* write all tables */
670 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
671 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
672 s->mjpeg_vsample[1] = 1;
673 s->mjpeg_vsample[2] = 1;
674 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
675 s->mjpeg_hsample[1] = 1;
676 s->mjpeg_hsample[2] = 1;
677 if (mjpeg_init(s) < 0)
684 if (h263_get_picture_format(s->width, s->height) == 7) {
685 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
688 s->out_format = FMT_H263;
693 s->out_format = FMT_H263;
696 s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
697 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
699 /* These are just to be sure */
705 s->out_format = FMT_H263;
706 s->h263_flv = 2; /* format = 1; 11-bit codes */
707 s->unrestricted_mv = 1;
708 s->rtp_mode=0; /* don't allow GOB */
713 s->out_format = FMT_H263;
719 s->out_format = FMT_H263;
721 s->unrestricted_mv = 1;
722 s->low_delay= s->max_b_frames ? 0 : 1;
723 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
725 case CODEC_ID_MSMPEG4V1:
726 s->out_format = FMT_H263;
729 s->unrestricted_mv = 1;
730 s->msmpeg4_version= 1;
734 case CODEC_ID_MSMPEG4V2:
735 s->out_format = FMT_H263;
738 s->unrestricted_mv = 1;
739 s->msmpeg4_version= 2;
743 case CODEC_ID_MSMPEG4V3:
744 s->out_format = FMT_H263;
747 s->unrestricted_mv = 1;
748 s->msmpeg4_version= 3;
749 s->flipflop_rounding=1;
754 s->out_format = FMT_H263;
757 s->unrestricted_mv = 1;
758 s->msmpeg4_version= 4;
759 s->flipflop_rounding=1;
764 s->out_format = FMT_H263;
767 s->unrestricted_mv = 1;
768 s->msmpeg4_version= 5;
769 s->flipflop_rounding=1;
778 { /* set up some save defaults, some codecs might override them later */
784 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
785 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
786 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
788 for(i=-16; i<16; i++){
789 default_fcode_tab[i + MAX_MV]= 1;
793 s->me.mv_penalty= default_mv_penalty;
794 s->fcode_tab= default_fcode_tab;
796 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
798 /* dont use mv_penalty table for crap MV as it would be confused */
799 //FIXME remove after fixing / removing old ME
800 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
805 if (MPV_common_init(s) < 0)
810 #ifdef CONFIG_ENCODERS
812 if (s->out_format == FMT_H263)
814 if(s->msmpeg4_version)
815 ff_msmpeg4_encode_init(s);
817 if (s->out_format == FMT_MPEG1)
818 ff_mpeg1_encode_init(s);
821 /* init default q matrix */
823 int j= s->dsp.idct_permutation[i];
825 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
826 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
827 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
828 }else if(s->out_format == FMT_H263){
830 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
834 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
835 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
837 if(s->avctx->intra_matrix)
838 s->intra_matrix[j] = s->avctx->intra_matrix[i];
839 if(s->avctx->inter_matrix)
840 s->inter_matrix[j] = s->avctx->inter_matrix[i];
843 /* precompute matrix */
844 /* for mjpeg, we do include qscale in the matrix */
845 if (s->out_format != FMT_MJPEG) {
846 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
847 s->intra_matrix, s->intra_quant_bias, 1, 31);
848 convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
849 s->inter_matrix, s->inter_quant_bias, 1, 31);
852 if(ff_rate_control_init(s) < 0)
855 s->picture_number = 0;
856 s->picture_in_gop_number = 0;
857 s->fake_picture_number = 0;
858 /* motion detector init */
865 int MPV_encode_end(AVCodecContext *avctx)
867 MpegEncContext *s = avctx->priv_data;
873 ff_rate_control_uninit(s);
876 if (s->out_format == FMT_MJPEG)
879 av_freep(&avctx->extradata);
884 #endif //CONFIG_ENCODERS
886 void init_rl(RLTable *rl)
888 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
889 uint8_t index_run[MAX_RUN+1];
890 int last, run, level, start, end, i;
892 /* compute max_level[], max_run[] and index_run[] */
893 for(last=0;last<2;last++) {
902 memset(max_level, 0, MAX_RUN + 1);
903 memset(max_run, 0, MAX_LEVEL + 1);
904 memset(index_run, rl->n, MAX_RUN + 1);
905 for(i=start;i<end;i++) {
906 run = rl->table_run[i];
907 level = rl->table_level[i];
908 if (index_run[run] == rl->n)
910 if (level > max_level[run])
911 max_level[run] = level;
912 if (run > max_run[level])
913 max_run[level] = run;
915 rl->max_level[last] = av_malloc(MAX_RUN + 1);
916 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
917 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
918 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
919 rl->index_run[last] = av_malloc(MAX_RUN + 1);
920 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
924 /* draw the edges of width 'w' of an image of size width, height */
925 //FIXME check that this is ok for mpeg4 interlaced
926 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
928 uint8_t *ptr, *last_line;
931 last_line = buf + (height - 1) * wrap;
934 memcpy(buf - (i + 1) * wrap, buf, width);
935 memcpy(last_line + (i + 1) * wrap, last_line, width);
939 for(i=0;i<height;i++) {
940 memset(ptr - w, ptr[0], w);
941 memset(ptr + width, ptr[width-1], w);
946 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
947 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
948 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
949 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
953 static int find_unused_picture(MpegEncContext *s, int shared){
957 for(i=0; i<MAX_PICTURE_COUNT; i++){
958 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
961 for(i=0; i<MAX_PICTURE_COUNT; i++){
962 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
964 for(i=0; i<MAX_PICTURE_COUNT; i++){
965 if(s->picture[i].data[0]==NULL) break;
969 assert(i<MAX_PICTURE_COUNT);
973 /* generic function for encode/decode called before a frame is coded/decoded */
974 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
981 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
983 /* mark&release old frames */
984 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr->data[0]) {
985 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
987 /* release forgotten pictures */
988 /* if(mpeg124/h263) */
990 for(i=0; i<MAX_PICTURE_COUNT; i++){
991 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
992 fprintf(stderr, "releasing zombie picture\n");
993 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1000 /* release non refernce frames */
1001 for(i=0; i<MAX_PICTURE_COUNT; i++){
1002 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1003 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1007 i= find_unused_picture(s, 0);
1009 pic= (AVFrame*)&s->picture[i];
1010 pic->reference= s->pict_type != B_TYPE ? 3 : 0;
1012 if(s->current_picture_ptr)
1013 pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
1015 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1018 s->current_picture_ptr= &s->picture[i];
1021 s->current_picture_ptr->pict_type= s->pict_type;
1022 s->current_picture_ptr->quality= s->qscale;
1023 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1025 s->current_picture= *s->current_picture_ptr;
1027 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1028 if (s->pict_type != B_TYPE) {
1029 s->last_picture_ptr= s->next_picture_ptr;
1030 s->next_picture_ptr= s->current_picture_ptr;
1033 if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
1034 if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
1035 if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
1037 if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
1038 fprintf(stderr, "warning: first frame is no keyframe\n");
1039 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1043 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1045 if(s->picture_structure!=PICT_FRAME){
1048 if(s->picture_structure == PICT_BOTTOM_FIELD){
1049 s->current_picture.data[i] += s->current_picture.linesize[i];
1051 s->current_picture.linesize[i] *= 2;
1052 s->last_picture.linesize[i] *=2;
1053 s->next_picture.linesize[i] *=2;
1058 s->hurry_up= s->avctx->hurry_up;
1059 s->error_resilience= avctx->error_resilience;
1061 /* set dequantizer, we cant do it during init as it might change for mpeg4
1062 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1063 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO)
1064 s->dct_unquantize = s->dct_unquantize_mpeg2;
1065 else if(s->out_format == FMT_H263)
1066 s->dct_unquantize = s->dct_unquantize_h263;
1068 s->dct_unquantize = s->dct_unquantize_mpeg1;
1071 if(s->avctx->xvmc_acceleration)
1072 return XVMC_field_start(s, avctx);
1077 /* generic function for encode/decode called after a frame has been coded/decoded */
1078 void MPV_frame_end(MpegEncContext *s)
1081 /* draw edge for correct motion prediction if outside */
1083 //just to make sure that all data is rendered.
1084 if(s->avctx->xvmc_acceleration){
1088 if(s->codec_id!=CODEC_ID_SVQ1 && s->out_format != FMT_MPEG1){
1089 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1090 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1091 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1092 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1097 s->last_pict_type = s->pict_type;
1098 if(s->pict_type!=B_TYPE){
1099 s->last_non_b_pict_type= s->pict_type;
1102 /* copy back current_picture variables */
1103 for(i=0; i<MAX_PICTURE_COUNT; i++){
1104 if(s->picture[i].data[0] == s->current_picture.data[0]){
1105 s->picture[i]= s->current_picture;
1109 assert(i<MAX_PICTURE_COUNT);
1113 /* release non refernce frames */
1114 for(i=0; i<MAX_PICTURE_COUNT; i++){
1115 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1116 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1120 // clear copies, to avoid confusion
1122 memset(&s->last_picture, 0, sizeof(Picture));
1123 memset(&s->next_picture, 0, sizeof(Picture));
1124 memset(&s->current_picture, 0, sizeof(Picture));
1129 * draws an line from (ex, ey) -> (sx, sy).
1130 * @param w width of the image
1131 * @param h height of the image
1132 * @param stride stride/linesize of the image
1133 * @param color color of the arrow
1135 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1138 sx= clip(sx, 0, w-1);
1139 sy= clip(sy, 0, h-1);
1140 ex= clip(ex, 0, w-1);
1141 ey= clip(ey, 0, h-1);
1143 buf[sy*stride + sx]+= color;
1145 if(ABS(ex - sx) > ABS(ey - sy)){
1150 buf+= sx + sy*stride;
1152 f= ((ey-sy)<<16)/ex;
1153 for(x= 0; x <= ex; x++){
1154 y= ((x*f) + (1<<15))>>16;
1155 buf[y*stride + x]+= color;
1162 buf+= sx + sy*stride;
1164 if(ey) f= ((ex-sx)<<16)/ey;
1166 for(y= 0; y <= ey; y++){
1167 x= ((y*f) + (1<<15))>>16;
1168 buf[y*stride + x]+= color;
1174 * draws an arrow from (ex, ey) -> (sx, sy).
1175 * @param w width of the image
1176 * @param h height of the image
1177 * @param stride stride/linesize of the image
1178 * @param color color of the arrow
1180 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1183 sx= clip(sx, -100, w+100);
1184 sy= clip(sy, -100, h+100);
1185 ex= clip(ex, -100, w+100);
1186 ey= clip(ey, -100, h+100);
1191 if(dx*dx + dy*dy > 3*3){
1194 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1196 //FIXME subpixel accuracy
1197 rx= ROUNDED_DIV(rx*3<<4, length);
1198 ry= ROUNDED_DIV(ry*3<<4, length);
1200 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1201 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1203 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1207 * prints debuging info for the given picture.
1209 void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1211 if(!pict || !pict->mb_type) return;
1213 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1216 for(y=0; y<s->mb_height; y++){
1217 for(x=0; x<s->mb_width; x++){
1218 if(s->avctx->debug&FF_DEBUG_SKIP){
1219 int count= s->mbskip_table[x + y*s->mb_stride];
1220 if(count>9) count=9;
1221 printf("%1d", count);
1223 if(s->avctx->debug&FF_DEBUG_QP){
1224 printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1226 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1227 int mb_type= pict->mb_type[x + y*s->mb_stride];
1229 //Type & MV direction
1232 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1234 else if(IS_INTRA4x4(mb_type))
1236 else if(IS_INTRA16x16(mb_type))
1238 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1240 else if(IS_DIRECT(mb_type))
1242 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1244 else if(IS_GMC(mb_type))
1246 else if(IS_SKIP(mb_type))
1248 else if(!USES_LIST(mb_type, 1))
1250 else if(!USES_LIST(mb_type, 0))
1253 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1260 else if(IS_16X8(mb_type))
1262 else if(IS_8X16(mb_type))
1264 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1270 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1281 if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1282 const int shift= 1 + s->quarter_sample;
1284 uint8_t *ptr= pict->data[0];
1285 s->low_delay=0; //needed to see the vectors without trashing the buffers
1287 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1289 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1290 const int mb_index= mb_x + mb_y*s->mb_stride;
1291 if(IS_8X8(s->current_picture.mb_type[mb_index])){
1294 int sx= mb_x*16 + 4 + 8*(i&1);
1295 int sy= mb_y*16 + 4 + 8*(i>>1);
1296 int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1297 int mx= (s->motion_val[xy][0]>>shift) + sx;
1298 int my= (s->motion_val[xy][1]>>shift) + sy;
1299 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1302 int sx= mb_x*16 + 8;
1303 int sy= mb_y*16 + 8;
1304 int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1305 int mx= (s->motion_val[xy][0]>>shift) + sx;
1306 int my= (s->motion_val[xy][1]>>shift) + sy;
1307 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1309 s->mbskip_table[mb_index]=0;
1315 #ifdef CONFIG_ENCODERS
1317 static int get_sae(uint8_t *src, int ref, int stride){
1321 for(y=0; y<16; y++){
1322 for(x=0; x<16; x++){
1323 acc+= ABS(src[x+y*stride] - ref);
1330 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1337 for(y=0; y<h; y+=16){
1338 for(x=0; x<w; x+=16){
1339 int offset= x + y*stride;
1340 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1341 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1342 int sae = get_sae(src + offset, mean, stride);
1344 acc+= sae + 500 < sad;
1351 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1354 const int encoding_delay= s->max_b_frames;
1358 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1359 if(pic_arg->linesize[0] != s->linesize) direct=0;
1360 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1361 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1363 // printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1366 i= find_unused_picture(s, 1);
1368 pic= (AVFrame*)&s->picture[i];
1372 pic->data[i]= pic_arg->data[i];
1373 pic->linesize[i]= pic_arg->linesize[i];
1375 alloc_picture(s, (Picture*)pic, 1);
1377 i= find_unused_picture(s, 0);
1379 pic= (AVFrame*)&s->picture[i];
1382 alloc_picture(s, (Picture*)pic, 0);
1384 /* the input will be 16 pixels to the right relative to the actual buffer start
1385 * and the current_pic, so the buffer can be reused, yes its not beatifull
1390 if( pic->data[0] == pic_arg->data[0]
1391 && pic->data[1] == pic_arg->data[1]
1392 && pic->data[2] == pic_arg->data[2]){
1395 int h_chroma_shift, v_chroma_shift;
1396 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1399 int src_stride= pic_arg->linesize[i];
1400 int dst_stride= i ? s->uvlinesize : s->linesize;
1401 int h_shift= i ? h_chroma_shift : 0;
1402 int v_shift= i ? v_chroma_shift : 0;
1403 int w= s->width >>h_shift;
1404 int h= s->height>>v_shift;
1405 uint8_t *src= pic_arg->data[i];
1406 uint8_t *dst= pic->data[i];
1408 if(src_stride==dst_stride)
1409 memcpy(dst, src, src_stride*h);
1412 memcpy(dst, src, w);
1420 pic->quality= pic_arg->quality;
1421 pic->pict_type= pic_arg->pict_type;
1422 pic->pts = pic_arg->pts;
1424 if(s->input_picture[encoding_delay])
1425 pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1429 /* shift buffer entries */
1430 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1431 s->input_picture[i-1]= s->input_picture[i];
1433 s->input_picture[encoding_delay]= (Picture*)pic;
1438 static void select_input_picture(MpegEncContext *s){
1440 int coded_pic_num=0;
1442 if(s->reordered_input_picture[0])
1443 coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1445 for(i=1; i<MAX_PICTURE_COUNT; i++)
1446 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1447 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1449 /* set next picture types & ordering */
1450 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1451 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1452 s->reordered_input_picture[0]= s->input_picture[0];
1453 s->reordered_input_picture[0]->pict_type= I_TYPE;
1454 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1458 if(s->flags&CODEC_FLAG_PASS2){
1459 for(i=0; i<s->max_b_frames+1; i++){
1460 int pict_num= s->input_picture[0]->display_picture_number + i;
1461 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1462 s->input_picture[i]->pict_type= pict_type;
1464 if(i + 1 >= s->rc_context.num_entries) break;
1468 if(s->input_picture[0]->pict_type){
1469 /* user selected pict_type */
1470 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1471 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1474 if(b_frames > s->max_b_frames){
1475 fprintf(stderr, "warning, too many bframes in a row\n");
1476 b_frames = s->max_b_frames;
1478 }else if(s->b_frame_strategy==0){
1479 b_frames= s->max_b_frames;
1480 while(b_frames && !s->input_picture[b_frames]) b_frames--;
1481 }else if(s->b_frame_strategy==1){
1482 for(i=1; i<s->max_b_frames+1; i++){
1483 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
1484 s->input_picture[i]->b_frame_score=
1485 get_intra_count(s, s->input_picture[i ]->data[0],
1486 s->input_picture[i-1]->data[0], s->linesize) + 1;
1489 for(i=0; i<s->max_b_frames; i++){
1490 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1493 b_frames= FFMAX(0, i-1);
1496 for(i=0; i<b_frames+1; i++){
1497 s->input_picture[i]->b_frame_score=0;
1500 fprintf(stderr, "illegal b frame strategy\n");
1505 //static int b_count=0;
1506 //b_count+= b_frames;
1507 //printf("b_frames: %d\n", b_count);
1509 s->reordered_input_picture[0]= s->input_picture[b_frames];
1510 if( s->picture_in_gop_number + b_frames >= s->gop_size
1511 || s->reordered_input_picture[0]->pict_type== I_TYPE)
1512 s->reordered_input_picture[0]->pict_type= I_TYPE;
1514 s->reordered_input_picture[0]->pict_type= P_TYPE;
1515 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1516 for(i=0; i<b_frames; i++){
1518 s->reordered_input_picture[i+1]= s->input_picture[i];
1519 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1520 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1525 if(s->reordered_input_picture[0]){
1526 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1528 s->new_picture= *s->reordered_input_picture[0];
1530 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1531 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1533 int i= find_unused_picture(s, 0);
1534 Picture *pic= &s->picture[i];
1536 /* mark us unused / free shared pic */
1538 s->reordered_input_picture[0]->data[i]= NULL;
1539 s->reordered_input_picture[0]->type= 0;
1541 //FIXME bad, copy * except
1542 pic->pict_type = s->reordered_input_picture[0]->pict_type;
1543 pic->quality = s->reordered_input_picture[0]->quality;
1544 pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1545 pic->reference = s->reordered_input_picture[0]->reference;
1546 pic->pts = s->reordered_input_picture[0]->pts;
1548 alloc_picture(s, pic, 0);
1550 s->current_picture_ptr= pic;
1552 // input is not a shared pix -> reuse buffer for current_pix
1554 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1555 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1557 s->current_picture_ptr= s->reordered_input_picture[0];
1559 //reverse the +16 we did before storing the input
1560 s->current_picture_ptr->data[i]-=16;
1563 s->current_picture= *s->current_picture_ptr;
1565 s->picture_number= s->new_picture.display_picture_number;
1566 //printf("dpn:%d\n", s->picture_number);
1568 memset(&s->new_picture, 0, sizeof(Picture));
1572 int MPV_encode_picture(AVCodecContext *avctx,
1573 unsigned char *buf, int buf_size, void *data)
1575 MpegEncContext *s = avctx->priv_data;
1576 AVFrame *pic_arg = data;
1579 if(avctx->pix_fmt != PIX_FMT_YUV420P){
1580 fprintf(stderr, "this codec supports only YUV420P\n");
1584 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1586 s->picture_in_gop_number++;
1588 load_input_picture(s, pic_arg);
1590 select_input_picture(s);
1593 if(s->new_picture.data[0]){
1595 s->pict_type= s->new_picture.pict_type;
1596 if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1597 s->qscale= (int)(s->new_picture.quality+0.5);
1601 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1602 MPV_frame_start(s, avctx);
1604 encode_picture(s, s->picture_number);
1606 avctx->real_pict_num = s->picture_number;
1607 avctx->header_bits = s->header_bits;
1608 avctx->mv_bits = s->mv_bits;
1609 avctx->misc_bits = s->misc_bits;
1610 avctx->i_tex_bits = s->i_tex_bits;
1611 avctx->p_tex_bits = s->p_tex_bits;
1612 avctx->i_count = s->i_count;
1613 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1614 avctx->skip_count = s->skip_count;
1618 if (s->out_format == FMT_MJPEG)
1619 mjpeg_picture_trailer(s);
1621 if(s->flags&CODEC_FLAG_PASS1)
1622 ff_write_pass1_stats(s);
1625 avctx->error[i] += s->current_picture_ptr->error[i];
1629 s->input_picture_number++;
1631 flush_put_bits(&s->pb);
1632 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1634 s->total_bits += s->frame_bits;
1635 avctx->frame_bits = s->frame_bits;
1637 return pbBufPtr(&s->pb) - s->pb.buf;
1640 #endif //CONFIG_ENCODERS
1642 static inline void gmc1_motion(MpegEncContext *s,
1643 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1645 uint8_t **ref_picture, int src_offset)
1648 int offset, src_x, src_y, linesize, uvlinesize;
1649 int motion_x, motion_y;
1652 motion_x= s->sprite_offset[0][0];
1653 motion_y= s->sprite_offset[0][1];
1654 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1655 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1656 motion_x<<=(3-s->sprite_warping_accuracy);
1657 motion_y<<=(3-s->sprite_warping_accuracy);
1658 src_x = clip(src_x, -16, s->width);
1659 if (src_x == s->width)
1661 src_y = clip(src_y, -16, s->height);
1662 if (src_y == s->height)
1665 linesize = s->linesize;
1666 uvlinesize = s->uvlinesize;
1668 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1670 dest_y+=dest_offset;
1671 if(s->flags&CODEC_FLAG_EMU_EDGE){
1672 if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1673 || src_y + 17 >= s->v_edge_pos){
1674 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1675 ptr= s->edge_emu_buffer;
1679 if((motion_x|motion_y)&7){
1680 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1681 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1685 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1686 if (s->no_rounding){
1687 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1689 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
1693 if(s->flags&CODEC_FLAG_GRAY) return;
1695 motion_x= s->sprite_offset[1][0];
1696 motion_y= s->sprite_offset[1][1];
1697 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1698 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1699 motion_x<<=(3-s->sprite_warping_accuracy);
1700 motion_y<<=(3-s->sprite_warping_accuracy);
1701 src_x = clip(src_x, -8, s->width>>1);
1702 if (src_x == s->width>>1)
1704 src_y = clip(src_y, -8, s->height>>1);
1705 if (src_y == s->height>>1)
1708 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1709 ptr = ref_picture[1] + offset;
1710 if(s->flags&CODEC_FLAG_EMU_EDGE){
1711 if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1712 || src_y + 9 >= s->v_edge_pos>>1){
1713 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);
1714 ptr= s->edge_emu_buffer;
1718 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1720 ptr = ref_picture[2] + offset;
1722 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);
1723 ptr= s->edge_emu_buffer;
1725 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1730 static inline void gmc_motion(MpegEncContext *s,
1731 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1733 uint8_t **ref_picture, int src_offset)
1736 int linesize, uvlinesize;
1737 const int a= s->sprite_warping_accuracy;
1740 linesize = s->linesize;
1741 uvlinesize = s->uvlinesize;
1743 ptr = ref_picture[0] + src_offset;
1745 dest_y+=dest_offset;
1747 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1748 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1750 s->dsp.gmc(dest_y, ptr, linesize, 16,
1753 s->sprite_delta[0][0], s->sprite_delta[0][1],
1754 s->sprite_delta[1][0], s->sprite_delta[1][1],
1755 a+1, (1<<(2*a+1)) - s->no_rounding,
1756 s->h_edge_pos, s->v_edge_pos);
1757 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1758 ox + s->sprite_delta[0][0]*8,
1759 oy + s->sprite_delta[1][0]*8,
1760 s->sprite_delta[0][0], s->sprite_delta[0][1],
1761 s->sprite_delta[1][0], s->sprite_delta[1][1],
1762 a+1, (1<<(2*a+1)) - s->no_rounding,
1763 s->h_edge_pos, s->v_edge_pos);
1765 if(s->flags&CODEC_FLAG_GRAY) return;
1768 dest_cb+=dest_offset>>1;
1769 dest_cr+=dest_offset>>1;
1771 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1772 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1774 ptr = ref_picture[1] + (src_offset>>1);
1775 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1778 s->sprite_delta[0][0], s->sprite_delta[0][1],
1779 s->sprite_delta[1][0], s->sprite_delta[1][1],
1780 a+1, (1<<(2*a+1)) - s->no_rounding,
1781 s->h_edge_pos>>1, s->v_edge_pos>>1);
1783 ptr = ref_picture[2] + (src_offset>>1);
1784 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1787 s->sprite_delta[0][0], s->sprite_delta[0][1],
1788 s->sprite_delta[1][0], s->sprite_delta[1][1],
1789 a+1, (1<<(2*a+1)) - s->no_rounding,
1790 s->h_edge_pos>>1, s->v_edge_pos>>1);
1794 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1795 * @param buf destination buffer
1796 * @param src source buffer
1797 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1798 * @param block_w width of block
1799 * @param block_h height of block
1800 * @param src_x x coordinate of the top left sample of the block in the source buffer
1801 * @param src_y y coordinate of the top left sample of the block in the source buffer
1802 * @param w width of the source buffer
1803 * @param h height of the source buffer
1805 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1806 int src_x, int src_y, int w, int h){
1808 int start_y, start_x, end_y, end_x;
1811 src+= (h-1-src_y)*linesize;
1813 }else if(src_y<=-block_h){
1814 src+= (1-block_h-src_y)*linesize;
1820 }else if(src_x<=-block_w){
1821 src+= (1-block_w-src_x);
1825 start_y= FFMAX(0, -src_y);
1826 start_x= FFMAX(0, -src_x);
1827 end_y= FFMIN(block_h, h-src_y);
1828 end_x= FFMIN(block_w, w-src_x);
1830 // copy existing part
1831 for(y=start_y; y<end_y; y++){
1832 for(x=start_x; x<end_x; x++){
1833 buf[x + y*linesize]= src[x + y*linesize];
1838 for(y=0; y<start_y; y++){
1839 for(x=start_x; x<end_x; x++){
1840 buf[x + y*linesize]= buf[x + start_y*linesize];
1845 for(y=end_y; y<block_h; y++){
1846 for(x=start_x; x<end_x; x++){
1847 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1851 for(y=0; y<block_h; y++){
1853 for(x=0; x<start_x; x++){
1854 buf[x + y*linesize]= buf[start_x + y*linesize];
1858 for(x=end_x; x<block_w; x++){
1859 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1865 /* apply one mpeg motion vector to the three components */
1866 static inline void mpeg_motion(MpegEncContext *s,
1867 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1869 uint8_t **ref_picture, int src_offset,
1870 int field_based, op_pixels_func (*pix_op)[4],
1871 int motion_x, int motion_y, int h)
1874 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1877 if(s->quarter_sample)
1883 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1884 src_x = s->mb_x * 16 + (motion_x >> 1);
1885 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1887 /* WARNING: do no forget half pels */
1888 height = s->height >> field_based;
1889 v_edge_pos = s->v_edge_pos >> field_based;
1890 src_x = clip(src_x, -16, s->width);
1891 if (src_x == s->width)
1893 src_y = clip(src_y, -16, height);
1894 if (src_y == height)
1896 linesize = s->current_picture.linesize[0] << field_based;
1897 uvlinesize = s->current_picture.linesize[1] << field_based;
1898 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1899 dest_y += dest_offset;
1901 if(s->flags&CODEC_FLAG_EMU_EDGE){
1902 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1903 || src_y + (motion_y&1) + h > v_edge_pos){
1904 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, //FIXME linesize? and uv below
1905 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1906 ptr= s->edge_emu_buffer + src_offset;
1910 pix_op[0][dxy](dest_y, ptr, linesize, h);
1912 if(s->flags&CODEC_FLAG_GRAY) return;
1914 if (s->out_format == FMT_H263) {
1916 if ((motion_x & 3) != 0)
1918 if ((motion_y & 3) != 0)
1925 dxy = ((my & 1) << 1) | (mx & 1);
1930 src_x = s->mb_x * 8 + mx;
1931 src_y = s->mb_y * (8 >> field_based) + my;
1932 src_x = clip(src_x, -8, s->width >> 1);
1933 if (src_x == (s->width >> 1))
1935 src_y = clip(src_y, -8, height >> 1);
1936 if (src_y == (height >> 1))
1938 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1939 ptr = ref_picture[1] + offset;
1941 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1942 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1943 ptr= s->edge_emu_buffer + (src_offset >> 1);
1945 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1947 ptr = ref_picture[2] + offset;
1949 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1950 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1951 ptr= s->edge_emu_buffer + (src_offset >> 1);
1953 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1956 static inline void qpel_motion(MpegEncContext *s,
1957 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1959 uint8_t **ref_picture, int src_offset,
1960 int field_based, op_pixels_func (*pix_op)[4],
1961 qpel_mc_func (*qpix_op)[16],
1962 int motion_x, int motion_y, int h)
1965 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1968 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1969 src_x = s->mb_x * 16 + (motion_x >> 2);
1970 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1972 height = s->height >> field_based;
1973 v_edge_pos = s->v_edge_pos >> field_based;
1974 src_x = clip(src_x, -16, s->width);
1975 if (src_x == s->width)
1977 src_y = clip(src_y, -16, height);
1978 if (src_y == height)
1980 linesize = s->linesize << field_based;
1981 uvlinesize = s->uvlinesize << field_based;
1982 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1983 dest_y += dest_offset;
1984 //printf("%d %d %d\n", src_x, src_y, dxy);
1986 if(s->flags&CODEC_FLAG_EMU_EDGE){
1987 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1988 || src_y + (motion_y&3) + h > v_edge_pos){
1989 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,
1990 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1991 ptr= s->edge_emu_buffer + src_offset;
1996 qpix_op[0][dxy](dest_y, ptr, linesize);
1998 //damn interlaced mode
1999 //FIXME boundary mirroring is not exactly correct here
2000 qpix_op[1][dxy](dest_y , ptr , linesize);
2001 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
2004 if(s->flags&CODEC_FLAG_GRAY) return;
2009 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2010 static const int rtab[8]= {0,0,1,1,0,0,0,1};
2011 mx= (motion_x>>1) + rtab[motion_x&7];
2012 my= (motion_y>>1) + rtab[motion_y&7];
2013 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2014 mx= (motion_x>>1)|(motion_x&1);
2015 my= (motion_y>>1)|(motion_y&1);
2023 dxy= (mx&1) | ((my&1)<<1);
2027 src_x = s->mb_x * 8 + mx;
2028 src_y = s->mb_y * (8 >> field_based) + my;
2029 src_x = clip(src_x, -8, s->width >> 1);
2030 if (src_x == (s->width >> 1))
2032 src_y = clip(src_y, -8, height >> 1);
2033 if (src_y == (height >> 1))
2036 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
2037 ptr = ref_picture[1] + offset;
2039 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
2040 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2041 ptr= s->edge_emu_buffer + (src_offset >> 1);
2043 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2045 ptr = ref_picture[2] + offset;
2047 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
2048 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2049 ptr= s->edge_emu_buffer + (src_offset >> 1);
2051 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
2054 inline int ff_h263_round_chroma(int x){
2056 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2059 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2064 * motion compesation of a single macroblock
2066 * @param dest_y luma destination pointer
2067 * @param dest_cb chroma cb/u destination pointer
2068 * @param dest_cr chroma cr/v destination pointer
2069 * @param dir direction (0->forward, 1->backward)
2070 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2071 * @param pic_op halfpel motion compensation function (average or put normally)
2072 * @param pic_op qpel motion compensation function (average or put normally)
2073 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2075 static inline void MPV_motion(MpegEncContext *s,
2076 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2077 int dir, uint8_t **ref_picture,
2078 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2080 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2082 uint8_t *ptr, *dest;
2088 switch(s->mv_type) {
2092 if(s->real_sprite_warping_points==1){
2093 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2096 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2099 }else if(s->quarter_sample){
2100 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2103 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2105 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2106 ref_picture, pix_op,
2107 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2111 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2114 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2120 if(s->quarter_sample){
2122 motion_x = s->mv[dir][i][0];
2123 motion_y = s->mv[dir][i][1];
2125 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2126 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2127 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2129 /* WARNING: do no forget half pels */
2130 src_x = clip(src_x, -16, s->width);
2131 if (src_x == s->width)
2133 src_y = clip(src_y, -16, s->height);
2134 if (src_y == s->height)
2137 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2138 if(s->flags&CODEC_FLAG_EMU_EDGE){
2139 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
2140 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
2141 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);
2142 ptr= s->edge_emu_buffer;
2145 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2146 qpix_op[1][dxy](dest, ptr, s->linesize);
2148 mx += s->mv[dir][i][0]/2;
2149 my += s->mv[dir][i][1]/2;
2153 motion_x = s->mv[dir][i][0];
2154 motion_y = s->mv[dir][i][1];
2156 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2157 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2158 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2160 /* WARNING: do no forget half pels */
2161 src_x = clip(src_x, -16, s->width);
2162 if (src_x == s->width)
2164 src_y = clip(src_y, -16, s->height);
2165 if (src_y == s->height)
2168 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2169 if(s->flags&CODEC_FLAG_EMU_EDGE){
2170 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2171 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2172 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);
2173 ptr= s->edge_emu_buffer;
2176 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2177 pix_op[1][dxy](dest, ptr, s->linesize, 8);
2179 mx += s->mv[dir][i][0];
2180 my += s->mv[dir][i][1];
2184 if(s->flags&CODEC_FLAG_GRAY) break;
2185 /* In case of 8X8, we construct a single chroma motion vector
2186 with a special rounding */
2187 mx= ff_h263_round_chroma(mx);
2188 my= ff_h263_round_chroma(my);
2189 dxy = ((my & 1) << 1) | (mx & 1);
2193 src_x = mb_x * 8 + mx;
2194 src_y = mb_y * 8 + my;
2195 src_x = clip(src_x, -8, s->width/2);
2196 if (src_x == s->width/2)
2198 src_y = clip(src_y, -8, s->height/2);
2199 if (src_y == s->height/2)
2202 offset = (src_y * (s->uvlinesize)) + src_x;
2203 ptr = ref_picture[1] + offset;
2204 if(s->flags&CODEC_FLAG_EMU_EDGE){
2205 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2206 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2207 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);
2208 ptr= s->edge_emu_buffer;
2212 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2214 ptr = ref_picture[2] + offset;
2216 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);
2217 ptr= s->edge_emu_buffer;
2219 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2222 if (s->picture_structure == PICT_FRAME) {
2223 if(s->quarter_sample){
2225 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2226 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2228 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2230 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2231 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2233 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2236 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2237 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2239 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2241 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2242 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2244 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2248 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2249 offset= s->field_select[dir][0] ? s->linesize : 0;
2251 ref_picture= s->current_picture.data;
2252 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2255 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2256 ref_picture, offset,
2258 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2263 uint8_t ** ref2picture;
2265 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2266 ref2picture= ref_picture;
2267 offset= s->field_select[dir][0] ? s->linesize : 0;
2269 ref2picture= s->current_picture.data;
2270 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2273 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2274 ref2picture, offset,
2276 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2279 if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2280 ref2picture= ref_picture;
2281 offset= s->field_select[dir][1] ? s->linesize : 0;
2283 ref2picture= s->current_picture.data;
2284 offset= s->field_select[dir][1] ? s->linesize : -s->linesize;
2286 // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2287 mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2289 ref2picture, offset,
2291 s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2297 op_pixels_func (*dmv_pix_op)[4];
2300 dmv_pix_op = s->dsp.put_pixels_tab;
2302 if(s->picture_structure == PICT_FRAME){
2303 //put top field from top field
2304 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2307 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2308 //put bottom field from bottom field
2309 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2310 ref_picture, s->linesize,
2312 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2314 dmv_pix_op = s->dsp.avg_pixels_tab;
2316 //avg top field from bottom field
2317 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2318 ref_picture, s->linesize,
2320 s->mv[dir][2][0], s->mv[dir][2][1], 8);
2321 //avg bottom field from top field
2322 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2325 s->mv[dir][3][0], s->mv[dir][3][1], 8);
2328 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2331 //put field from the same parity
2332 //same parity is never in the same frame
2333 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2336 s->mv[dir][0][0],s->mv[dir][0][1],16);
2338 // after put we make avg of the same block
2339 dmv_pix_op=s->dsp.avg_pixels_tab;
2341 //opposite parity is always in the same frame if this is second field
2342 if(!s->first_field){
2343 ref_picture = s->current_picture.data;
2344 //top field is one linesize from frame beginig
2345 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2346 -s->linesize : s->linesize;
2348 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2351 //avg field from the opposite parity
2352 mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2353 ref_picture, offset,
2355 s->mv[dir][2][0],s->mv[dir][2][1],16);
2364 /* put block[] to dest[] */
2365 static inline void put_dct(MpegEncContext *s,
2366 DCTELEM *block, int i, uint8_t *dest, int line_size)
2368 s->dct_unquantize(s, block, i, s->qscale);
2369 s->dsp.idct_put (dest, line_size, block);
2372 /* add block[] to dest[] */
2373 static inline void add_dct(MpegEncContext *s,
2374 DCTELEM *block, int i, uint8_t *dest, int line_size)
2376 if (s->block_last_index[i] >= 0) {
2377 s->dsp.idct_add (dest, line_size, block);
2381 static inline void add_dequant_dct(MpegEncContext *s,
2382 DCTELEM *block, int i, uint8_t *dest, int line_size)
2384 if (s->block_last_index[i] >= 0) {
2385 s->dct_unquantize(s, block, i, s->qscale);
2387 s->dsp.idct_add (dest, line_size, block);
2392 * cleans dc, ac, coded_block for the current non intra MB
2394 void ff_clean_intra_table_entries(MpegEncContext *s)
2396 int wrap = s->block_wrap[0];
2397 int xy = s->block_index[0];
2400 s->dc_val[0][xy + 1 ] =
2401 s->dc_val[0][xy + wrap] =
2402 s->dc_val[0][xy + 1 + wrap] = 1024;
2404 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2405 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2406 if (s->msmpeg4_version>=3) {
2407 s->coded_block[xy ] =
2408 s->coded_block[xy + 1 ] =
2409 s->coded_block[xy + wrap] =
2410 s->coded_block[xy + 1 + wrap] = 0;
2413 wrap = s->block_wrap[4];
2414 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2416 s->dc_val[2][xy] = 1024;
2418 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2419 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2421 s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2424 /* generic function called after a macroblock has been parsed by the
2425 decoder or after it has been encoded by the encoder.
2427 Important variables used:
2428 s->mb_intra : true if intra macroblock
2429 s->mv_dir : motion vector direction
2430 s->mv_type : motion vector type
2431 s->mv : motion vector
2432 s->interlaced_dct : true if interlaced dct used (mpeg2)
2434 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2437 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2439 if(s->avctx->xvmc_acceleration){
2440 XVMC_decode_mb(s,block);
2448 s->current_picture.qscale_table[mb_xy]= s->qscale;
2450 /* update DC predictors for P macroblocks */
2452 if (s->h263_pred || s->h263_aic) {
2453 if(s->mbintra_table[mb_xy])
2454 ff_clean_intra_table_entries(s);
2458 s->last_dc[2] = 128 << s->intra_dc_precision;
2461 else if (s->h263_pred || s->h263_aic)
2462 s->mbintra_table[mb_xy]=1;
2464 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2465 uint8_t *dest_y, *dest_cb, *dest_cr;
2466 int dct_linesize, dct_offset;
2467 op_pixels_func (*op_pix)[4];
2468 qpel_mc_func (*op_qpix)[16];
2469 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2470 const int uvlinesize= s->current_picture.linesize[1];
2472 /* avoid copy if macroblock skipped in last frame too */
2473 /* skip only during decoding as we might trash the buffers during encoding a bit */
2475 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2476 const int age= s->current_picture.age;
2482 assert(s->pict_type!=I_TYPE);
2484 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2485 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2487 /* if previous was skipped too, then nothing to do ! */
2488 if (*mbskip_ptr >= age && s->current_picture.reference){
2491 } else if(!s->current_picture.reference){
2492 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2493 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2495 *mbskip_ptr = 0; /* not skipped */
2499 if (s->interlaced_dct) {
2500 dct_linesize = linesize * 2;
2501 dct_offset = linesize;
2503 dct_linesize = linesize;
2504 dct_offset = linesize * 8;
2508 dest_cb= s->dest[1];
2509 dest_cr= s->dest[2];
2512 /* motion handling */
2513 /* decoding or more than one mb_type (MC was allready done otherwise) */
2515 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2516 op_pix = s->dsp.put_pixels_tab;
2517 op_qpix= s->dsp.put_qpel_pixels_tab;
2519 op_pix = s->dsp.put_no_rnd_pixels_tab;
2520 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2523 if (s->mv_dir & MV_DIR_FORWARD) {
2524 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2525 op_pix = s->dsp.avg_pixels_tab;
2526 op_qpix= s->dsp.avg_qpel_pixels_tab;
2528 if (s->mv_dir & MV_DIR_BACKWARD) {
2529 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2533 /* skip dequant / idct if we are really late ;) */
2534 if(s->hurry_up>1) return;
2536 /* add dct residue */
2537 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2538 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2539 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2540 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2541 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2542 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2544 if(!(s->flags&CODEC_FLAG_GRAY)){
2545 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2546 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2548 } else if(s->codec_id != CODEC_ID_WMV2){
2549 add_dct(s, block[0], 0, dest_y, dct_linesize);
2550 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2551 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2552 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2554 if(!(s->flags&CODEC_FLAG_GRAY)){
2555 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2556 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2561 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2565 /* dct only in intra block */
2566 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2567 put_dct(s, block[0], 0, dest_y, dct_linesize);
2568 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2569 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2570 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2572 if(!(s->flags&CODEC_FLAG_GRAY)){
2573 put_dct(s, block[4], 4, dest_cb, uvlinesize);
2574 put_dct(s, block[5], 5, dest_cr, uvlinesize);
2577 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2578 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]);
2579 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2580 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2582 if(!(s->flags&CODEC_FLAG_GRAY)){
2583 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2584 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2591 #ifdef CONFIG_ENCODERS
2593 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2595 static const char tab[64]=
2607 DCTELEM *block= s->block[n];
2608 const int last_index= s->block_last_index[n];
2613 threshold= -threshold;
2617 /* are all which we could set to zero are allready zero? */
2618 if(last_index<=skip_dc - 1) return;
2620 for(i=0; i<=last_index; i++){
2621 const int j = s->intra_scantable.permutated[i];
2622 const int level = ABS(block[j]);
2624 if(skip_dc && i==0) continue;
2633 if(score >= threshold) return;
2634 for(i=skip_dc; i<=last_index; i++){
2635 const int j = s->intra_scantable.permutated[i];
2638 if(block[0]) s->block_last_index[n]= 0;
2639 else s->block_last_index[n]= -1;
2642 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2645 const int maxlevel= s->max_qcoeff;
2646 const int minlevel= s->min_qcoeff;
2649 i=1; //skip clipping of intra dc
2653 for(;i<=last_index; i++){
2654 const int j= s->intra_scantable.permutated[i];
2655 int level = block[j];
2657 if (level>maxlevel) level=maxlevel;
2658 else if(level<minlevel) level=minlevel;
2665 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2670 for(x=0; x<16; x+=4){
2671 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
2672 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2680 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2685 for(x=0; x<16; x++){
2686 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2695 #define SQ(a) ((a)*(a))
2697 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2702 for(x=0; x<16; x+=4){
2703 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
2704 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2712 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2717 for(x=0; x<16; x++){
2718 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2729 #endif //CONFIG_ENCODERS
2733 * @param h is the normal height, this will be reduced automatically if needed for the last row
2735 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2736 if (s->avctx->draw_horiz_band) {
2740 if(s->picture_structure != PICT_FRAME){
2743 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2746 h= FFMIN(h, s->height - y);
2748 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2749 src= (AVFrame*)s->current_picture_ptr;
2750 else if(s->last_picture_ptr)
2751 src= (AVFrame*)s->last_picture_ptr;
2755 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2761 offset[0]= y * s->linesize;;
2763 offset[2]= (y>>1) * s->uvlinesize;;
2769 s->avctx->draw_horiz_band(s->avctx, src, offset,
2770 y, s->picture_structure, h);
2774 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2775 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2776 const int uvlinesize= s->current_picture.linesize[1];
2778 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2779 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
2780 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
2781 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
2782 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
2783 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;
2785 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){
2786 s->dest[0] = s->current_picture.data[0] + s->mb_x * 16 - 16;
2787 s->dest[1] = s->current_picture.data[1] + s->mb_x * 8 - 8;
2788 s->dest[2] = s->current_picture.data[2] + s->mb_x * 8 - 8;
2790 s->dest[0] = s->current_picture.data[0] + (s->mb_y * 16* linesize ) + s->mb_x * 16 - 16;
2791 s->dest[1] = s->current_picture.data[1] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2792 s->dest[2] = s->current_picture.data[2] + (s->mb_y * 8 * uvlinesize) + s->mb_x * 8 - 8;
2796 #ifdef CONFIG_ENCODERS
2798 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2800 const int mb_x= s->mb_x;
2801 const int mb_y= s->mb_y;
2804 int dct_offset = s->linesize*8; //default for progressive frames
2806 for(i=0; i<6; i++) skip_dct[i]=0;
2808 if(s->adaptive_quant){
2809 s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2811 if(s->out_format==FMT_H263){
2812 if (s->dquant> 2) s->dquant= 2;
2813 else if(s->dquant<-2) s->dquant=-2;
2816 if(s->codec_id==CODEC_ID_MPEG4){
2818 if(s->mv_dir&MV_DIRECT)
2821 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2824 s->qscale+= s->dquant;
2825 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2826 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2834 wrap_y = s->linesize;
2835 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2837 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2838 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2839 ptr= s->edge_emu_buffer;
2843 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2844 int progressive_score, interlaced_score;
2846 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2847 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
2849 if(progressive_score > interlaced_score + 100){
2850 s->interlaced_dct=1;
2855 s->interlaced_dct=0;
2858 s->dsp.get_pixels(s->block[0], ptr , wrap_y);
2859 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y);
2860 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y);
2861 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2863 if(s->flags&CODEC_FLAG_GRAY){
2867 int wrap_c = s->uvlinesize;
2868 ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2870 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);
2871 ptr= s->edge_emu_buffer;
2873 s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2875 ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2877 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);
2878 ptr= s->edge_emu_buffer;
2880 s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2883 op_pixels_func (*op_pix)[4];
2884 qpel_mc_func (*op_qpix)[16];
2885 uint8_t *dest_y, *dest_cb, *dest_cr;
2886 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2890 dest_y = s->dest[0];
2891 dest_cb = s->dest[1];
2892 dest_cr = s->dest[2];
2893 wrap_y = s->linesize;
2894 wrap_c = s->uvlinesize;
2895 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2896 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2897 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2899 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2900 op_pix = s->dsp.put_pixels_tab;
2901 op_qpix= s->dsp.put_qpel_pixels_tab;
2903 op_pix = s->dsp.put_no_rnd_pixels_tab;
2904 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2907 if (s->mv_dir & MV_DIR_FORWARD) {
2908 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2909 op_pix = s->dsp.avg_pixels_tab;
2910 op_qpix= s->dsp.avg_qpel_pixels_tab;
2912 if (s->mv_dir & MV_DIR_BACKWARD) {
2913 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2916 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2917 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2918 ptr_y= s->edge_emu_buffer;
2922 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2923 int progressive_score, interlaced_score;
2925 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
2926 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
2927 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
2928 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
2930 if(progressive_score > interlaced_score + 600){
2931 s->interlaced_dct=1;
2936 s->interlaced_dct=0;
2939 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
2940 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2941 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
2942 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2944 if(s->flags&CODEC_FLAG_GRAY){
2949 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);
2950 ptr_cb= s->edge_emu_buffer;
2952 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2954 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);
2955 ptr_cr= s->edge_emu_buffer;
2957 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2959 /* pre quantization */
2960 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2962 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2963 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2964 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2965 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2966 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2967 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2973 if(skip_dct[i]) num++;
2976 if(s->mb_x==0 && s->mb_y==0){
2978 printf("%6d %1d\n", stat[i], i);
2991 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2992 ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2994 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2995 (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P',
2996 s->qscale, adap_parm, s->qscale*adap_parm,
2997 s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
3000 /* DCT & quantize */
3001 if(s->out_format==FMT_MJPEG){
3004 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
3005 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3011 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3012 // FIXME we could decide to change to quantizer instead of clipping
3013 // JS: I don't think that would be a good idea it could lower quality instead
3014 // of improve it. Just INTRADC clipping deserves changes in quantizer
3015 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3017 s->block_last_index[i]= -1;
3019 if(s->luma_elim_threshold && !s->mb_intra)
3021 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3022 if(s->chroma_elim_threshold && !s->mb_intra)
3024 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3027 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3028 s->block_last_index[4]=
3029 s->block_last_index[5]= 0;
3031 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
3034 /* huffman encode */
3035 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
3036 case CODEC_ID_MPEG1VIDEO:
3037 case CODEC_ID_MPEG2VIDEO:
3038 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
3040 case CODEC_ID_MPEG4:
3041 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3042 case CODEC_ID_MSMPEG4V2:
3043 case CODEC_ID_MSMPEG4V3:
3045 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3047 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3049 case CODEC_ID_H263P:
3052 h263_encode_mb(s, s->block, motion_x, motion_y); break;
3054 case CODEC_ID_MJPEG:
3055 mjpeg_encode_mb(s, s->block); break;
3061 #endif //CONFIG_ENCODERS
3064 * combines the (truncated) bitstream to a complete frame
3065 * @returns -1 if no complete frame could be created
3067 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3068 ParseContext *pc= &s->parse_context;
3072 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3073 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3077 /* copy overreaded byes from last frame into buffer */
3078 for(; pc->overread>0; pc->overread--){
3079 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3082 pc->last_index= pc->index;
3084 /* copy into buffer end return */
3085 if(next == END_NOT_FOUND){
3086 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3088 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3089 pc->index += *buf_size;
3094 pc->overread_index= pc->index + next;
3096 /* append to buffer */
3098 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3100 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3105 /* store overread bytes */
3106 for(;next < 0; next++){
3107 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3113 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3114 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3121 void ff_mpeg_flush(AVCodecContext *avctx){
3123 MpegEncContext *s = avctx->priv_data;
3125 for(i=0; i<MAX_PICTURE_COUNT; i++){
3126 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
3127 || s->picture[i].type == FF_BUFFER_TYPE_USER))
3128 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
3130 s->last_picture_ptr = s->next_picture_ptr = NULL;
3132 s->parse_context.state= -1;
3133 s->parse_context.frame_start_found= 0;
3134 s->parse_context.overread= 0;
3135 s->parse_context.overread_index= 0;
3136 s->parse_context.index= 0;
3137 s->parse_context.last_index= 0;
3140 #ifdef CONFIG_ENCODERS
3141 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3143 int bytes= length>>4;
3144 int bits= length&15;
3147 if(length==0) return;
3149 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3150 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3153 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3156 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3159 d->mb_skip_run= s->mb_skip_run;
3161 d->last_dc[i]= s->last_dc[i];
3164 d->mv_bits= s->mv_bits;
3165 d->i_tex_bits= s->i_tex_bits;
3166 d->p_tex_bits= s->p_tex_bits;
3167 d->i_count= s->i_count;
3168 d->f_count= s->f_count;
3169 d->b_count= s->b_count;
3170 d->skip_count= s->skip_count;
3171 d->misc_bits= s->misc_bits;
3175 d->qscale= s->qscale;
3178 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3181 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
3182 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3185 d->mb_skip_run= s->mb_skip_run;
3187 d->last_dc[i]= s->last_dc[i];
3190 d->mv_bits= s->mv_bits;
3191 d->i_tex_bits= s->i_tex_bits;
3192 d->p_tex_bits= s->p_tex_bits;
3193 d->i_count= s->i_count;
3194 d->f_count= s->f_count;
3195 d->b_count= s->b_count;
3196 d->skip_count= s->skip_count;
3197 d->misc_bits= s->misc_bits;
3199 d->mb_intra= s->mb_intra;
3200 d->mb_skiped= s->mb_skiped;
3201 d->mv_type= s->mv_type;
3202 d->mv_dir= s->mv_dir;
3204 if(s->data_partitioning){
3206 d->tex_pb= s->tex_pb;
3210 d->block_last_index[i]= s->block_last_index[i];
3211 d->interlaced_dct= s->interlaced_dct;
3212 d->qscale= s->qscale;
3215 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
3216 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3217 int *dmin, int *next_block, int motion_x, int motion_y)
3220 uint8_t *dest_backup[3];
3222 copy_context_before_encode(s, backup, type);
3224 s->block= s->blocks[*next_block];
3225 s->pb= pb[*next_block];
3226 if(s->data_partitioning){
3227 s->pb2 = pb2 [*next_block];
3228 s->tex_pb= tex_pb[*next_block];
3232 memcpy(dest_backup, s->dest, sizeof(s->dest));
3233 s->dest[0] = s->me.scratchpad;
3234 s->dest[1] = s->me.scratchpad + 16;
3235 s->dest[2] = s->me.scratchpad + 16 + 8;
3236 assert(2*s->uvlinesize == s->linesize); //should be no prob for encoding
3237 assert(s->linesize >= 64); //FIXME
3240 encode_mb(s, motion_x, motion_y);
3242 score= get_bit_count(&s->pb);
3243 if(s->data_partitioning){
3244 score+= get_bit_count(&s->pb2);
3245 score+= get_bit_count(&s->tex_pb);
3248 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
3249 MPV_decode_mb(s, s->block);
3251 score *= s->qscale * s->qscale * 109;
3252 score += sse_mb(s) << 7;
3256 memcpy(s->dest, dest_backup, sizeof(s->dest));
3263 copy_context_after_encode(best, s, type);
3267 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3268 uint32_t *sq = squareTbl + 256;
3273 return s->dsp.sse[0](NULL, src1, src2, stride);
3274 else if(w==8 && h==8)
3275 return s->dsp.sse[1](NULL, src1, src2, stride);
3279 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3288 static int sse_mb(MpegEncContext *s){
3292 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3293 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3296 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)
3297 +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)
3298 +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);
3300 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)
3301 +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)
3302 +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);
3305 static void encode_picture(MpegEncContext *s, int picture_number)
3307 int mb_x, mb_y, pdif = 0;
3310 MpegEncContext best_s, backup_s;
3311 uint8_t bit_buf[2][3000];
3312 uint8_t bit_buf2[2][3000];
3313 uint8_t bit_buf_tex[2][3000];
3314 PutBitContext pb[2], pb2[2], tex_pb[2];
3317 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
3318 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
3319 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3322 s->picture_number = picture_number;
3324 /* Reset the average MB variance */
3325 s->current_picture.mb_var_sum = 0;
3326 s->current_picture.mc_mb_var_sum = 0;
3329 /* we need to initialize some time vars before we can encode b-frames */
3330 // RAL: Condition added for MPEG1VIDEO
3331 //FIXME figure out why mpeg1/2 need this !!!
3332 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3333 ff_set_mpeg4_time(s, s->picture_number);
3336 s->scene_change_score=0;
3338 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3340 if(s->pict_type==I_TYPE){
3341 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3342 else s->no_rounding=0;
3343 }else if(s->pict_type!=B_TYPE){
3344 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3345 s->no_rounding ^= 1;
3348 /* Estimate motion for every MB */
3349 s->mb_intra=0; //for the rate distoration & bit compare functions
3350 if(s->pict_type != I_TYPE){
3351 if(s->pict_type != B_TYPE){
3352 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3354 s->me.dia_size= s->avctx->pre_dia_size;
3356 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3357 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3360 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3367 s->me.dia_size= s->avctx->dia_size;
3368 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3369 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3370 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3371 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3372 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3373 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3376 s->block_index[0]+=2;
3377 s->block_index[1]+=2;
3378 s->block_index[2]+=2;
3379 s->block_index[3]+=2;
3381 /* compute motion vector & mb_type and store in context */
3382 if(s->pict_type==B_TYPE)
3383 ff_estimate_b_frame_motion(s, mb_x, mb_y);
3385 ff_estimate_p_frame_motion(s, mb_x, mb_y);
3388 }else /* if(s->pict_type == I_TYPE) */{
3390 //FIXME do we need to zero them?
3391 memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3392 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3393 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3395 if(!s->fixed_qscale){
3396 /* finding spatial complexity for I-frame rate control */
3397 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3398 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3401 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3403 int sum = s->dsp.pix_sum(pix, s->linesize);
3405 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3407 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3408 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3409 s->current_picture.mb_var_sum += varc;
3416 if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3417 s->pict_type= I_TYPE;
3418 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3419 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3423 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3424 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3426 ff_fix_long_p_mvs(s);
3429 if(s->pict_type==B_TYPE){
3432 a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3433 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3434 s->f_code = FFMAX(a, b);
3436 a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3437 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3438 s->b_code = FFMAX(a, b);
3440 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3441 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3442 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3443 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3447 if (s->fixed_qscale)
3448 s->frame_qscale = s->current_picture.quality;
3450 s->frame_qscale = ff_rate_estimate_qscale(s);
3452 if(s->adaptive_quant){
3454 switch(s->codec_id){
3455 case CODEC_ID_MPEG4:
3456 ff_clean_mpeg4_qscales(s);
3459 case CODEC_ID_H263P:
3461 ff_clean_h263_qscales(s);
3466 s->qscale= s->current_picture.qscale_table[0];
3468 s->qscale= (int)(s->frame_qscale + 0.5);
3470 if (s->out_format == FMT_MJPEG) {
3471 /* for mjpeg, we do include qscale in the matrix */
3472 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3474 int j= s->dsp.idct_permutation[i];
3476 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3478 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3479 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3482 //FIXME var duplication
3483 s->current_picture.key_frame= s->pict_type == I_TYPE;
3484 s->current_picture.pict_type= s->pict_type;
3486 if(s->current_picture.key_frame)
3487 s->picture_in_gop_number=0;
3489 s->last_bits= get_bit_count(&s->pb);
3490 switch(s->out_format) {
3492 mjpeg_picture_header(s);
3496 if (s->codec_id == CODEC_ID_WMV2)
3497 ff_wmv2_encode_picture_header(s, picture_number);
3498 else if (s->h263_msmpeg4)
3499 msmpeg4_encode_picture_header(s, picture_number);
3500 else if (s->h263_pred)
3501 mpeg4_encode_picture_header(s, picture_number);
3502 else if (s->h263_rv10)
3503 rv10_encode_picture_header(s, picture_number);
3504 else if (s->codec_id == CODEC_ID_FLV1)
3505 ff_flv_encode_picture_header(s, picture_number);
3507 h263_encode_picture_header(s, picture_number);
3511 mpeg1_encode_picture_header(s, picture_number);
3514 bits= get_bit_count(&s->pb);
3515 s->header_bits= bits - s->last_bits;
3527 /* init last dc values */
3528 /* note: quant matrix value (8) is implied here */
3529 s->last_dc[i] = 128;
3531 s->current_picture_ptr->error[i] = 0;
3534 s->last_mv[0][0][0] = 0;
3535 s->last_mv[0][0][1] = 0;
3536 s->last_mv[1][0][0] = 0;
3537 s->last_mv[1][0][1] = 0;
3542 switch(s->codec_id){
3544 case CODEC_ID_H263P:
3546 s->gob_index = ff_h263_get_gob_height(s);
3548 case CODEC_ID_MPEG4:
3549 if(s->partitioned_frame)
3550 ff_mpeg4_init_partitions(s);
3557 s->first_slice_line = 1;
3558 s->ptr_lastgob = s->pb.buf;
3559 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3563 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3564 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3565 ff_init_block_index(s);
3567 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3568 const int xy= mb_y*s->mb_stride + mb_x;
3569 int mb_type= s->mb_type[xy];
3574 ff_update_block_index(s);
3576 /* write gob / video packet header */
3578 if(s->rtp_mode && mb_y + mb_x>0){
3579 int current_packet_size, is_gob_start;
3581 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3584 if(s->codec_id==CODEC_ID_MPEG4){
3585 if(current_packet_size >= s->rtp_payload_size){
3587 if(s->partitioned_frame){
3588 ff_mpeg4_merge_partitions(s);
3589 ff_mpeg4_init_partitions(s);
3591 ff_mpeg4_encode_video_packet_header(s);
3593 if(s->flags&CODEC_FLAG_PASS1){
3594 int bits= get_bit_count(&s->pb);
3595 s->misc_bits+= bits - s->last_bits;
3598 ff_mpeg4_clean_buffers(s);
3601 }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3602 if( current_packet_size >= s->rtp_payload_size
3603 && s->mb_skip_run==0){
3604 ff_mpeg1_encode_slice_header(s);
3605 ff_mpeg1_clean_buffers(s);
3608 }else if(s->codec_id==CODEC_ID_MPEG2VIDEO){
3609 if( ( current_packet_size >= s->rtp_payload_size || mb_x==0)
3610 && s->mb_skip_run==0){
3611 ff_mpeg1_encode_slice_header(s);
3612 ff_mpeg1_clean_buffers(s);
3616 if(current_packet_size >= s->rtp_payload_size
3617 && s->mb_x==0 && s->mb_y%s->gob_index==0){
3619 h263_encode_gob_header(s, mb_y);
3625 s->ptr_lastgob = pbBufPtr(&s->pb);
3626 s->first_slice_line=1;
3627 s->resync_mb_x=mb_x;
3628 s->resync_mb_y=mb_y;
3633 if( (s->resync_mb_x == s->mb_x)
3634 && s->resync_mb_y+1 == s->mb_y){
3635 s->first_slice_line=0;
3640 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3642 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3644 copy_context_before_encode(&backup_s, s, -1);
3646 best_s.data_partitioning= s->data_partitioning;
3647 best_s.partitioned_frame= s->partitioned_frame;
3648 if(s->data_partitioning){
3649 backup_s.pb2= s->pb2;
3650 backup_s.tex_pb= s->tex_pb;
3653 if(mb_type&MB_TYPE_INTER){
3654 s->mv_dir = MV_DIR_FORWARD;
3655 s->mv_type = MV_TYPE_16X16;
3657 s->mv[0][0][0] = s->p_mv_table[xy][0];
3658 s->mv[0][0][1] = s->p_mv_table[xy][1];
3659 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
3660 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3662 if(mb_type&MB_TYPE_INTER4V){
3663 s->mv_dir = MV_DIR_FORWARD;
3664 s->mv_type = MV_TYPE_8X8;
3667 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3668 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3670 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
3671 &dmin, &next_block, 0, 0);
3673 if(mb_type&MB_TYPE_FORWARD){
3674 s->mv_dir = MV_DIR_FORWARD;
3675 s->mv_type = MV_TYPE_16X16;
3677 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3678 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3679 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
3680 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3682 if(mb_type&MB_TYPE_BACKWARD){
3683 s->mv_dir = MV_DIR_BACKWARD;
3684 s->mv_type = MV_TYPE_16X16;
3686 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3687 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3688 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3689 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3691 if(mb_type&MB_TYPE_BIDIR){
3692 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3693 s->mv_type = MV_TYPE_16X16;
3695 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3696 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3697 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3698 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3699 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
3700 &dmin, &next_block, 0, 0);
3702 if(mb_type&MB_TYPE_DIRECT){
3703 int mx= s->b_direct_mv_table[xy][0];
3704 int my= s->b_direct_mv_table[xy][1];
3706 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3709 ff_mpeg4_set_direct_mv(s, mx, my);
3711 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
3712 &dmin, &next_block, mx, my);
3714 if(mb_type&MB_TYPE_INTRA){
3716 s->mv_type = MV_TYPE_16X16;
3720 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3721 &dmin, &next_block, 0, 0);
3722 if(s->h263_pred || s->h263_aic){
3724 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3726 ff_clean_intra_table_entries(s); //old mode?
3729 copy_context_after_encode(s, &best_s, -1);
3731 pb_bits_count= get_bit_count(&s->pb);
3732 flush_put_bits(&s->pb);
3733 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3736 if(s->data_partitioning){
3737 pb2_bits_count= get_bit_count(&s->pb2);
3738 flush_put_bits(&s->pb2);
3739 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3740 s->pb2= backup_s.pb2;
3742 tex_pb_bits_count= get_bit_count(&s->tex_pb);
3743 flush_put_bits(&s->tex_pb);
3744 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3745 s->tex_pb= backup_s.tex_pb;
3747 s->last_bits= get_bit_count(&s->pb);
3749 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3750 ff_h263_update_motion_val(s);
3753 s->dsp.put_pixels_tab[0][0](s->dest[0], s->me.scratchpad , s->linesize ,16);
3754 s->dsp.put_pixels_tab[1][0](s->dest[1], s->me.scratchpad + 16, s->uvlinesize, 8);
3755 s->dsp.put_pixels_tab[1][0](s->dest[2], s->me.scratchpad + 24, s->uvlinesize, 8);
3758 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3759 MPV_decode_mb(s, s->block);
3761 int motion_x, motion_y;
3763 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3765 if(s->avctx->mb_decision==FF_MB_DECISION_SIMPLE && s->pict_type==P_TYPE){ //FIXME check if the mess is usefull at all
3766 /* get luma score */
3767 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3768 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
3772 int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3775 dest_y = s->new_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
3777 for(i=0; i<16; i++){
3778 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3779 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3780 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3781 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3785 intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3787 /* printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
3788 s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3789 s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3792 /* get chroma score */
3793 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3801 if(s->out_format == FMT_H263){
3802 mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3804 mean= (s->last_dc[i] + 4)>>3;
3806 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3810 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3811 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3814 intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3819 switch(s->avctx->mb_cmp&0xFF){
3822 intra_score+= 32*s->qscale;
3825 intra_score+= 24*s->qscale*s->qscale;
3828 intra_score+= 96*s->qscale;
3831 intra_score+= 48*s->qscale;
3838 intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3842 if(intra_score < inter_score)
3843 mb_type= MB_TYPE_INTRA;
3846 s->mv_type=MV_TYPE_16X16;
3847 // only one MB-Type possible
3853 motion_x= s->mv[0][0][0] = 0;
3854 motion_y= s->mv[0][0][1] = 0;
3857 s->mv_dir = MV_DIR_FORWARD;
3859 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3860 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3862 case MB_TYPE_INTER4V:
3863 s->mv_dir = MV_DIR_FORWARD;
3864 s->mv_type = MV_TYPE_8X8;
3867 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3868 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3870 motion_x= motion_y= 0;
3872 case MB_TYPE_DIRECT:
3873 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3875 motion_x=s->b_direct_mv_table[xy][0];
3876 motion_y=s->b_direct_mv_table[xy][1];
3878 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3882 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3886 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3887 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3888 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3889 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3891 case MB_TYPE_BACKWARD:
3892 s->mv_dir = MV_DIR_BACKWARD;
3894 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3895 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3897 case MB_TYPE_FORWARD:
3898 s->mv_dir = MV_DIR_FORWARD;
3900 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3901 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3902 // printf(" %d %d ", motion_x, motion_y);
3905 motion_x=motion_y=0; //gcc warning fix
3906 printf("illegal MB type\n");
3909 encode_mb(s, motion_x, motion_y);
3911 // RAL: Update last macrobloc type
3912 s->last_mv_dir = s->mv_dir;
3914 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
3915 ff_h263_update_motion_val(s);
3917 MPV_decode_mb(s, s->block);
3920 /* clean the MV table in IPS frames for direct mode in B frames */
3921 if(s->mb_intra /* && I,P,S_TYPE */){
3922 s->p_mv_table[xy][0]=0;
3923 s->p_mv_table[xy][1]=0;
3926 if(s->flags&CODEC_FLAG_PSNR){
3930 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3931 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3933 s->current_picture_ptr->error[0] += sse(
3934 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3935 s->dest[0], w, h, s->linesize);
3936 s->current_picture_ptr->error[1] += sse(
3937 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3938 s->dest[1], w>>1, h>>1, s->uvlinesize);
3939 s->current_picture_ptr->error[2] += sse(
3940 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3941 s->dest[2], w>>1, h>>1, s->uvlinesize);
3943 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3949 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3950 ff_mpeg4_merge_partitions(s);
3952 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3953 msmpeg4_encode_ext_header(s);
3955 if(s->codec_id==CODEC_ID_MPEG4)
3956 ff_mpeg4_stuffing(&s->pb);
3959 //if (s->gob_number)
3960 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3962 /* Send the last GOB if RTP */
3964 flush_put_bits(&s->pb);
3965 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3966 /* Call the RTP callback to send the last GOB */
3967 if (s->rtp_callback)
3968 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3969 s->ptr_lastgob = pbBufPtr(&s->pb);
3970 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3974 static int dct_quantize_trellis_c(MpegEncContext *s,
3975 DCTELEM *block, int n,
3976 int qscale, int *overflow){
3978 const uint8_t *scantable= s->intra_scantable.scantable;
3980 unsigned int threshold1, threshold2;
3990 int coeff_count[64];
3991 int lambda, qmul, qadd, start_i, last_non_zero, i;
3992 const int esc_length= s->ac_esc_length;
3994 uint8_t * last_length;
3998 s->dsp.fdct (block);
4001 qadd= ((qscale-1)|1)*8;
4012 /* For AIC we skip quant/dequant of INTRADC */
4017 /* note: block[0] is assumed to be positive */
4018 block[0] = (block[0] + (q >> 1)) / q;
4021 qmat = s->q_intra_matrix[qscale];
4022 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4023 bias= 1<<(QMAT_SHIFT-1);
4024 length = s->intra_ac_vlc_length;
4025 last_length= s->intra_ac_vlc_last_length;
4029 qmat = s->q_inter_matrix[qscale];
4030 length = s->inter_ac_vlc_length;
4031 last_length= s->inter_ac_vlc_last_length;
4034 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4035 threshold2= (threshold1<<1);
4037 for(i=start_i; i<64; i++) {
4038 const int j = scantable[i];
4039 const int k= i-start_i;
4040 int level = block[j];
4041 level = level * qmat[j];
4043 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
4044 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
4045 if(((unsigned)(level+threshold1))>threshold2){
4047 level= (bias + level)>>QMAT_SHIFT;
4049 coeff[1][k]= level-1;
4050 // coeff[2][k]= level-2;
4052 level= (bias - level)>>QMAT_SHIFT;
4053 coeff[0][k]= -level;
4054 coeff[1][k]= -level+1;
4055 // coeff[2][k]= -level+2;
4057 coeff_count[k]= FFMIN(level, 2);
4061 coeff[0][k]= (level>>31)|1;
4066 *overflow= s->max_qcoeff < max; //overflow might have happend
4068 if(last_non_zero < start_i){
4069 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4070 return last_non_zero;
4073 lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune