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 #endif //CONFIG_ENCODERS
55 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
58 /* enable all paranoid tests for rounding, overflows, etc... */
64 /* for jpeg fast DCT */
67 static const uint16_t aanscales[64] = {
68 /* precomputed values scaled up by 14 bits */
69 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
70 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
71 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
72 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
73 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
74 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
75 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
76 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
79 static const uint8_t h263_chroma_roundtab[16] = {
80 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
81 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
84 #ifdef CONFIG_ENCODERS
85 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
86 static uint8_t default_fcode_tab[MAX_MV*2+1];
88 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
90 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
91 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
95 for(qscale=qmin; qscale<=qmax; qscale++){
97 if (s->dsp.fdct == ff_jpeg_fdct_islow) {
99 const int j= s->dsp.idct_permutation[i];
100 /* 16 <= qscale * quant_matrix[i] <= 7905 */
101 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
102 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
103 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
105 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
106 (qscale * quant_matrix[j]));
108 } else if (s->dsp.fdct == fdct_ifast) {
110 const int j= s->dsp.idct_permutation[i];
111 /* 16 <= qscale * quant_matrix[i] <= 7905 */
112 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
113 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
114 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
116 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
117 (aanscales[i] * qscale * quant_matrix[j]));
121 const int j= s->dsp.idct_permutation[i];
122 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
123 So 16 <= qscale * quant_matrix[i] <= 7905
124 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
125 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
127 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
128 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
129 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
131 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
132 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
137 #endif //CONFIG_ENCODERS
139 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
143 st->scantable= src_scantable;
147 j = src_scantable[i];
148 st->permutated[i] = permutation[j];
157 j = st->permutated[i];
159 st->raster_end[i]= end;
163 /* init common dct for both encoder and decoder */
164 int DCT_common_init(MpegEncContext *s)
166 s->dct_unquantize_h263 = dct_unquantize_h263_c;
167 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
168 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
170 #ifdef CONFIG_ENCODERS
171 s->dct_quantize= dct_quantize_c;
175 MPV_common_init_mmx(s);
178 MPV_common_init_axp(s);
181 MPV_common_init_mlib(s);
184 MPV_common_init_mmi(s);
187 MPV_common_init_armv4l(s);
190 MPV_common_init_ppc(s);
193 #ifdef CONFIG_ENCODERS
194 s->fast_dct_quantize= s->dct_quantize;
196 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
197 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
200 #endif //CONFIG_ENCODERS
202 /* load & permutate scantables
203 note: only wmv uses differnt ones
205 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
206 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
207 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
208 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
210 s->picture_structure= PICT_FRAME;
216 * allocates a Picture
217 * The pixels are allocated/set by calling get_buffer() if shared=0
219 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
220 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
221 const int mb_array_size= s->mb_stride*s->mb_height;
225 assert(pic->data[0]);
226 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
227 pic->type= FF_BUFFER_TYPE_SHARED;
231 assert(!pic->data[0]);
233 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
235 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
236 fprintf(stderr, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
240 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
241 fprintf(stderr, "get_buffer() failed (stride changed)\n");
245 if(pic->linesize[1] != pic->linesize[2]){
246 fprintf(stderr, "get_buffer() failed (uv stride missmatch)\n");
250 s->linesize = pic->linesize[0];
251 s->uvlinesize= pic->linesize[1];
254 if(pic->qscale_table==NULL){
256 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
257 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
258 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
259 CHECKED_ALLOCZ(pic->mb_cmp_score, mb_array_size * sizeof(int32_t))
262 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
263 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
264 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(int))
265 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
266 if(s->out_format == FMT_H264){
268 CHECKED_ALLOCZ(pic->motion_val[i], 2 * 16 * s->mb_num * sizeof(uint16_t))
269 CHECKED_ALLOCZ(pic->ref_index[i] , 4 * s->mb_num * sizeof(uint8_t))
272 pic->qstride= s->mb_stride;
275 //it might be nicer if the application would keep track of these but it would require a API change
276 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
277 s->prev_pict_types[0]= s->pict_type;
278 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
279 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
282 fail: //for the CHECKED_ALLOCZ macro
287 * deallocates a picture
289 static void free_picture(MpegEncContext *s, Picture *pic){
292 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
293 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
296 av_freep(&pic->mb_var);
297 av_freep(&pic->mc_mb_var);
298 av_freep(&pic->mb_mean);
299 av_freep(&pic->mb_cmp_score);
300 av_freep(&pic->mbskip_table);
301 av_freep(&pic->qscale_table);
302 av_freep(&pic->mb_type_base);
305 av_freep(&pic->motion_val[i]);
306 av_freep(&pic->ref_index[i]);
309 if(pic->type == FF_BUFFER_TYPE_SHARED){
318 /* init common structure for both encoder and decoder */
319 int MPV_common_init(MpegEncContext *s)
321 int y_size, c_size, yc_size, i, mb_array_size, x, y;
323 dsputil_init(&s->dsp, s->avctx);
326 s->flags= s->avctx->flags;
328 s->mb_width = (s->width + 15) / 16;
329 s->mb_height = (s->height + 15) / 16;
330 s->mb_stride = s->mb_width + 1;
331 mb_array_size= s->mb_height * s->mb_stride;
333 /* set default edge pos, will be overriden in decode_header if needed */
334 s->h_edge_pos= s->mb_width*16;
335 s->v_edge_pos= s->mb_height*16;
337 s->mb_num = s->mb_width * s->mb_height;
342 s->block_wrap[3]= s->mb_width*2 + 2;
344 s->block_wrap[5]= s->mb_width + 2;
346 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
347 c_size = (s->mb_width + 2) * (s->mb_height + 2);
348 yc_size = y_size + 2 * c_size;
350 /* convert fourcc to upper case */
351 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
352 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
353 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
354 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
356 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
357 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
359 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
361 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
362 for(y=0; y<s->mb_height; y++){
363 for(x=0; x<s->mb_width; x++){
364 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
367 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
370 int mv_table_size= s->mb_stride * (s->mb_height+2) + 1;
372 /* Allocate MV tables */
373 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
374 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
375 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
376 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
377 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
378 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
379 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
380 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
381 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
382 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
383 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
384 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
386 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
387 CHECKED_ALLOCZ(s->me.scratchpad, s->width*2*16*3*sizeof(uint8_t))
389 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
390 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
392 if(s->codec_id==CODEC_ID_MPEG4){
393 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
394 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
397 if(s->msmpeg4_version){
398 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
400 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
402 /* Allocate MB type table */
403 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint8_t)) //needed for encoding
406 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
408 if (s->out_format == FMT_H263 || s->encoding) {
412 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
413 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(int16_t));
416 if(s->codec_id==CODEC_ID_MPEG4){
417 /* interlaced direct mode decoding tables */
418 CHECKED_ALLOCZ(s->field_mv_table, mb_array_size*2*2 * sizeof(int16_t))
419 CHECKED_ALLOCZ(s->field_select_table, mb_array_size*2* sizeof(int8_t))
421 if (s->out_format == FMT_H263) {
423 CHECKED_ALLOCZ(s->ac_val[0], yc_size * sizeof(int16_t) * 16);
424 s->ac_val[1] = s->ac_val[0] + y_size;
425 s->ac_val[2] = s->ac_val[1] + c_size;
428 CHECKED_ALLOCZ(s->coded_block, y_size);
430 /* divx501 bitstream reorder buffer */
431 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
433 /* cbp, ac_pred, pred_dir */
434 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
435 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
438 if (s->h263_pred || s->h263_plus || !s->encoding) {
440 //MN: we need these for error resilience of intra-frames
441 CHECKED_ALLOCZ(s->dc_val[0], yc_size * sizeof(int16_t));
442 s->dc_val[1] = s->dc_val[0] + y_size;
443 s->dc_val[2] = s->dc_val[1] + c_size;
444 for(i=0;i<yc_size;i++)
445 s->dc_val[0][i] = 1024;
448 /* which mb is a intra block */
449 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
450 memset(s->mbintra_table, 1, mb_array_size);
452 /* default structure is frame */
453 s->picture_structure = PICT_FRAME;
455 /* init macroblock skip table */
456 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
457 //Note the +1 is for a quicker mpeg4 slice_end detection
458 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
460 s->block= s->blocks[0];
462 s->parse_context.state= -1;
464 s->context_initialized = 1;
474 /* init common structure for both encoder and decoder */
475 void MPV_common_end(MpegEncContext *s)
479 av_freep(&s->parse_context.buffer);
480 s->parse_context.buffer_size=0;
482 av_freep(&s->mb_type);
483 av_freep(&s->p_mv_table_base);
484 av_freep(&s->b_forw_mv_table_base);
485 av_freep(&s->b_back_mv_table_base);
486 av_freep(&s->b_bidir_forw_mv_table_base);
487 av_freep(&s->b_bidir_back_mv_table_base);
488 av_freep(&s->b_direct_mv_table_base);
490 s->b_forw_mv_table= NULL;
491 s->b_back_mv_table= NULL;
492 s->b_bidir_forw_mv_table= NULL;
493 s->b_bidir_back_mv_table= NULL;
494 s->b_direct_mv_table= NULL;
496 av_freep(&s->motion_val);
497 av_freep(&s->dc_val[0]);
498 av_freep(&s->ac_val[0]);
499 av_freep(&s->coded_block);
500 av_freep(&s->mbintra_table);
501 av_freep(&s->cbp_table);
502 av_freep(&s->pred_dir_table);
503 av_freep(&s->me.scratchpad);
504 av_freep(&s->me.map);
505 av_freep(&s->me.score_map);
507 av_freep(&s->mbskip_table);
508 av_freep(&s->prev_pict_types);
509 av_freep(&s->bitstream_buffer);
510 av_freep(&s->tex_pb_buffer);
511 av_freep(&s->pb2_buffer);
512 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
513 av_freep(&s->field_mv_table);
514 av_freep(&s->field_select_table);
515 av_freep(&s->avctx->stats_out);
516 av_freep(&s->ac_stats);
517 av_freep(&s->error_status_table);
518 av_freep(&s->mb_index2xy);
520 for(i=0; i<MAX_PICTURE_COUNT; i++){
521 free_picture(s, &s->picture[i]);
523 avcodec_default_free_buffers(s->avctx);
524 s->context_initialized = 0;
527 #ifdef CONFIG_ENCODERS
529 /* init video encoder */
530 int MPV_encode_init(AVCodecContext *avctx)
532 MpegEncContext *s = avctx->priv_data;
534 int chroma_h_shift, chroma_v_shift;
536 s->bit_rate = avctx->bit_rate;
537 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
538 s->width = avctx->width;
539 s->height = avctx->height;
540 if(avctx->gop_size > 600){
541 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
544 s->gop_size = avctx->gop_size;
545 s->rtp_mode = avctx->rtp_mode;
546 s->rtp_payload_size = avctx->rtp_payload_size;
547 if (avctx->rtp_callback)
548 s->rtp_callback = avctx->rtp_callback;
549 s->max_qdiff= avctx->max_qdiff;
550 s->qcompress= avctx->qcompress;
551 s->qblur= avctx->qblur;
553 s->flags= avctx->flags;
554 s->max_b_frames= avctx->max_b_frames;
555 s->b_frame_strategy= avctx->b_frame_strategy;
556 s->codec_id= avctx->codec->id;
557 s->luma_elim_threshold = avctx->luma_elim_threshold;
558 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
559 s->strict_std_compliance= avctx->strict_std_compliance;
560 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
561 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
562 s->mpeg_quant= avctx->mpeg_quant;
564 if (s->gop_size <= 1) {
571 s->me_method = avctx->me_method;
574 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
576 s->adaptive_quant= ( s->avctx->lumi_masking
577 || s->avctx->dark_masking
578 || s->avctx->temporal_cplx_masking
579 || s->avctx->spatial_cplx_masking
580 || s->avctx->p_masking)
583 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
585 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4){
586 fprintf(stderr, "4MV not supporetd by codec\n");
590 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
591 fprintf(stderr, "qpel not supporetd by codec\n");
595 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
596 fprintf(stderr, "data partitioning not supporetd by codec\n");
600 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO){
601 fprintf(stderr, "b frames not supporetd by codec\n");
605 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
606 fprintf(stderr, "mpeg2 style quantization not supporetd by codec\n");
610 if(s->codec_id==CODEC_ID_MJPEG){
611 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
612 s->inter_quant_bias= 0;
613 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO){
614 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
615 s->inter_quant_bias= 0;
617 s->intra_quant_bias=0;
618 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
621 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
622 s->intra_quant_bias= avctx->intra_quant_bias;
623 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
624 s->inter_quant_bias= avctx->inter_quant_bias;
626 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
628 switch(avctx->codec->id) {
629 case CODEC_ID_MPEG1VIDEO:
630 s->out_format = FMT_MPEG1;
631 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
632 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
636 s->out_format = FMT_MJPEG;
637 s->intra_only = 1; /* force intra only for jpeg */
638 s->mjpeg_write_tables = 1; /* write all tables */
639 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
640 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
641 s->mjpeg_vsample[1] = 1;
642 s->mjpeg_vsample[2] = 1;
643 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
644 s->mjpeg_hsample[1] = 1;
645 s->mjpeg_hsample[2] = 1;
646 if (mjpeg_init(s) < 0)
653 if (h263_get_picture_format(s->width, s->height) == 7) {
654 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
657 s->out_format = FMT_H263;
662 s->out_format = FMT_H263;
665 s->unrestricted_mv=(avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
666 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
668 /* These are just to be sure */
674 s->out_format = FMT_H263;
675 s->h263_flv = 2; /* format = 1; 11-bit codes */
676 s->unrestricted_mv = 1;
677 s->rtp_mode=0; /* don't allow GOB */
682 s->out_format = FMT_H263;
688 s->out_format = FMT_H263;
690 s->unrestricted_mv = 1;
691 s->low_delay= s->max_b_frames ? 0 : 1;
692 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
694 case CODEC_ID_MSMPEG4V1:
695 s->out_format = FMT_H263;
698 s->unrestricted_mv = 1;
699 s->msmpeg4_version= 1;
703 case CODEC_ID_MSMPEG4V2:
704 s->out_format = FMT_H263;
707 s->unrestricted_mv = 1;
708 s->msmpeg4_version= 2;
712 case CODEC_ID_MSMPEG4V3:
713 s->out_format = FMT_H263;
716 s->unrestricted_mv = 1;
717 s->msmpeg4_version= 3;
718 s->flipflop_rounding=1;
723 s->out_format = FMT_H263;
726 s->unrestricted_mv = 1;
727 s->msmpeg4_version= 4;
728 s->flipflop_rounding=1;
733 s->out_format = FMT_H263;
736 s->unrestricted_mv = 1;
737 s->msmpeg4_version= 5;
738 s->flipflop_rounding=1;
747 { /* set up some save defaults, some codecs might override them later */
753 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
754 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
755 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
757 for(i=-16; i<16; i++){
758 default_fcode_tab[i + MAX_MV]= 1;
762 s->me.mv_penalty= default_mv_penalty;
763 s->fcode_tab= default_fcode_tab;
765 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
767 /* dont use mv_penalty table for crap MV as it would be confused */
768 //FIXME remove after fixing / removing old ME
769 if (s->me_method < ME_EPZS) s->me.mv_penalty = default_mv_penalty;
774 if (MPV_common_init(s) < 0)
779 #ifdef CONFIG_ENCODERS
781 if (s->out_format == FMT_H263)
783 if(s->msmpeg4_version)
784 ff_msmpeg4_encode_init(s);
786 if (s->out_format == FMT_MPEG1)
787 ff_mpeg1_encode_init(s);
790 /* init default q matrix */
792 int j= s->dsp.idct_permutation[i];
794 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
795 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
796 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
797 }else if(s->out_format == FMT_H263){
799 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
803 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
804 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
808 /* precompute matrix */
809 /* for mjpeg, we do include qscale in the matrix */
810 if (s->out_format != FMT_MJPEG) {
811 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
812 s->intra_matrix, s->intra_quant_bias, 1, 31);
813 convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
814 s->inter_matrix, s->inter_quant_bias, 1, 31);
817 if(ff_rate_control_init(s) < 0)
820 s->picture_number = 0;
821 s->picture_in_gop_number = 0;
822 s->fake_picture_number = 0;
823 /* motion detector init */
830 int MPV_encode_end(AVCodecContext *avctx)
832 MpegEncContext *s = avctx->priv_data;
838 ff_rate_control_uninit(s);
841 if (s->out_format == FMT_MJPEG)
847 #endif //CONFIG_ENCODERS
849 void init_rl(RLTable *rl)
851 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
852 uint8_t index_run[MAX_RUN+1];
853 int last, run, level, start, end, i;
855 /* compute max_level[], max_run[] and index_run[] */
856 for(last=0;last<2;last++) {
865 memset(max_level, 0, MAX_RUN + 1);
866 memset(max_run, 0, MAX_LEVEL + 1);
867 memset(index_run, rl->n, MAX_RUN + 1);
868 for(i=start;i<end;i++) {
869 run = rl->table_run[i];
870 level = rl->table_level[i];
871 if (index_run[run] == rl->n)
873 if (level > max_level[run])
874 max_level[run] = level;
875 if (run > max_run[level])
876 max_run[level] = run;
878 rl->max_level[last] = av_malloc(MAX_RUN + 1);
879 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
880 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
881 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
882 rl->index_run[last] = av_malloc(MAX_RUN + 1);
883 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
887 /* draw the edges of width 'w' of an image of size width, height */
888 //FIXME check that this is ok for mpeg4 interlaced
889 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
891 uint8_t *ptr, *last_line;
894 last_line = buf + (height - 1) * wrap;
897 memcpy(buf - (i + 1) * wrap, buf, width);
898 memcpy(last_line + (i + 1) * wrap, last_line, width);
902 for(i=0;i<height;i++) {
903 memset(ptr - w, ptr[0], w);
904 memset(ptr + width, ptr[width-1], w);
909 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
910 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
911 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
912 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
916 static int find_unused_picture(MpegEncContext *s, int shared){
920 for(i=0; i<MAX_PICTURE_COUNT; i++){
921 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) break;
924 for(i=0; i<MAX_PICTURE_COUNT; i++){
925 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) break; //FIXME
927 for(i=0; i<MAX_PICTURE_COUNT; i++){
928 if(s->picture[i].data[0]==NULL) break;
932 assert(i<MAX_PICTURE_COUNT);
936 /* generic function for encode/decode called before a frame is coded/decoded */
937 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
944 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
946 /* mark&release old frames */
947 if (s->pict_type != B_TYPE && s->last_picture_ptr) {
948 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
950 /* release forgotten pictures */
951 /* if(mpeg124/h263) */
953 for(i=0; i<MAX_PICTURE_COUNT; i++){
954 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
955 fprintf(stderr, "releasing zombie picture\n");
956 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
963 /* release non refernce frames */
964 for(i=0; i<MAX_PICTURE_COUNT; i++){
965 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
966 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
970 i= find_unused_picture(s, 0);
972 pic= (AVFrame*)&s->picture[i];
973 pic->reference= s->pict_type != B_TYPE ? 3 : 0;
975 if(s->current_picture_ptr)
976 pic->coded_picture_number= s->current_picture_ptr->coded_picture_number+1;
978 alloc_picture(s, (Picture*)pic, 0);
980 s->current_picture_ptr= &s->picture[i];
983 s->current_picture_ptr->pict_type= s->pict_type;
984 s->current_picture_ptr->quality= s->qscale;
985 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
987 s->current_picture= *s->current_picture_ptr;
989 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
990 if (s->pict_type != B_TYPE) {
991 s->last_picture_ptr= s->next_picture_ptr;
992 s->next_picture_ptr= s->current_picture_ptr;
995 if(s->last_picture_ptr) s->last_picture= *s->last_picture_ptr;
996 if(s->next_picture_ptr) s->next_picture= *s->next_picture_ptr;
997 if(s->new_picture_ptr ) s->new_picture = *s->new_picture_ptr;
999 if(s->picture_structure!=PICT_FRAME){
1002 if(s->picture_structure == PICT_BOTTOM_FIELD){
1003 s->current_picture.data[i] += s->current_picture.linesize[i];
1005 s->current_picture.linesize[i] *= 2;
1006 s->last_picture.linesize[i] *=2;
1007 s->next_picture.linesize[i] *=2;
1011 if(s->pict_type != I_TYPE && s->last_picture_ptr==NULL){
1012 fprintf(stderr, "warning: first frame is no keyframe\n");
1013 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1018 s->hurry_up= s->avctx->hurry_up;
1019 s->error_resilience= avctx->error_resilience;
1021 /* set dequantizer, we cant do it during init as it might change for mpeg4
1022 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1023 if(s->out_format == FMT_H263){
1025 s->dct_unquantize = s->dct_unquantize_mpeg2;
1027 s->dct_unquantize = s->dct_unquantize_h263;
1029 s->dct_unquantize = s->dct_unquantize_mpeg1;
1034 /* generic function for encode/decode called after a frame has been coded/decoded */
1035 void MPV_frame_end(MpegEncContext *s)
1038 /* draw edge for correct motion prediction if outside */
1039 if(s->codec_id!=CODEC_ID_SVQ1 && s->codec_id != CODEC_ID_MPEG1VIDEO){
1040 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1041 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1042 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1043 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1048 s->last_pict_type = s->pict_type;
1049 if(s->pict_type!=B_TYPE){
1050 s->last_non_b_pict_type= s->pict_type;
1053 /* copy back current_picture variables */
1054 for(i=0; i<MAX_PICTURE_COUNT; i++){
1055 if(s->picture[i].data[0] == s->current_picture.data[0]){
1056 s->picture[i]= s->current_picture;
1060 assert(i<MAX_PICTURE_COUNT);
1064 /* release non refernce frames */
1065 for(i=0; i<MAX_PICTURE_COUNT; i++){
1066 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1067 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1071 // clear copies, to avoid confusion
1073 memset(&s->last_picture, 0, sizeof(Picture));
1074 memset(&s->next_picture, 0, sizeof(Picture));
1075 memset(&s->current_picture, 0, sizeof(Picture));
1080 * draws an line from (ex, ey) -> (sx, sy).
1081 * @param w width of the image
1082 * @param h height of the image
1083 * @param stride stride/linesize of the image
1084 * @param color color of the arrow
1086 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1089 sx= clip(sx, 0, w-1);
1090 sy= clip(sy, 0, h-1);
1091 ex= clip(ex, 0, w-1);
1092 ey= clip(ey, 0, h-1);
1094 buf[sy*stride + sx]+= color;
1096 if(ABS(ex - sx) > ABS(ey - sy)){
1101 buf+= sx + sy*stride;
1103 f= ((ey-sy)<<16)/ex;
1104 for(x= 0; x <= ex; x++){
1105 y= ((x*f) + (1<<15))>>16;
1106 buf[y*stride + x]+= color;
1113 buf+= sx + sy*stride;
1115 if(ey) f= ((ex-sx)<<16)/ey;
1117 for(y= 0; y <= ey; y++){
1118 x= ((y*f) + (1<<15))>>16;
1119 buf[y*stride + x]+= color;
1125 * draws an arrow from (ex, ey) -> (sx, sy).
1126 * @param w width of the image
1127 * @param h height of the image
1128 * @param stride stride/linesize of the image
1129 * @param color color of the arrow
1131 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1134 sx= clip(sx, -100, w+100);
1135 sy= clip(sy, -100, h+100);
1136 ex= clip(ex, -100, w+100);
1137 ey= clip(ey, -100, h+100);
1142 if(dx*dx + dy*dy > 3*3){
1145 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1147 //FIXME subpixel accuracy
1148 rx= ROUNDED_DIV(rx*3<<4, length);
1149 ry= ROUNDED_DIV(ry*3<<4, length);
1151 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1152 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1154 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1158 * prints debuging info for the given picture.
1160 void ff_print_debug_info(MpegEncContext *s, Picture *pict){
1162 if(!pict || !pict->mb_type) return;
1164 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1167 for(y=0; y<s->mb_height; y++){
1168 for(x=0; x<s->mb_width; x++){
1169 if(s->avctx->debug&FF_DEBUG_SKIP){
1170 int count= s->mbskip_table[x + y*s->mb_stride];
1171 if(count>9) count=9;
1172 printf("%1d", count);
1174 if(s->avctx->debug&FF_DEBUG_QP){
1175 printf("%2d", pict->qscale_table[x + y*s->mb_stride]);
1177 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1178 int mb_type= pict->mb_type[x + y*s->mb_stride];
1180 //Type & MV direction
1183 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1185 else if(IS_INTRA4x4(mb_type))
1187 else if(IS_INTRA16x16(mb_type))
1189 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1191 else if(IS_DIRECT(mb_type))
1193 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1195 else if(IS_GMC(mb_type))
1197 else if(IS_SKIP(mb_type))
1199 else if(!USES_LIST(mb_type, 1))
1201 else if(!USES_LIST(mb_type, 0))
1204 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1211 else if(IS_16X8(mb_type))
1213 else if(IS_8X16(mb_type))
1215 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1221 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1232 if((s->avctx->debug&FF_DEBUG_VIS_MV) && s->motion_val){
1233 const int shift= 1 + s->quarter_sample;
1235 uint8_t *ptr= pict->data[0];
1236 s->low_delay=0; //needed to see the vectors without trashing the buffers
1238 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1240 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1241 const int mb_index= mb_x + mb_y*s->mb_stride;
1242 if(IS_8X8(s->current_picture.mb_type[mb_index])){
1245 int sx= mb_x*16 + 4 + 8*(i&1);
1246 int sy= mb_y*16 + 4 + 8*(i>>1);
1247 int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);
1248 int mx= (s->motion_val[xy][0]>>shift) + sx;
1249 int my= (s->motion_val[xy][1]>>shift) + sy;
1250 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1253 int sx= mb_x*16 + 8;
1254 int sy= mb_y*16 + 8;
1255 int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);
1256 int mx= (s->motion_val[xy][0]>>shift) + sx;
1257 int my= (s->motion_val[xy][1]>>shift) + sy;
1258 draw_arrow(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);
1260 s->mbskip_table[mb_index]=0;
1266 #ifdef CONFIG_ENCODERS
1268 static int get_sae(uint8_t *src, int ref, int stride){
1272 for(y=0; y<16; y++){
1273 for(x=0; x<16; x++){
1274 acc+= ABS(src[x+y*stride] - ref);
1281 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1288 for(y=0; y<h; y+=16){
1289 for(x=0; x<w; x+=16){
1290 int offset= x + y*stride;
1291 int sad = s->dsp.pix_abs16x16(src + offset, ref + offset, stride);
1292 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1293 int sae = get_sae(src + offset, mean, stride);
1295 acc+= sae + 500 < sad;
1302 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1305 const int encoding_delay= s->max_b_frames;
1308 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1309 if(pic_arg->linesize[0] != s->linesize) direct=0;
1310 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1311 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1313 // printf("%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1316 i= find_unused_picture(s, 1);
1318 pic= (AVFrame*)&s->picture[i];
1322 pic->data[i]= pic_arg->data[i];
1323 pic->linesize[i]= pic_arg->linesize[i];
1325 alloc_picture(s, (Picture*)pic, 1);
1327 i= find_unused_picture(s, 0);
1329 pic= (AVFrame*)&s->picture[i];
1332 alloc_picture(s, (Picture*)pic, 0);
1334 /* the input will be 16 pixels to the right relative to the actual buffer start
1335 * and the current_pic, so the buffer can be reused, yes its not beatifull
1340 if( pic->data[0] == pic_arg->data[0]
1341 && pic->data[1] == pic_arg->data[1]
1342 && pic->data[2] == pic_arg->data[2]){
1345 int h_chroma_shift, v_chroma_shift;
1347 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1350 int src_stride= pic_arg->linesize[i];
1351 int dst_stride= i ? s->uvlinesize : s->linesize;
1352 int h_shift= i ? h_chroma_shift : 0;
1353 int v_shift= i ? v_chroma_shift : 0;
1354 int w= s->width >>h_shift;
1355 int h= s->height>>v_shift;
1356 uint8_t *src= pic_arg->data[i];
1357 uint8_t *dst= pic->data[i];
1359 if(src_stride==dst_stride)
1360 memcpy(dst, src, src_stride*h);
1363 memcpy(dst, src, w);
1371 pic->quality= pic_arg->quality;
1372 pic->pict_type= pic_arg->pict_type;
1373 pic->pts = pic_arg->pts;
1375 if(s->input_picture[encoding_delay])
1376 pic->display_picture_number= s->input_picture[encoding_delay]->display_picture_number + 1;
1378 /* shift buffer entries */
1379 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1380 s->input_picture[i-1]= s->input_picture[i];
1382 s->input_picture[encoding_delay]= (Picture*)pic;
1387 static void select_input_picture(MpegEncContext *s){
1389 const int encoding_delay= s->max_b_frames;
1390 int coded_pic_num=0;
1392 if(s->reordered_input_picture[0])
1393 coded_pic_num= s->reordered_input_picture[0]->coded_picture_number + 1;
1395 for(i=1; i<MAX_PICTURE_COUNT; i++)
1396 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
1397 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
1399 /* set next picture types & ordering */
1400 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
1401 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
1402 s->reordered_input_picture[0]= s->input_picture[0];
1403 s->reordered_input_picture[0]->pict_type= I_TYPE;
1404 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1408 if(s->flags&CODEC_FLAG_PASS2){
1409 for(i=0; i<s->max_b_frames+1; i++){
1410 int pict_num= s->input_picture[0]->display_picture_number + i;
1411 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
1412 s->input_picture[i]->pict_type= pict_type;
1414 if(i + 1 >= s->rc_context.num_entries) break;
1418 if(s->input_picture[0]->pict_type){
1419 /* user selected pict_type */
1420 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
1421 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
1424 if(b_frames > s->max_b_frames){
1425 fprintf(stderr, "warning, too many bframes in a row\n");
1426 b_frames = s->max_b_frames;
1428 }else if(s->b_frame_strategy==0){
1429 b_frames= s->max_b_frames;
1430 }else if(s->b_frame_strategy==1){
1431 for(i=1; i<s->max_b_frames+1; i++){
1432 if(s->input_picture[i]->b_frame_score==0){
1433 s->input_picture[i]->b_frame_score=
1434 get_intra_count(s, s->input_picture[i ]->data[0],
1435 s->input_picture[i-1]->data[0], s->linesize) + 1;
1438 for(i=0; i<s->max_b_frames; i++){
1439 if(s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
1442 b_frames= FFMAX(0, i-1);
1445 for(i=0; i<b_frames+1; i++){
1446 s->input_picture[i]->b_frame_score=0;
1449 fprintf(stderr, "illegal b frame strategy\n");
1454 //static int b_count=0;
1455 //b_count+= b_frames;
1456 //printf("b_frames: %d\n", b_count);
1458 s->reordered_input_picture[0]= s->input_picture[b_frames];
1459 if( s->picture_in_gop_number + b_frames >= s->gop_size
1460 || s->reordered_input_picture[0]->pict_type== I_TYPE)
1461 s->reordered_input_picture[0]->pict_type= I_TYPE;
1463 s->reordered_input_picture[0]->pict_type= P_TYPE;
1464 s->reordered_input_picture[0]->coded_picture_number= coded_pic_num;
1465 for(i=0; i<b_frames; i++){
1467 s->reordered_input_picture[i+1]= s->input_picture[i];
1468 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
1469 s->reordered_input_picture[i+1]->coded_picture_number= coded_pic_num;
1474 if(s->reordered_input_picture[0]){
1475 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
1477 s->new_picture= *s->reordered_input_picture[0];
1479 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
1480 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
1482 int i= find_unused_picture(s, 0);
1483 Picture *pic= &s->picture[i];
1485 /* mark us unused / free shared pic */
1487 s->reordered_input_picture[0]->data[i]= NULL;
1488 s->reordered_input_picture[0]->type= 0;
1490 //FIXME bad, copy * except
1491 pic->pict_type = s->reordered_input_picture[0]->pict_type;
1492 pic->quality = s->reordered_input_picture[0]->quality;
1493 pic->coded_picture_number = s->reordered_input_picture[0]->coded_picture_number;
1494 pic->reference = s->reordered_input_picture[0]->reference;
1496 alloc_picture(s, pic, 0);
1498 s->current_picture_ptr= pic;
1500 // input is not a shared pix -> reuse buffer for current_pix
1502 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
1503 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
1505 s->current_picture_ptr= s->reordered_input_picture[0];
1507 //reverse the +16 we did before storing the input
1508 s->current_picture_ptr->data[i]-=16;
1511 s->current_picture= *s->current_picture_ptr;
1513 s->picture_number= s->new_picture.display_picture_number;
1514 //printf("dpn:%d\n", s->picture_number);
1516 memset(&s->new_picture, 0, sizeof(Picture));
1520 int MPV_encode_picture(AVCodecContext *avctx,
1521 unsigned char *buf, int buf_size, void *data)
1523 MpegEncContext *s = avctx->priv_data;
1524 AVFrame *pic_arg = data;
1527 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
1529 s->picture_in_gop_number++;
1531 load_input_picture(s, pic_arg);
1533 select_input_picture(s);
1536 if(s->new_picture.data[0]){
1538 s->pict_type= s->new_picture.pict_type;
1539 if (s->fixed_qscale){ /* the ratecontrol needs the last qscale so we dont touch it for CBR */
1540 s->qscale= (int)(s->new_picture.quality+0.5);
1544 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
1545 MPV_frame_start(s, avctx);
1547 encode_picture(s, s->picture_number);
1549 avctx->real_pict_num = s->picture_number;
1550 avctx->header_bits = s->header_bits;
1551 avctx->mv_bits = s->mv_bits;
1552 avctx->misc_bits = s->misc_bits;
1553 avctx->i_tex_bits = s->i_tex_bits;
1554 avctx->p_tex_bits = s->p_tex_bits;
1555 avctx->i_count = s->i_count;
1556 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
1557 avctx->skip_count = s->skip_count;
1561 if (s->out_format == FMT_MJPEG)
1562 mjpeg_picture_trailer(s);
1564 if(s->flags&CODEC_FLAG_PASS1)
1565 ff_write_pass1_stats(s);
1568 avctx->error[i] += s->current_picture_ptr->error[i];
1572 s->input_picture_number++;
1574 flush_put_bits(&s->pb);
1575 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
1577 s->total_bits += s->frame_bits;
1578 avctx->frame_bits = s->frame_bits;
1580 return pbBufPtr(&s->pb) - s->pb.buf;
1583 #endif //CONFIG_ENCODERS
1585 static inline void gmc1_motion(MpegEncContext *s,
1586 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1588 uint8_t **ref_picture, int src_offset)
1591 int offset, src_x, src_y, linesize, uvlinesize;
1592 int motion_x, motion_y;
1595 motion_x= s->sprite_offset[0][0];
1596 motion_y= s->sprite_offset[0][1];
1597 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1598 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1599 motion_x<<=(3-s->sprite_warping_accuracy);
1600 motion_y<<=(3-s->sprite_warping_accuracy);
1601 src_x = clip(src_x, -16, s->width);
1602 if (src_x == s->width)
1604 src_y = clip(src_y, -16, s->height);
1605 if (src_y == s->height)
1608 linesize = s->linesize;
1609 uvlinesize = s->uvlinesize;
1611 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1613 dest_y+=dest_offset;
1614 if(s->flags&CODEC_FLAG_EMU_EDGE){
1615 if(src_x<0 || src_y<0 || src_x + 17 >= s->h_edge_pos
1616 || src_y + 17 >= s->v_edge_pos){
1617 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1618 ptr= s->edge_emu_buffer;
1622 if((motion_x|motion_y)&7){
1623 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1624 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
1628 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
1629 if (s->no_rounding){
1630 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
1632 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
1636 if(s->flags&CODEC_FLAG_GRAY) return;
1638 motion_x= s->sprite_offset[1][0];
1639 motion_y= s->sprite_offset[1][1];
1640 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1641 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1642 motion_x<<=(3-s->sprite_warping_accuracy);
1643 motion_y<<=(3-s->sprite_warping_accuracy);
1644 src_x = clip(src_x, -8, s->width>>1);
1645 if (src_x == s->width>>1)
1647 src_y = clip(src_y, -8, s->height>>1);
1648 if (src_y == s->height>>1)
1651 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1652 ptr = ref_picture[1] + offset;
1653 if(s->flags&CODEC_FLAG_EMU_EDGE){
1654 if(src_x<0 || src_y<0 || src_x + 9 >= s->h_edge_pos>>1
1655 || src_y + 9 >= s->v_edge_pos>>1){
1656 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);
1657 ptr= s->edge_emu_buffer;
1661 s->dsp.gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1663 ptr = ref_picture[2] + offset;
1665 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);
1666 ptr= s->edge_emu_buffer;
1668 s->dsp.gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
1673 static inline void gmc_motion(MpegEncContext *s,
1674 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1676 uint8_t **ref_picture, int src_offset)
1679 int linesize, uvlinesize;
1680 const int a= s->sprite_warping_accuracy;
1683 linesize = s->linesize;
1684 uvlinesize = s->uvlinesize;
1686 ptr = ref_picture[0] + src_offset;
1688 dest_y+=dest_offset;
1690 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
1691 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
1693 s->dsp.gmc(dest_y, ptr, linesize, 16,
1696 s->sprite_delta[0][0], s->sprite_delta[0][1],
1697 s->sprite_delta[1][0], s->sprite_delta[1][1],
1698 a+1, (1<<(2*a+1)) - s->no_rounding,
1699 s->h_edge_pos, s->v_edge_pos);
1700 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
1701 ox + s->sprite_delta[0][0]*8,
1702 oy + s->sprite_delta[1][0]*8,
1703 s->sprite_delta[0][0], s->sprite_delta[0][1],
1704 s->sprite_delta[1][0], s->sprite_delta[1][1],
1705 a+1, (1<<(2*a+1)) - s->no_rounding,
1706 s->h_edge_pos, s->v_edge_pos);
1708 if(s->flags&CODEC_FLAG_GRAY) return;
1711 dest_cb+=dest_offset>>1;
1712 dest_cr+=dest_offset>>1;
1714 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
1715 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
1717 ptr = ref_picture[1] + (src_offset>>1);
1718 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
1721 s->sprite_delta[0][0], s->sprite_delta[0][1],
1722 s->sprite_delta[1][0], s->sprite_delta[1][1],
1723 a+1, (1<<(2*a+1)) - s->no_rounding,
1724 s->h_edge_pos>>1, s->v_edge_pos>>1);
1726 ptr = ref_picture[2] + (src_offset>>1);
1727 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
1730 s->sprite_delta[0][0], s->sprite_delta[0][1],
1731 s->sprite_delta[1][0], s->sprite_delta[1][1],
1732 a+1, (1<<(2*a+1)) - s->no_rounding,
1733 s->h_edge_pos>>1, s->v_edge_pos>>1);
1737 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1738 * @param buf destination buffer
1739 * @param src source buffer
1740 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1741 * @param block_w width of block
1742 * @param block_h height of block
1743 * @param src_x x coordinate of the top left sample of the block in the source buffer
1744 * @param src_y y coordinate of the top left sample of the block in the source buffer
1745 * @param w width of the source buffer
1746 * @param h height of the source buffer
1748 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1749 int src_x, int src_y, int w, int h){
1751 int start_y, start_x, end_y, end_x;
1754 src+= (h-1-src_y)*linesize;
1756 }else if(src_y<=-block_h){
1757 src+= (1-block_h-src_y)*linesize;
1763 }else if(src_x<=-block_w){
1764 src+= (1-block_w-src_x);
1768 start_y= FFMAX(0, -src_y);
1769 start_x= FFMAX(0, -src_x);
1770 end_y= FFMIN(block_h, h-src_y);
1771 end_x= FFMIN(block_w, w-src_x);
1773 // copy existing part
1774 for(y=start_y; y<end_y; y++){
1775 for(x=start_x; x<end_x; x++){
1776 buf[x + y*linesize]= src[x + y*linesize];
1781 for(y=0; y<start_y; y++){
1782 for(x=start_x; x<end_x; x++){
1783 buf[x + y*linesize]= buf[x + start_y*linesize];
1788 for(y=end_y; y<block_h; y++){
1789 for(x=start_x; x<end_x; x++){
1790 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1794 for(y=0; y<block_h; y++){
1796 for(x=0; x<start_x; x++){
1797 buf[x + y*linesize]= buf[start_x + y*linesize];
1801 for(x=end_x; x<block_w; x++){
1802 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1808 /* apply one mpeg motion vector to the three components */
1809 static inline void mpeg_motion(MpegEncContext *s,
1810 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1812 uint8_t **ref_picture, int src_offset,
1813 int field_based, op_pixels_func (*pix_op)[4],
1814 int motion_x, int motion_y, int h)
1817 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1820 if(s->quarter_sample)
1826 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1827 src_x = s->mb_x * 16 + (motion_x >> 1);
1828 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1830 /* WARNING: do no forget half pels */
1831 height = s->height >> field_based;
1832 v_edge_pos = s->v_edge_pos >> field_based;
1833 src_x = clip(src_x, -16, s->width);
1834 if (src_x == s->width)
1836 src_y = clip(src_y, -16, height);
1837 if (src_y == height)
1839 linesize = s->current_picture.linesize[0] << field_based;
1840 uvlinesize = s->current_picture.linesize[1] << field_based;
1841 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1842 dest_y += dest_offset;
1844 if(s->flags&CODEC_FLAG_EMU_EDGE){
1845 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1846 || src_y + (motion_y&1) + h > v_edge_pos){
1847 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based, //FIXME linesize? and uv below
1848 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1849 ptr= s->edge_emu_buffer + src_offset;
1853 pix_op[0][dxy](dest_y, ptr, linesize, h);
1855 if(s->flags&CODEC_FLAG_GRAY) return;
1857 if (s->out_format == FMT_H263) {
1859 if ((motion_x & 3) != 0)
1861 if ((motion_y & 3) != 0)
1868 dxy = ((my & 1) << 1) | (mx & 1);
1873 src_x = s->mb_x * 8 + mx;
1874 src_y = s->mb_y * (8 >> field_based) + my;
1875 src_x = clip(src_x, -8, s->width >> 1);
1876 if (src_x == (s->width >> 1))
1878 src_y = clip(src_y, -8, height >> 1);
1879 if (src_y == (height >> 1))
1881 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1882 ptr = ref_picture[1] + offset;
1884 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1885 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1886 ptr= s->edge_emu_buffer + (src_offset >> 1);
1888 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1890 ptr = ref_picture[2] + offset;
1892 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9+field_based,
1893 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1894 ptr= s->edge_emu_buffer + (src_offset >> 1);
1896 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1899 static inline void qpel_motion(MpegEncContext *s,
1900 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1902 uint8_t **ref_picture, int src_offset,
1903 int field_based, op_pixels_func (*pix_op)[4],
1904 qpel_mc_func (*qpix_op)[16],
1905 int motion_x, int motion_y, int h)
1908 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1911 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1912 src_x = s->mb_x * 16 + (motion_x >> 2);
1913 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1915 height = s->height >> field_based;
1916 v_edge_pos = s->v_edge_pos >> field_based;
1917 src_x = clip(src_x, -16, s->width);
1918 if (src_x == s->width)
1920 src_y = clip(src_y, -16, height);
1921 if (src_y == height)
1923 linesize = s->linesize << field_based;
1924 uvlinesize = s->uvlinesize << field_based;
1925 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1926 dest_y += dest_offset;
1927 //printf("%d %d %d\n", src_x, src_y, dxy);
1929 if(s->flags&CODEC_FLAG_EMU_EDGE){
1930 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1931 || src_y + (motion_y&3) + h > v_edge_pos){
1932 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - src_offset, s->linesize, 17, 17+field_based,
1933 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
1934 ptr= s->edge_emu_buffer + src_offset;
1939 qpix_op[0][dxy](dest_y, ptr, linesize);
1941 //damn interlaced mode
1942 //FIXME boundary mirroring is not exactly correct here
1943 qpix_op[1][dxy](dest_y , ptr , linesize);
1944 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1947 if(s->flags&CODEC_FLAG_GRAY) return;
1952 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
1953 static const int rtab[8]= {0,0,1,1,0,0,0,1};
1954 mx= (motion_x>>1) + rtab[motion_x&7];
1955 my= (motion_y>>1) + rtab[motion_y&7];
1956 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
1957 mx= (motion_x>>1)|(motion_x&1);
1958 my= (motion_y>>1)|(motion_y&1);
1966 dxy= (mx&1) | ((my&1)<<1);
1970 src_x = s->mb_x * 8 + mx;
1971 src_y = s->mb_y * (8 >> field_based) + my;
1972 src_x = clip(src_x, -8, s->width >> 1);
1973 if (src_x == (s->width >> 1))
1975 src_y = clip(src_y, -8, height >> 1);
1976 if (src_y == (height >> 1))
1979 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1980 ptr = ref_picture[1] + offset;
1982 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
1983 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1984 ptr= s->edge_emu_buffer + (src_offset >> 1);
1986 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1988 ptr = ref_picture[2] + offset;
1990 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - (src_offset >> 1), s->uvlinesize, 9, 9 + field_based,
1991 src_x, src_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
1992 ptr= s->edge_emu_buffer + (src_offset >> 1);
1994 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1997 inline int ff_h263_round_chroma(int x){
1999 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2002 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2007 * motion compesation of a single macroblock
2009 * @param dest_y luma destination pointer
2010 * @param dest_cb chroma cb/u destination pointer
2011 * @param dest_cr chroma cr/v destination pointer
2012 * @param dir direction (0->forward, 1->backward)
2013 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2014 * @param pic_op halfpel motion compensation function (average or put normally)
2015 * @param pic_op qpel motion compensation function (average or put normally)
2016 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2018 static inline void MPV_motion(MpegEncContext *s,
2019 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2020 int dir, uint8_t **ref_picture,
2021 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2023 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
2025 uint8_t *ptr, *dest;
2031 switch(s->mv_type) {
2035 if(s->real_sprite_warping_points==1){
2036 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
2039 gmc_motion(s, dest_y, dest_cb, dest_cr, 0,
2042 }else if(s->quarter_sample){
2043 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2046 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2048 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
2049 ref_picture, pix_op,
2050 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2054 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2057 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2063 if(s->quarter_sample){
2065 motion_x = s->mv[dir][i][0];
2066 motion_y = s->mv[dir][i][1];
2068 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2069 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
2070 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
2072 /* WARNING: do no forget half pels */
2073 src_x = clip(src_x, -16, s->width);
2074 if (src_x == s->width)
2076 src_y = clip(src_y, -16, s->height);
2077 if (src_y == s->height)
2080 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2081 if(s->flags&CODEC_FLAG_EMU_EDGE){
2082 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
2083 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
2084 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);
2085 ptr= s->edge_emu_buffer;
2088 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2089 qpix_op[1][dxy](dest, ptr, s->linesize);
2091 mx += s->mv[dir][i][0]/2;
2092 my += s->mv[dir][i][1]/2;
2096 motion_x = s->mv[dir][i][0];
2097 motion_y = s->mv[dir][i][1];
2099 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2100 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
2101 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
2103 /* WARNING: do no forget half pels */
2104 src_x = clip(src_x, -16, s->width);
2105 if (src_x == s->width)
2107 src_y = clip(src_y, -16, s->height);
2108 if (src_y == s->height)
2111 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
2112 if(s->flags&CODEC_FLAG_EMU_EDGE){
2113 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
2114 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
2115 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);
2116 ptr= s->edge_emu_buffer;
2119 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
2120 pix_op[1][dxy](dest, ptr, s->linesize, 8);
2122 mx += s->mv[dir][i][0];
2123 my += s->mv[dir][i][1];
2127 if(s->flags&CODEC_FLAG_GRAY) break;
2128 /* In case of 8X8, we construct a single chroma motion vector
2129 with a special rounding */
2130 mx= ff_h263_round_chroma(mx);
2131 my= ff_h263_round_chroma(my);
2132 dxy = ((my & 1) << 1) | (mx & 1);
2136 src_x = mb_x * 8 + mx;
2137 src_y = mb_y * 8 + my;
2138 src_x = clip(src_x, -8, s->width/2);
2139 if (src_x == s->width/2)
2141 src_y = clip(src_y, -8, s->height/2);
2142 if (src_y == s->height/2)
2145 offset = (src_y * (s->uvlinesize)) + src_x;
2146 ptr = ref_picture[1] + offset;
2147 if(s->flags&CODEC_FLAG_EMU_EDGE){
2148 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
2149 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
2150 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);
2151 ptr= s->edge_emu_buffer;
2155 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
2157 ptr = ref_picture[2] + offset;
2159 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);
2160 ptr= s->edge_emu_buffer;
2162 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
2165 if (s->picture_structure == PICT_FRAME) {
2166 if(s->quarter_sample){
2168 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
2169 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2171 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2173 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2174 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2176 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2179 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2180 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
2182 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2184 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2185 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
2187 s->mv[dir][1][0], s->mv[dir][1][1], 8);
2191 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2192 offset= s->field_select[dir][0] ? s->linesize : 0;
2194 ref_picture= s->current_picture.data;
2195 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2198 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2199 ref_picture, offset,
2201 s->mv[dir][0][0], s->mv[dir][0][1], 16);
2206 uint8_t ** ref2picture;
2208 if(s->picture_structure == s->field_select[dir][0] + 1 || s->pict_type == B_TYPE || s->first_field){
2209 ref2picture= ref_picture;
2210 offset= s->field_select[dir][0] ? s->linesize : 0;
2212 ref2picture= s->current_picture.data;
2213 offset= s->field_select[dir][0] ? s->linesize : -s->linesize;
2216 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2217 ref2picture, offset,
2219 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2222 if(s->picture_structure == s->field_select[dir][1] + 1 || s->pict_type == B_TYPE || s->first_field){
2223 ref2picture= ref_picture;
2224 offset= s->field_select[dir][1] ? s->linesize : 0;
2226 ref2picture= s->current_picture.data;
2227 offset= s->field_select[dir][1] ? s->linesize : -s->linesize;
2229 // I know it is ugly but this is the only way to fool emu_edge without rewrite mpeg_motion
2230 mpeg_motion(s, dest_y+16*s->linesize, dest_cb+8*s->uvlinesize, dest_cr+8*s->uvlinesize,
2232 ref2picture, offset,
2234 s->mv[dir][1][0], s->mv[dir][1][1]+16, 8);
2240 op_pixels_func (*dmv_pix_op)[4];
2243 dmv_pix_op = s->dsp.put_pixels_tab;
2245 if(s->picture_structure == PICT_FRAME){
2246 //put top field from top field
2247 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2250 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2251 //put bottom field from bottom field
2252 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2253 ref_picture, s->linesize,
2255 s->mv[dir][0][0], s->mv[dir][0][1], 8);
2257 dmv_pix_op = s->dsp.avg_pixels_tab;
2259 //avg top field from bottom field
2260 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2261 ref_picture, s->linesize,
2263 s->mv[dir][2][0], s->mv[dir][2][1], 8);
2264 //avg bottom field from top field
2265 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
2268 s->mv[dir][3][0], s->mv[dir][3][1], 8);
2271 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2274 //put field from the same parity
2275 //same parity is never in the same frame
2276 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
2279 s->mv[dir][0][0],s->mv[dir][0][1],16);
2281 // after put we make avg of the same block
2282 dmv_pix_op=s->dsp.avg_pixels_tab;
2284 //opposite parity is always in the same frame if this is second field
2285 if(!s->first_field){
2286 ref_picture = s->current_picture.data;
2287 //top field is one linesize from frame beginig
2288 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2289 -s->linesize : s->linesize;
2291 offset=(s->picture_structure == PICT_BOTTOM_FIELD)?
2294 //avg field from the opposite parity
2295 mpeg_motion(s, dest_y, dest_cb, dest_cr,0,
2296 ref_picture, offset,
2298 s->mv[dir][2][0],s->mv[dir][2][1],16);
2307 /* put block[] to dest[] */
2308 static inline void put_dct(MpegEncContext *s,
2309 DCTELEM *block, int i, uint8_t *dest, int line_size)
2311 s->dct_unquantize(s, block, i, s->qscale);
2312 s->dsp.idct_put (dest, line_size, block);
2315 /* add block[] to dest[] */
2316 static inline void add_dct(MpegEncContext *s,
2317 DCTELEM *block, int i, uint8_t *dest, int line_size)
2319 if (s->block_last_index[i] >= 0) {
2320 s->dsp.idct_add (dest, line_size, block);
2324 static inline void add_dequant_dct(MpegEncContext *s,
2325 DCTELEM *block, int i, uint8_t *dest, int line_size)
2327 if (s->block_last_index[i] >= 0) {
2328 s->dct_unquantize(s, block, i, s->qscale);
2330 s->dsp.idct_add (dest, line_size, block);
2335 * cleans dc, ac, coded_block for the current non intra MB
2337 void ff_clean_intra_table_entries(MpegEncContext *s)
2339 int wrap = s->block_wrap[0];
2340 int xy = s->block_index[0];
2343 s->dc_val[0][xy + 1 ] =
2344 s->dc_val[0][xy + wrap] =
2345 s->dc_val[0][xy + 1 + wrap] = 1024;
2347 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2348 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2349 if (s->msmpeg4_version>=3) {
2350 s->coded_block[xy ] =
2351 s->coded_block[xy + 1 ] =
2352 s->coded_block[xy + wrap] =
2353 s->coded_block[xy + 1 + wrap] = 0;
2356 wrap = s->block_wrap[4];
2357 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
2359 s->dc_val[2][xy] = 1024;
2361 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2362 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2364 s->mbintra_table[s->mb_x + s->mb_y*s->mb_stride]= 0;
2367 /* generic function called after a macroblock has been parsed by the
2368 decoder or after it has been encoded by the encoder.
2370 Important variables used:
2371 s->mb_intra : true if intra macroblock
2372 s->mv_dir : motion vector direction
2373 s->mv_type : motion vector type
2374 s->mv : motion vector
2375 s->interlaced_dct : true if interlaced dct used (mpeg2)
2377 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
2380 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2385 s->current_picture.qscale_table[mb_xy]= s->qscale;
2387 /* update DC predictors for P macroblocks */
2389 if (s->h263_pred || s->h263_aic) {
2390 if(s->mbintra_table[mb_xy])
2391 ff_clean_intra_table_entries(s);
2395 s->last_dc[2] = 128 << s->intra_dc_precision;
2398 else if (s->h263_pred || s->h263_aic)
2399 s->mbintra_table[mb_xy]=1;
2401 /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
2402 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
2403 //FIXME a lot of thet is only needed for !low_delay
2404 const int wrap = s->block_wrap[0];
2405 const int xy = s->block_index[0];
2406 if(s->mv_type != MV_TYPE_8X8){
2407 int motion_x, motion_y;
2411 } else if (s->mv_type == MV_TYPE_16X16) {
2412 motion_x = s->mv[0][0][0];
2413 motion_y = s->mv[0][0][1];
2414 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
2416 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
2417 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
2418 motion_x = (motion_x>>1) | (motion_x&1);
2420 s->field_mv_table[mb_xy][i][0]= s->mv[0][i][0];
2421 s->field_mv_table[mb_xy][i][1]= s->mv[0][i][1];
2422 s->field_select_table[mb_xy][i]= s->field_select[0][i];
2426 /* no update if 8X8 because it has been done during parsing */
2427 s->motion_val[xy][0] = motion_x;
2428 s->motion_val[xy][1] = motion_y;
2429 s->motion_val[xy + 1][0] = motion_x;
2430 s->motion_val[xy + 1][1] = motion_y;
2431 s->motion_val[xy + wrap][0] = motion_x;
2432 s->motion_val[xy + wrap][1] = motion_y;
2433 s->motion_val[xy + 1 + wrap][0] = motion_x;
2434 s->motion_val[xy + 1 + wrap][1] = motion_y;
2437 if(s->encoding){ //FIXME encoding MUST be cleaned up
2438 if (s->mv_type == MV_TYPE_8X8)
2439 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_8x8;
2441 s->current_picture.mb_type[mb_xy]= MB_TYPE_L0 | MB_TYPE_16x16;
2445 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
2446 uint8_t *dest_y, *dest_cb, *dest_cr;
2447 int dct_linesize, dct_offset;
2448 op_pixels_func (*op_pix)[4];
2449 qpel_mc_func (*op_qpix)[16];
2450 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
2451 const int uvlinesize= s->current_picture.linesize[1];
2453 /* avoid copy if macroblock skipped in last frame too */
2454 if (s->pict_type != B_TYPE) {
2455 s->current_picture.mbskip_table[mb_xy]= s->mb_skiped;
2458 /* skip only during decoding as we might trash the buffers during encoding a bit */
2460 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2461 const int age= s->current_picture.age;
2467 assert(s->pict_type!=I_TYPE);
2469 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
2470 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2472 /* if previous was skipped too, then nothing to do ! */
2473 if (*mbskip_ptr >= age && s->current_picture.reference){
2476 } else if(!s->current_picture.reference){
2477 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2478 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2480 *mbskip_ptr = 0; /* not skipped */
2485 if(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME){ //FIXME precalc
2486 dest_y = s->current_picture.data[0] + mb_x * 16;
2487 dest_cb = s->current_picture.data[1] + mb_x * 8;
2488 dest_cr = s->current_picture.data[2] + mb_x * 8;
2490 dest_y = s->current_picture.data[0] + (mb_y * 16* linesize ) + mb_x * 16;
2491 dest_cb = s->current_picture.data[1] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2492 dest_cr = s->current_picture.data[2] + (mb_y * 8 * uvlinesize) + mb_x * 8;
2495 if (s->interlaced_dct) {
2496 dct_linesize = linesize * 2;
2497 dct_offset = linesize;
2499 dct_linesize = linesize;
2500 dct_offset = linesize * 8;
2504 /* motion handling */
2505 /* decoding or more than one mb_type (MC was allready done otherwise) */
2506 if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
2507 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2508 op_pix = s->dsp.put_pixels_tab;
2509 op_qpix= s->dsp.put_qpel_pixels_tab;
2511 op_pix = s->dsp.put_no_rnd_pixels_tab;
2512 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2515 if (s->mv_dir & MV_DIR_FORWARD) {
2516 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2517 op_pix = s->dsp.avg_pixels_tab;
2518 op_qpix= s->dsp.avg_qpel_pixels_tab;
2520 if (s->mv_dir & MV_DIR_BACKWARD) {
2521 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2525 /* skip dequant / idct if we are really late ;) */
2526 if(s->hurry_up>1) return;
2528 /* add dct residue */
2529 if(s->encoding || !( s->mpeg2 || s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO
2530 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2531 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
2532 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2533 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2534 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2536 if(!(s->flags&CODEC_FLAG_GRAY)){
2537 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize);
2538 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize);
2540 } else if(s->codec_id != CODEC_ID_WMV2){
2541 add_dct(s, block[0], 0, dest_y, dct_linesize);
2542 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2543 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2544 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2546 if(!(s->flags&CODEC_FLAG_GRAY)){
2547 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2548 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2553 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2557 /* dct only in intra block */
2558 if(s->encoding || !(s->mpeg2 || s->codec_id==CODEC_ID_MPEG1VIDEO)){
2559 put_dct(s, block[0], 0, dest_y, dct_linesize);
2560 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
2561 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
2562 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
2564 if(!(s->flags&CODEC_FLAG_GRAY)){
2565 put_dct(s, block[4], 4, dest_cb, uvlinesize);
2566 put_dct(s, block[5], 5, dest_cr, uvlinesize);
2569 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2570 s->dsp.idct_put(dest_y + 8, dct_linesize, block[1]);
2571 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2572 s->dsp.idct_put(dest_y + dct_offset + 8, dct_linesize, block[3]);
2574 if(!(s->flags&CODEC_FLAG_GRAY)){
2575 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2576 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2583 #ifdef CONFIG_ENCODERS
2585 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
2587 static const char tab[64]=
2599 DCTELEM *block= s->block[n];
2600 const int last_index= s->block_last_index[n];
2605 threshold= -threshold;
2609 /* are all which we could set to zero are allready zero? */
2610 if(last_index<=skip_dc - 1) return;
2612 for(i=0; i<=last_index; i++){
2613 const int j = s->intra_scantable.permutated[i];
2614 const int level = ABS(block[j]);
2616 if(skip_dc && i==0) continue;
2625 if(score >= threshold) return;
2626 for(i=skip_dc; i<=last_index; i++){
2627 const int j = s->intra_scantable.permutated[i];
2630 if(block[0]) s->block_last_index[n]= 0;
2631 else s->block_last_index[n]= -1;
2634 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
2637 const int maxlevel= s->max_qcoeff;
2638 const int minlevel= s->min_qcoeff;
2641 i=1; //skip clipping of intra dc
2645 for(;i<=last_index; i++){
2646 const int j= s->intra_scantable.permutated[i];
2647 int level = block[j];
2649 if (level>maxlevel) level=maxlevel;
2650 else if(level<minlevel) level=minlevel;
2657 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2662 for(x=0; x<16; x+=4){
2663 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
2664 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
2672 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2677 for(x=0; x<16; x++){
2678 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2687 #define SQ(a) ((a)*(a))
2689 static int pix_vcmp16x8(uint8_t *s, int stride){ //FIXME move to dsputil & optimize
2694 for(x=0; x<16; x+=4){
2695 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
2696 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
2704 static int pix_diff_vcmp16x8(uint8_t *s1, uint8_t*s2, int stride){ //FIXME move to dsputil & optimize
2709 for(x=0; x<16; x++){
2710 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
2721 #endif //CONFIG_ENCODERS
2725 * @param h is the normal height, this will be reduced automatically if needed for the last row
2727 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2728 if ( s->avctx->draw_horiz_band
2729 && (s->last_picture_ptr || s->low_delay) ) {
2730 uint8_t *src_ptr[3];
2732 h= FFMIN(h, s->height - y);
2734 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME)
2737 offset = y * s->linesize;
2739 if(s->pict_type==B_TYPE || s->low_delay){
2740 src_ptr[0] = s->current_picture.data[0] + offset;
2741 src_ptr[1] = s->current_picture.data[1] + (offset >> 2);
2742 src_ptr[2] = s->current_picture.data[2] + (offset >> 2);
2744 src_ptr[0] = s->last_picture.data[0] + offset;
2745 src_ptr[1] = s->last_picture.data[1] + (offset >> 2);
2746 src_ptr[2] = s->last_picture.data[2] + (offset >> 2);
2750 s->avctx->draw_horiz_band(s->avctx, src_ptr, s->linesize,
2755 #ifdef CONFIG_ENCODERS
2757 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2759 const int mb_x= s->mb_x;
2760 const int mb_y= s->mb_y;
2763 int dct_offset = s->linesize*8; //default for progressive frames
2765 for(i=0; i<6; i++) skip_dct[i]=0;
2767 if(s->adaptive_quant){
2768 s->dquant= s->current_picture.qscale_table[mb_x + mb_y*s->mb_stride] - s->qscale;
2770 if(s->out_format==FMT_H263){
2771 if (s->dquant> 2) s->dquant= 2;
2772 else if(s->dquant<-2) s->dquant=-2;
2775 if(s->codec_id==CODEC_ID_MPEG4){
2777 if(s->mv_dir&MV_DIRECT)
2780 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
2783 s->qscale+= s->dquant;
2784 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2785 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2793 wrap_y = s->linesize;
2794 ptr = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2796 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2797 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2798 ptr= s->edge_emu_buffer;
2802 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2803 int progressive_score, interlaced_score;
2805 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2806 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
2808 if(progressive_score > interlaced_score + 100){
2809 s->interlaced_dct=1;
2814 s->interlaced_dct=0;
2817 s->dsp.get_pixels(s->block[0], ptr , wrap_y);
2818 s->dsp.get_pixels(s->block[1], ptr + 8, wrap_y);
2819 s->dsp.get_pixels(s->block[2], ptr + dct_offset , wrap_y);
2820 s->dsp.get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2822 if(s->flags&CODEC_FLAG_GRAY){
2826 int wrap_c = s->uvlinesize;
2827 ptr = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2829 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);
2830 ptr= s->edge_emu_buffer;
2832 s->dsp.get_pixels(s->block[4], ptr, wrap_c);
2834 ptr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2836 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);
2837 ptr= s->edge_emu_buffer;
2839 s->dsp.get_pixels(s->block[5], ptr, wrap_c);
2842 op_pixels_func (*op_pix)[4];
2843 qpel_mc_func (*op_qpix)[16];
2844 uint8_t *dest_y, *dest_cb, *dest_cr;
2845 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2849 dest_y = s->current_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
2850 dest_cb = s->current_picture.data[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2851 dest_cr = s->current_picture.data[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2852 wrap_y = s->linesize;
2853 wrap_c = s->uvlinesize;
2854 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2855 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2856 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2858 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2859 op_pix = s->dsp.put_pixels_tab;
2860 op_qpix= s->dsp.put_qpel_pixels_tab;
2862 op_pix = s->dsp.put_no_rnd_pixels_tab;
2863 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
2866 if (s->mv_dir & MV_DIR_FORWARD) {
2867 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2868 op_pix = s->dsp.avg_pixels_tab;
2869 op_qpix= s->dsp.avg_qpel_pixels_tab;
2871 if (s->mv_dir & MV_DIR_BACKWARD) {
2872 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2875 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2876 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2877 ptr_y= s->edge_emu_buffer;
2881 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2882 int progressive_score, interlaced_score;
2884 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
2885 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
2886 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
2887 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
2889 if(progressive_score > interlaced_score + 600){
2890 s->interlaced_dct=1;
2895 s->interlaced_dct=0;
2898 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
2899 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2900 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
2901 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2903 if(s->flags&CODEC_FLAG_GRAY){
2908 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);
2909 ptr_cb= s->edge_emu_buffer;
2911 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2913 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);
2914 ptr_cr= s->edge_emu_buffer;
2916 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2918 /* pre quantization */
2919 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
2921 if(s->dsp.pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2922 if(s->dsp.pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2923 if(s->dsp.pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2924 if(s->dsp.pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2925 if(s->dsp.pix_abs8x8(ptr_cb , dest_cb , wrap_c) < 20*s->qscale) skip_dct[4]= 1;
2926 if(s->dsp.pix_abs8x8(ptr_cr , dest_cr , wrap_c) < 20*s->qscale) skip_dct[5]= 1;
2932 if(skip_dct[i]) num++;
2935 if(s->mb_x==0 && s->mb_y==0){
2937 printf("%6d %1d\n", stat[i], i);
2950 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_stride*mb_y+mb_x] + 1.0) /
2951 ((s->mb_var[s->mb_stride*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2953 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2954 (s->mb_type[s->mb_stride*mb_y+mb_x] > 0) ? 'I' : 'P',
2955 s->qscale, adap_parm, s->qscale*adap_parm,
2956 s->mb_var[s->mb_stride*mb_y+mb_x], s->avg_mb_var);
2959 /* DCT & quantize */
2960 if(s->out_format==FMT_MJPEG){
2963 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2964 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2970 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2971 // FIXME we could decide to change to quantizer instead of clipping
2972 // JS: I don't think that would be a good idea it could lower quality instead
2973 // of improve it. Just INTRADC clipping deserves changes in quantizer
2974 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2976 s->block_last_index[i]= -1;
2978 if(s->luma_elim_threshold && !s->mb_intra)
2980 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2981 if(s->chroma_elim_threshold && !s->mb_intra)
2983 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2986 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2987 s->block_last_index[4]=
2988 s->block_last_index[5]= 0;
2990 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
2993 /* huffman encode */
2994 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2995 case CODEC_ID_MPEG1VIDEO:
2996 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
2998 case CODEC_ID_MPEG4:
2999 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3000 case CODEC_ID_MSMPEG4V2:
3001 case CODEC_ID_MSMPEG4V3:
3003 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
3005 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
3007 case CODEC_ID_H263P:
3010 h263_encode_mb(s, s->block, motion_x, motion_y); break;
3012 case CODEC_ID_MJPEG:
3013 mjpeg_encode_mb(s, s->block); break;
3019 #endif //CONFIG_ENCODERS
3022 * combines the (truncated) bitstream to a complete frame
3023 * @returns -1 if no complete frame could be created
3025 int ff_combine_frame( MpegEncContext *s, int next, uint8_t **buf, int *buf_size){
3026 ParseContext *pc= &s->parse_context;
3030 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3031 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3035 /* copy overreaded byes from last frame into buffer */
3036 for(; pc->overread>0; pc->overread--){
3037 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
3040 pc->last_index= pc->index;
3042 /* copy into buffer end return */
3043 if(next == END_NOT_FOUND){
3044 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3046 memcpy(&pc->buffer[pc->index], *buf, *buf_size);
3047 pc->index += *buf_size;
3052 pc->overread_index= pc->index + next;
3054 /* append to buffer */
3056 pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
3058 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
3063 /* store overread bytes */
3064 for(;next < 0; next++){
3065 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
3071 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
3072 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
3079 #ifdef CONFIG_ENCODERS
3080 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
3082 int bytes= length>>4;
3083 int bits= length&15;
3086 if(length==0) return;
3088 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
3089 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
3092 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
3095 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3098 d->mb_skip_run= s->mb_skip_run;
3100 d->last_dc[i]= s->last_dc[i];
3103 d->mv_bits= s->mv_bits;
3104 d->i_tex_bits= s->i_tex_bits;
3105 d->p_tex_bits= s->p_tex_bits;
3106 d->i_count= s->i_count;
3107 d->f_count= s->f_count;
3108 d->b_count= s->b_count;
3109 d->skip_count= s->skip_count;
3110 d->misc_bits= s->misc_bits;
3113 d->mb_skiped= s->mb_skiped;
3114 d->qscale= s->qscale;
3117 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
3120 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
3121 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
3124 d->mb_skip_run= s->mb_skip_run;
3126 d->last_dc[i]= s->last_dc[i];
3129 d->mv_bits= s->mv_bits;
3130 d->i_tex_bits= s->i_tex_bits;
3131 d->p_tex_bits= s->p_tex_bits;
3132 d->i_count= s->i_count;
3133 d->f_count= s->f_count;
3134 d->b_count= s->b_count;
3135 d->skip_count= s->skip_count;
3136 d->misc_bits= s->misc_bits;
3138 d->mb_intra= s->mb_intra;
3139 d->mb_skiped= s->mb_skiped;
3140 d->mv_type= s->mv_type;
3141 d->mv_dir= s->mv_dir;
3143 if(s->data_partitioning){
3145 d->tex_pb= s->tex_pb;
3149 d->block_last_index[i]= s->block_last_index[i];
3150 d->interlaced_dct= s->interlaced_dct;
3151 d->qscale= s->qscale;
3154 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
3155 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
3156 int *dmin, int *next_block, int motion_x, int motion_y)
3160 copy_context_before_encode(s, backup, type);
3162 s->block= s->blocks[*next_block];
3163 s->pb= pb[*next_block];
3164 if(s->data_partitioning){
3165 s->pb2 = pb2 [*next_block];
3166 s->tex_pb= tex_pb[*next_block];
3169 encode_mb(s, motion_x, motion_y);
3171 bits_count= get_bit_count(&s->pb);
3172 if(s->data_partitioning){
3173 bits_count+= get_bit_count(&s->pb2);
3174 bits_count+= get_bit_count(&s->tex_pb);
3177 if(bits_count<*dmin){
3181 copy_context_after_encode(best, s, type);
3185 static inline int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
3186 uint32_t *sq = squareTbl + 256;
3191 return s->dsp.sse[0](NULL, src1, src2, stride);
3192 else if(w==8 && h==8)
3193 return s->dsp.sse[1](NULL, src1, src2, stride);
3197 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
3206 static void encode_picture(MpegEncContext *s, int picture_number)
3208 int mb_x, mb_y, pdif = 0;
3211 MpegEncContext best_s, backup_s;
3212 uint8_t bit_buf[2][3000];
3213 uint8_t bit_buf2[2][3000];
3214 uint8_t bit_buf_tex[2][3000];
3215 PutBitContext pb[2], pb2[2], tex_pb[2];
3218 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
3219 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
3220 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
3223 s->picture_number = picture_number;
3225 /* Reset the average MB variance */
3226 s->current_picture.mb_var_sum = 0;
3227 s->current_picture.mc_mb_var_sum = 0;
3230 /* we need to initialize some time vars before we can encode b-frames */
3231 // RAL: Condition added for MPEG1VIDEO
3232 if (s->codec_id == CODEC_ID_MPEG1VIDEO || (s->h263_pred && !s->h263_msmpeg4))
3233 ff_set_mpeg4_time(s, s->picture_number);
3236 s->scene_change_score=0;
3238 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
3240 if(s->pict_type==I_TYPE){
3241 if(s->msmpeg4_version >= 3) s->no_rounding=1;
3242 else s->no_rounding=0;
3243 }else if(s->pict_type!=B_TYPE){
3244 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
3245 s->no_rounding ^= 1;
3248 /* Estimate motion for every MB */
3249 s->mb_intra=0; //for the rate distoration & bit compare functions
3250 if(s->pict_type != I_TYPE){
3251 if(s->pict_type != B_TYPE){
3252 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
3254 s->me.dia_size= s->avctx->pre_dia_size;
3256 for(mb_y=s->mb_height-1; mb_y >=0 ; mb_y--) {
3257 for(mb_x=s->mb_width-1; mb_x >=0 ; mb_x--) {
3260 ff_pre_estimate_p_frame_motion(s, mb_x, mb_y);
3267 s->me.dia_size= s->avctx->dia_size;
3268 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3269 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3270 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3271 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3272 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3273 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3276 s->block_index[0]+=2;
3277 s->block_index[1]+=2;
3278 s->block_index[2]+=2;
3279 s->block_index[3]+=2;
3281 /* compute motion vector & mb_type and store in context */
3282 if(s->pict_type==B_TYPE)
3283 ff_estimate_b_frame_motion(s, mb_x, mb_y);
3285 ff_estimate_p_frame_motion(s, mb_x, mb_y);
3288 }else /* if(s->pict_type == I_TYPE) */{
3290 //FIXME do we need to zero them?
3291 memset(s->motion_val[0], 0, sizeof(int16_t)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
3292 memset(s->p_mv_table , 0, sizeof(int16_t)*(s->mb_stride)*s->mb_height*2);
3293 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3295 if(!s->fixed_qscale){
3296 /* finding spatial complexity for I-frame rate control */
3297 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3298 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3301 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
3303 int sum = s->dsp.pix_sum(pix, s->linesize);
3305 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
3307 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
3308 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
3309 s->current_picture.mb_var_sum += varc;
3316 if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
3317 s->pict_type= I_TYPE;
3318 memset(s->mb_type , MB_TYPE_INTRA, sizeof(uint8_t)*s->mb_stride*s->mb_height);
3319 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3323 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
3324 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
3326 ff_fix_long_p_mvs(s);
3329 if(s->pict_type==B_TYPE){
3332 a = ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
3333 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, MB_TYPE_BIDIR);
3334 s->f_code = FFMAX(a, b);
3336 a = ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
3337 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, MB_TYPE_BIDIR);
3338 s->b_code = FFMAX(a, b);
3340 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
3341 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
3342 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
3343 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
3347 if (s->fixed_qscale)
3348 s->frame_qscale = s->current_picture.quality;
3350 s->frame_qscale = ff_rate_estimate_qscale(s);
3352 if(s->adaptive_quant){
3354 switch(s->codec_id){
3355 case CODEC_ID_MPEG4:
3356 ff_clean_mpeg4_qscales(s);
3359 case CODEC_ID_H263P:
3361 ff_clean_h263_qscales(s);
3366 s->qscale= s->current_picture.qscale_table[0];
3368 s->qscale= (int)(s->frame_qscale + 0.5);
3370 if (s->out_format == FMT_MJPEG) {
3371 /* for mjpeg, we do include qscale in the matrix */
3372 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
3374 int j= s->dsp.idct_permutation[i];
3376 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3378 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3379 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
3382 //FIXME var duplication
3383 s->current_picture.key_frame= s->pict_type == I_TYPE;
3384 s->current_picture.pict_type= s->pict_type;
3386 if(s->current_picture.key_frame)
3387 s->picture_in_gop_number=0;
3389 s->last_bits= get_bit_count(&s->pb);
3390 switch(s->out_format) {
3392 mjpeg_picture_header(s);
3396 if (s->codec_id == CODEC_ID_WMV2)
3397 ff_wmv2_encode_picture_header(s, picture_number);
3398 else if (s->h263_msmpeg4)
3399 msmpeg4_encode_picture_header(s, picture_number);
3400 else if (s->h263_pred)
3401 mpeg4_encode_picture_header(s, picture_number);
3402 else if (s->h263_rv10)
3403 rv10_encode_picture_header(s, picture_number);
3405 h263_encode_picture_header(s, picture_number);
3409 mpeg1_encode_picture_header(s, picture_number);
3412 bits= get_bit_count(&s->pb);
3413 s->header_bits= bits - s->last_bits;
3425 /* init last dc values */
3426 /* note: quant matrix value (8) is implied here */
3427 s->last_dc[i] = 128;
3429 s->current_picture_ptr->error[i] = 0;
3432 s->last_mv[0][0][0] = 0;
3433 s->last_mv[0][0][1] = 0;
3434 s->last_mv[1][0][0] = 0;
3435 s->last_mv[1][0][1] = 0;
3440 switch(s->codec_id){
3442 case CODEC_ID_H263P:
3444 s->gob_index = ff_h263_get_gob_height(s);
3446 case CODEC_ID_MPEG4:
3447 if(s->partitioned_frame)
3448 ff_mpeg4_init_partitions(s);
3455 s->first_slice_line = 1;
3456 s->ptr_lastgob = s->pb.buf;
3457 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
3458 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
3459 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
3461 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
3462 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
3463 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
3464 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
3465 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
3466 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
3467 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3468 const int xy= mb_y*s->mb_stride + mb_x;
3469 int mb_type= s->mb_type[xy];
3475 s->block_index[0]+=2;
3476 s->block_index[1]+=2;
3477 s->block_index[2]+=2;
3478 s->block_index[3]+=2;
3479 s->block_index[4]++;
3480 s->block_index[5]++;
3482 /* write gob / video packet header */
3485 int current_packet_size, is_gob_start;
3487 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
3490 if(s->codec_id==CODEC_ID_MPEG4){
3491 if(current_packet_size >= s->rtp_payload_size
3492 && s->mb_y + s->mb_x>0){
3494 if(s->partitioned_frame){
3495 ff_mpeg4_merge_partitions(s);
3496 ff_mpeg4_init_partitions(s);
3498 ff_mpeg4_encode_video_packet_header(s);
3500 if(s->flags&CODEC_FLAG_PASS1){
3501 int bits= get_bit_count(&s->pb);
3502 s->misc_bits+= bits - s->last_bits;
3505 ff_mpeg4_clean_buffers(s);
3508 }else if(s->codec_id==CODEC_ID_MPEG1VIDEO){
3509 if( current_packet_size >= s->rtp_payload_size
3510 && s->mb_y + s->mb_x>0 && s->mb_skip_run==0){
3511 ff_mpeg1_encode_slice_header(s);
3512 ff_mpeg1_clean_buffers(s);
3516 if(current_packet_size >= s->rtp_payload_size
3517 && s->mb_x==0 && s->mb_y>0 && s->mb_y%s->gob_index==0){
3519 h263_encode_gob_header(s, mb_y);
3525 s->ptr_lastgob = pbBufPtr(&s->pb);
3526 s->first_slice_line=1;
3527 s->resync_mb_x=mb_x;
3528 s->resync_mb_y=mb_y;
3533 if( (s->resync_mb_x == s->mb_x)
3534 && s->resync_mb_y+1 == s->mb_y){
3535 s->first_slice_line=0;
3538 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
3540 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3542 copy_context_before_encode(&backup_s, s, -1);
3544 best_s.data_partitioning= s->data_partitioning;
3545 best_s.partitioned_frame= s->partitioned_frame;
3546 if(s->data_partitioning){
3547 backup_s.pb2= s->pb2;
3548 backup_s.tex_pb= s->tex_pb;
3551 if(mb_type&MB_TYPE_INTER){
3552 s->mv_dir = MV_DIR_FORWARD;
3553 s->mv_type = MV_TYPE_16X16;
3555 s->mv[0][0][0] = s->p_mv_table[xy][0];
3556 s->mv[0][0][1] = s->p_mv_table[xy][1];
3557 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
3558 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3560 if(mb_type&MB_TYPE_INTER4V){
3561 s->mv_dir = MV_DIR_FORWARD;
3562 s->mv_type = MV_TYPE_8X8;
3565 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3566 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3568 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
3569 &dmin, &next_block, 0, 0);
3571 if(mb_type&MB_TYPE_FORWARD){
3572 s->mv_dir = MV_DIR_FORWARD;
3573 s->mv_type = MV_TYPE_16X16;
3575 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3576 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3577 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
3578 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3580 if(mb_type&MB_TYPE_BACKWARD){
3581 s->mv_dir = MV_DIR_BACKWARD;
3582 s->mv_type = MV_TYPE_16X16;
3584 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3585 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3586 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3587 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3589 if(mb_type&MB_TYPE_BIDIR){
3590 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3591 s->mv_type = MV_TYPE_16X16;
3593 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3594 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3595 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3596 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3597 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
3598 &dmin, &next_block, 0, 0);
3600 if(mb_type&MB_TYPE_DIRECT){
3601 int mx= s->b_direct_mv_table[xy][0];
3602 int my= s->b_direct_mv_table[xy][1];
3604 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3607 ff_mpeg4_set_direct_mv(s, mx, my);
3609 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
3610 &dmin, &next_block, mx, my);
3612 if(mb_type&MB_TYPE_INTRA){
3614 s->mv_type = MV_TYPE_16X16;
3618 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
3619 &dmin, &next_block, 0, 0);
3620 /* force cleaning of ac/dc pred stuff if needed ... */
3621 if(s->h263_pred || s->h263_aic)
3622 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3624 copy_context_after_encode(s, &best_s, -1);
3626 pb_bits_count= get_bit_count(&s->pb);
3627 flush_put_bits(&s->pb);
3628 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3631 if(s->data_partitioning){
3632 pb2_bits_count= get_bit_count(&s->pb2);
3633 flush_put_bits(&s->pb2);
3634 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3635 s->pb2= backup_s.pb2;
3637 tex_pb_bits_count= get_bit_count(&s->tex_pb);
3638 flush_put_bits(&s->tex_pb);
3639 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3640 s->tex_pb= backup_s.tex_pb;
3642 s->last_bits= get_bit_count(&s->pb);
3644 int motion_x, motion_y;
3646 int inter_score= s->current_picture.mb_cmp_score[mb_x + mb_y*s->mb_stride];
3648 if(!(s->flags&CODEC_FLAG_HQ) && s->pict_type==P_TYPE){
3649 /* get luma score */
3650 if((s->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
3651 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
3655 int mean= s->current_picture.mb_mean[mb_x + mb_y*s->mb_stride]; //FIXME
3658 dest_y = s->new_picture.data[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
3660 for(i=0; i<16; i++){
3661 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 0]) = mean;
3662 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 4]) = mean;
3663 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+ 8]) = mean;
3664 *(uint32_t*)(&s->me.scratchpad[i*s->linesize+12]) = mean;
3668 intra_score= s->dsp.mb_cmp[0](s, s->me.scratchpad, dest_y, s->linesize);
3670 /* printf("intra:%7d inter:%7d var:%7d mc_var.%7d\n", intra_score>>8, inter_score>>8,
3671 s->current_picture.mb_var[mb_x + mb_y*s->mb_stride],
3672 s->current_picture.mc_mb_var[mb_x + mb_y*s->mb_stride]);*/
3675 /* get chroma score */
3676 if(s->avctx->mb_cmp&FF_CMP_CHROMA){
3684 if(s->out_format == FMT_H263){
3685 mean= (s->dc_val[i][mb_x + (mb_y+1)*(s->mb_width+2)] + 4)>>3; //FIXME not exact but simple ;)
3687 mean= (s->last_dc[i] + 4)>>3;
3689 dest_c = s->new_picture.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3693 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 0]) = mean;
3694 *(uint32_t*)(&s->me.scratchpad[i*s->uvlinesize+ 4]) = mean;
3697 intra_score+= s->dsp.mb_cmp[1](s, s->me.scratchpad, dest_c, s->uvlinesize);
3702 switch(s->avctx->mb_cmp&0xFF){
3705 intra_score+= 32*s->qscale;
3708 intra_score+= 24*s->qscale*s->qscale;
3711 intra_score+= 96*s->qscale;
3714 intra_score+= 48*s->qscale;
3721 intra_score+= (s->qscale*s->qscale*109*8 + 64)>>7;
3725 if(intra_score < inter_score)
3726 mb_type= MB_TYPE_INTRA;
3729 s->mv_type=MV_TYPE_16X16;
3730 // only one MB-Type possible
3736 motion_x= s->mv[0][0][0] = 0;
3737 motion_y= s->mv[0][0][1] = 0;
3740 s->mv_dir = MV_DIR_FORWARD;
3742 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3743 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3745 case MB_TYPE_INTER4V:
3746 s->mv_dir = MV_DIR_FORWARD;
3747 s->mv_type = MV_TYPE_8X8;
3750 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
3751 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
3753 motion_x= motion_y= 0;
3755 case MB_TYPE_DIRECT:
3756 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3758 motion_x=s->b_direct_mv_table[xy][0];
3759 motion_y=s->b_direct_mv_table[xy][1];
3761 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3765 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3769 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3770 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3771 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3772 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3774 case MB_TYPE_BACKWARD:
3775 s->mv_dir = MV_DIR_BACKWARD;
3777 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3778 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3780 case MB_TYPE_FORWARD:
3781 s->mv_dir = MV_DIR_FORWARD;
3783 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3784 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3785 // printf(" %d %d ", motion_x, motion_y);
3788 motion_x=motion_y=0; //gcc warning fix
3789 printf("illegal MB type\n");
3792 encode_mb(s, motion_x, motion_y);
3794 // RAL: Update last macrobloc type
3795 s->last_mv_dir = s->mv_dir;
3798 /* clean the MV table in IPS frames for direct mode in B frames */
3799 if(s->mb_intra /* && I,P,S_TYPE */){
3800 s->p_mv_table[xy][0]=0;
3801 s->p_mv_table[xy][1]=0;
3804 MPV_decode_mb(s, s->block);
3806 if(s->flags&CODEC_FLAG_PSNR){
3810 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3811 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3813 s->current_picture_ptr->error[0] += sse(
3815 s->new_picture .data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3816 s->current_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3818 s->current_picture_ptr->error[1] += sse(
3820 s->new_picture .data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3821 s->current_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3822 w>>1, h>>1, s->uvlinesize);
3823 s->current_picture_ptr->error[2] += sse(
3825 s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3826 s->current_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
3827 w>>1, h>>1, s->uvlinesize);
3829 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, get_bit_count(&s->pb));
3835 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame)
3836 ff_mpeg4_merge_partitions(s);
3838 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
3839 msmpeg4_encode_ext_header(s);
3841 if(s->codec_id==CODEC_ID_MPEG4)
3842 ff_mpeg4_stuffing(&s->pb);
3845 //if (s->gob_number)
3846 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
3848 /* Send the last GOB if RTP */
3850 flush_put_bits(&s->pb);
3851 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
3852 /* Call the RTP callback to send the last GOB */
3853 if (s->rtp_callback)
3854 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
3855 s->ptr_lastgob = pbBufPtr(&s->pb);
3856 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
3860 static int dct_quantize_trellis_c(MpegEncContext *s,
3861 DCTELEM *block, int n,
3862 int qscale, int *overflow){
3864 const uint8_t *scantable= s->intra_scantable.scantable;
3866 unsigned int threshold1, threshold2;
3876 int coeff_count[64];
3877 int lambda, qmul, qadd, start_i, last_non_zero, i;
3878 const int esc_length= s->ac_esc_length;
3880 uint8_t * last_length;
3884 s->dsp.fdct (block);
3887 qadd= ((qscale-1)|1)*8;
3898 /* For AIC we skip quant/dequant of INTRADC */
3903 /* note: block[0] is assumed to be positive */
3904 block[0] = (block[0] + (q >> 1)) / q;
3907 qmat = s->q_intra_matrix[qscale];
3908 if(s->mpeg_quant || s->codec_id== CODEC_ID_MPEG1VIDEO)
3909 bias= 1<<(QMAT_SHIFT-1);
3910 length = s->intra_ac_vlc_length;
3911 last_length= s->intra_ac_vlc_last_length;
3915 qmat = s->q_inter_matrix[qscale];
3916 length = s->inter_ac_vlc_length;
3917 last_length= s->inter_ac_vlc_last_length;
3920 threshold1= (1<<QMAT_SHIFT) - bias - 1;
3921 threshold2= (threshold1<<1);
3923 for(i=start_i; i<64; i++) {
3924 const int j = scantable[i];
3925 const int k= i-start_i;
3926 int level = block[j];
3927 level = level * qmat[j];
3929 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
3930 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
3931 if(((unsigned)(level+threshold1))>threshold2){
3933 level= (bias + level)>>QMAT_SHIFT;
3935 coeff[1][k]= level-1;
3936 // coeff[2][k]= level-2;
3938 level= (bias - level)>>QMAT_SHIFT;
3939 coeff[0][k]= -level;
3940 coeff[1][k]= -level+1;
3941 // coeff[2][k]= -level+2;
3943 coeff_count[k]= FFMIN(level, 2);
3947 coeff[0][k]= (level>>31)|1;
3952 *overflow= s->max_qcoeff < max; //overflow might have happend
3954 if(last_non_zero < start_i){
3955 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
3956 return last_non_zero;
3959 lambda= (qscale*qscale*64*105 + 64)>>7; //FIXME finetune
3962 for(i=0; i<=last_non_zero - start_i; i++){
3963 int level_index, run, j;
3964 const int dct_coeff= block[ scantable[i + start_i] ];
3965 const int zero_distoration= dct_coeff*dct_coeff;
3966 int best_score=256*256*256*120;
3968 last_score += zero_distoration;
3969 for(level_index=0; level_index < coeff_count[i]; level_index++){
3971 int level= coeff[level_index][i];
3976 if(s->out_format == FMT_H263){
3978 unquant_coeff= level*qmul + qadd;
3980 unquant_coeff= level*qmul - qadd;
3983 j= s->dsp.idct_permutation[ scantable[i + start_i] ]; //FIXME optimize
3986 unquant_coeff = (int)((-level) * qscale * s->intra_matrix[j]) >> 3;
3987 unquant_coeff = -((unquant_coeff - 1) | 1);
3989 unquant_coeff = (int)( level * qscale * s->intra_matrix[j]) >> 3;
3990 unquant_coeff = (unquant_coeff - 1) | 1;
3994 unquant_coeff = ((((-level) << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3995 unquant_coeff = -((unquant_coeff - 1) | 1);
3997 unquant_coeff = ((( level << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3998 unquant_coeff = (unquant_coeff - 1) | 1;
4004 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff);
4006 if((level&(~127)) == 0){
4007 for(run=0; run<=i - left_limit; run++){
4008 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4009 score += score_tab[i-run];
4011 if(score < best_score){
4013 score_tab[i+1]= score;
4015 level_tab[i+1]= level-64;
4019 if(s->out_format == FMT_H263){
4020 for(run=0; run<=i - left_limit; run++){
4021 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4022 score += score_tab[i-run];
4023 if(score < last_score){
4026 last_level= level-64;
4032 distoration += esc_length*lambda;
4033 for(run=0; run<=i - left_limit; run++){
4034 int score= distoration + score_tab[i-run];
4036 if(score < best_score){
4038 score_tab[i+1]= score;
4040 level_tab[i+1]= level-64;
4044 if(s->out_format == FMT_H263){
4045 for(run=0; run<=i - left_limit; run++){
4046 int score= distoration + score_tab[i-run];
4047 if(score < last_score){
4050 last_level= level-64;
4058 for(j=left_limit; j<=i; j++){
4059 score_tab[j] += zero_distoration;
4061 score_limit+= zero_distoration;
4062 if(score_tab[i+1] < score_limit)
4063 score_limit= score_tab[i+1];
4065 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
4066 while(score_tab[ left_limit ] > score_limit + lambda) left_limit++;
4069 //FIXME add some cbp penalty
4071 if(s->out_format != FMT_H263){
4072 last_score= 256*256*256*120;
4073 for(i= left_limit; i<=last_non_zero - start_i + 1; i++){
4074 int score= score_tab[i];
4075 if(i) score += lambda*2; //FIXME exacter?
4077 if(score < last_score){
4080 last_level= level_tab[i];
4081 last_run= run_tab[i];
4086 last_non_zero= last_i - 1 + start_i;
4087 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
4089 if(last_non_zero < start_i)
4090 return last_non_zero;
4094 //FIXME use permutated scantable
4095 block[ s->dsp.idct_permutation[ scantable[last_non_zero] ] ]= last_level;
4098 for(;i>0 ; i -= run_tab[i] + 1){
4099 const int j= s->dsp.idct_permutation[ scantable[i - 1 + start_i] ];
4101 block[j]= level_tab[i];
4105 return last_non_zero;
4108 static int dct_quantize_c(MpegEncContext *s,
4109 DCTELEM *block, int n,
4110 int qscale, int *overflow)
4112 int i, j, level, last_non_zero, q;
4114 const uint8_t *scantable= s->intra_scantable.scantable;
4117 unsigned int threshold1, threshold2;
4119 s->dsp.fdct (block);
4129 /* For AIC we skip quant/dequant of INTRADC */
4132 /* note: block[0] is assumed to be positive */
4133 block[0] = (block[0] + (q >> 1)) / q;
4136 qmat = s->q_intra_matrix[qscale];
4137 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4141 qmat = s->q_inter_matrix[qscale];
4142 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4144 threshold1= (1<<QMAT_SHIFT) - bias - 1;
4145 threshold2= (threshold1<<1);
4150 level = level * qmat[j];
4152 // if( bias+level >= (1<<QMAT_SHIFT)
4153 // || bias-level >= (1<<QMAT_SHIFT)){
4154 if(((unsigned)(level+threshold1))>threshold2){
4156 level= (bias + level)>>QMAT_SHIFT;
4159 level= (bias - level)>>QMAT_SHIFT;
4168 *overflow= s->max_qcoeff < max; //overflow might have happend
4170 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4171 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4172 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4174 return last_non_zero;
4177 #endif //CONFIG_ENCODERS
4179 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
4180 DCTELEM *block, int n, int qscale)
4182 int i, level, nCoeffs;
4183 const uint16_t *quant_matrix;
4185 nCoeffs= s->block_last_index[n];
4189 block[0] = block[0] * s->y_dc_scale;
4191 block[0] = block[0] * s->c_dc_scale;
4192 /* XXX: only mpeg1 */
4193 quant_matrix = s->intra_matrix;
4194 for(i=1;i<=nCoeffs;i++) {
4195 int j= s->intra_scantable.permutated[i];
4200 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4201 level = (level - 1) | 1;
4204 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4205 level = (level - 1) | 1;
4208 if (level < -2048 || level > 2047)
4209 fprintf(stderr, "unquant error %d %d\n", i, level);
4216 quant_matrix = s->inter_matrix;
4217 for(;i<=nCoeffs;i++) {
4218 int j= s->intra_scantable.permutated[i];
4223 level = (((level << 1) + 1) * qscale *
4224 ((int) (quant_matrix[j]))) >> 4;
4225 level = (level - 1) | 1;
4228 level = (((level << 1) + 1) * qscale *
4229 ((int) (quant_matrix[j]))) >> 4;
4230 level = (level - 1) | 1;
4233 if (level < -2048 || level > 2047)
4234 fprintf(stderr, "unquant error %d %d\n", i, level);
4242 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
4243 DCTELEM *block, int n, int qscale)
4245 int i, level, nCoeffs;
4246 const uint16_t *quant_matrix;
4248 if(s->alternate_scan) nCoeffs= 63;
4249 else nCoeffs= s->block_last_index[n];
4253 block[0] = block[0] * s->y_dc_scale;
4255 block[0] = block[0] * s->c_dc_scale;
4256 quant_matrix = s->intra_matrix;
4257 for(i=1;i<=nCoeffs;i++) {
4258 int j= s->intra_scantable.permutated[i];
4263 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4266 level = (int)(level * qscale * quant_matrix[j]) >> 3;
4269 if (level < -2048 || level > 2047)
4270 fprintf(stderr, "unquant error %d %d\n", i, level);
4278 quant_matrix = s->inter_matrix;
4279 for(;i<=nCoeffs;i++) {
4280 int j= s->intra_scantable.permutated[i];
4285 level = (((level << 1) + 1) * qscale *
4286 ((int) (quant_matrix[j]))) >> 4;
4289 level = (((level << 1) + 1) * qscale *
4290 ((int) (quant_matrix[j]))) >> 4;
4293 if (level < -2048 || level > 2047)
4294 fprintf(stderr, "unquant error %d %d\n", i, level);
4305 static void dct_unquantize_h263_c(MpegEncContext *s,
4306 DCTELEM *block, int n, int qscale)
4308 int i, level, qmul, qadd;
4311 assert(s->block_last_index[n]>=0);
4313 qadd = (qscale - 1) | 1;
4319 block[0] = block[0] * s->y_dc_scale;
4321 block[0] = block[0] * s->c_dc_scale;
4325 nCoeffs= 63; //does not allways use zigzag table
4328 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
4331 for(;i<=nCoeffs;i++) {
4335 level = level * qmul - qadd;
4337 level = level * qmul + qadd;
4340 if (level < -2048 || level > 2047)
4341 fprintf(stderr, "unquant error %d %d\n", i, level);
4349 static const AVOption mpeg4_options[] =
4351 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
4352 AVOPTION_CODEC_FLAG("vhq", "very high quality", flags, CODEC_FLAG_HQ, 0),
4353 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
4354 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
4355 bit_rate_tolerance, 4, 240000000, 8000),
4356 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
4357 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
4358 AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
4359 rc_eq, "tex^qComp,option1,options2", 0),
4360 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
4361 rc_min_rate, 4, 24000000, 0),
4362 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
4363 rc_max_rate, 4, 24000000, 0),
4364 AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
4365 rc_buffer_aggressivity, 4, 24000000, 0),
4366 AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
4367 rc_initial_cplx, 0., 9999999., 0),
4368 AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
4369 i_quant_factor, 0., 0., 0),
4370 AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
4371 i_quant_factor, -999999., 999999., 0),
4372 AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
4373 dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
4374 AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
4375 lumi_masking, 0., 999999., 0),
4376 AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
4377 temporal_cplx_masking, 0., 999999., 0),
4378 AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
4379 spatial_cplx_masking, 0., 999999., 0),
4380 AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
4381 p_masking, 0., 999999., 0),
4382 AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
4383 dark_masking, 0., 999999., 0),
4384 AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
4385 idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
4387 AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
4389 AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
4392 AVOPTION_CODEC_INT("me_cmp", "ME compare function",
4393 me_cmp, 0, 24000000, 0),
4394 AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
4395 me_sub_cmp, 0, 24000000, 0),
4398 AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
4399 dia_size, 0, 24000000, 0),
4400 AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
4401 last_predictor_count, 0, 24000000, 0),
4403 AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
4404 pre_me, 0, 24000000, 0),
4405 AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
4406 me_pre_cmp, 0, 24000000, 0),
4408 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4409 me_range, 0, 24000000, 0),
4410 AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
4411 pre_dia_size, 0, 24000000, 0),
4412 AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
4413 me_subpel_quality, 0, 24000000, 0),
4414 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
4415 me_range, 0, 24000000, 0),
4416 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
4417 flags, CODEC_FLAG_PSNR, 0),
4418 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
4420 AVOPTION_SUB(avoptions_common),
4424 #ifdef CONFIG_ENCODERS
4426 AVCodec mpeg1video_encoder = {
4429 CODEC_ID_MPEG1VIDEO,
4430 sizeof(MpegEncContext),
4438 AVCodec h263_encoder = {
4442 sizeof(MpegEncContext),
4448 AVCodec h263p_encoder = {
4452 sizeof(MpegEncContext),
4458 AVCodec flv_encoder = {
4462 sizeof(MpegEncContext),
4468 AVCodec rv10_encoder = {
4472 sizeof(MpegEncContext),
4478 AVCodec mpeg4_encoder = {
4482 sizeof(MpegEncContext),
4486 .options = mpeg4_options,
4489 AVCodec msmpeg4v1_encoder = {
4493 sizeof(MpegEncContext),
4497 .options = mpeg4_options,
4500 AVCodec msmpeg4v2_encoder = {
4504 sizeof(MpegEncContext),
4508 .options = mpeg4_options,
4511 AVCodec msmpeg4v3_encoder = {
4515 sizeof(MpegEncContext),
4519 .options = mpeg4_options,
4522 AVCodec wmv1_encoder = {
4526 sizeof(MpegEncContext),
4530 .options = mpeg4_options,
4535 AVCodec mjpeg_encoder = {
4539 sizeof(MpegEncContext),
4545 #endif //CONFIG_ENCODERS