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>
25 #include "mpegvideo.h"
26 #include "simple_idct.h"
29 #include "fastmemcpy.h"
35 static void encode_picture(MpegEncContext *s, int picture_number);
36 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
37 DCTELEM *block, int n, int qscale);
38 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
39 DCTELEM *block, int n, int qscale);
40 static void dct_unquantize_h263_c(MpegEncContext *s,
41 DCTELEM *block, int n, int qscale);
42 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w);
43 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
45 void (*draw_edges)(UINT8 *buf, int wrap, int width, int height, int w)= draw_edges_c;
46 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
47 int src_x, int src_y, int w, int h);
51 /* enable all paranoid tests for rounding, overflows, etc... */
57 /* for jpeg fast DCT */
60 static const unsigned short aanscales[64] = {
61 /* precomputed values scaled up by 14 bits */
62 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
63 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
64 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
65 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
66 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
67 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
68 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
69 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
72 static UINT8 h263_chroma_roundtab[16] = {
73 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
76 static UINT16 default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
77 static UINT8 default_fcode_tab[MAX_MV*2+1];
79 /* default motion estimation */
80 int motion_estimation_method = ME_EPZS;
82 static void convert_matrix(MpegEncContext *s, int (*qmat)[64], uint16_t (*qmat16)[64], uint16_t (*qmat16_bias)[64],
83 const UINT16 *quant_matrix, int bias, int qmin, int qmax)
87 for(qscale=qmin; qscale<=qmax; qscale++){
89 if (s->fdct == ff_jpeg_fdct_islow) {
91 const int j= s->idct_permutation[i];
92 /* 16 <= qscale * quant_matrix[i] <= 7905 */
93 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
94 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
95 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
97 qmat[qscale][j] = (int)((UINT64_C(1) << QMAT_SHIFT) /
98 (qscale * quant_matrix[j]));
100 } else if (s->fdct == fdct_ifast) {
102 const int j= s->idct_permutation[i];
103 /* 16 <= qscale * quant_matrix[i] <= 7905 */
104 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
105 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
106 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
108 qmat[qscale][j] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
109 (aanscales[i] * qscale * quant_matrix[j]));
113 const int j= s->idct_permutation[i];
114 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
115 So 16 <= qscale * quant_matrix[i] <= 7905
116 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
117 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
119 qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
120 qmat16[qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
122 if(qmat16[qscale][i]==0 || qmat16[qscale][i]==128*256) qmat16[qscale][i]=128*256-1;
123 qmat16_bias[qscale][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][i]);
128 // move into common.c perhaps
129 #define CHECKED_ALLOCZ(p, size)\
131 p= av_mallocz(size);\
138 static void build_end(void)
141 int lastIndexAfterPerm=0;
142 for(lastIndex=0; lastIndex<64; lastIndex++)
144 if(ff_zigzag_direct[lastIndex] > lastIndexAfterPerm)
145 lastIndexAfterPerm= ff_zigzag_direct[lastIndex];
146 zigzag_end[lastIndex]= lastIndexAfterPerm + 1;
150 void ff_init_scantable(MpegEncContext *s, ScanTable *st, const UINT8 *src_scantable){
156 j = src_scantable[i];
157 st->permutated[i] = s->idct_permutation[j];
163 j = st->permutated[i];
165 st->raster_end[i]= end;
169 /* XXX: those functions should be suppressed ASAP when all IDCTs are
171 static void ff_jref_idct_put(UINT8 *dest, int line_size, DCTELEM *block)
174 put_pixels_clamped(block, dest, line_size);
176 static void ff_jref_idct_add(UINT8 *dest, int line_size, DCTELEM *block)
179 add_pixels_clamped(block, dest, line_size);
182 /* init common structure for both encoder and decoder */
183 int MPV_common_init(MpegEncContext *s)
188 s->dct_unquantize_h263 = dct_unquantize_h263_c;
189 s->dct_unquantize_mpeg1 = dct_unquantize_mpeg1_c;
190 s->dct_unquantize_mpeg2 = dct_unquantize_mpeg2_c;
191 s->dct_quantize= dct_quantize_c;
193 if(s->avctx->dct_algo==FF_DCT_FASTINT)
194 s->fdct = fdct_ifast;
196 s->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
198 if(s->avctx->idct_algo==FF_IDCT_INT){
199 s->idct_put= ff_jref_idct_put;
200 s->idct_add= ff_jref_idct_add;
202 s->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
203 }else{ //accurate/default
204 s->idct_put= simple_idct_put;
205 s->idct_add= simple_idct_add;
207 s->idct_permutation[i]= i;
211 MPV_common_init_mmx(s);
214 MPV_common_init_axp(s);
217 MPV_common_init_mlib(s);
221 /* load & permutate scantables
222 note: only wmv uses differnt ones
224 ff_init_scantable(s, &s->inter_scantable , ff_zigzag_direct);
225 ff_init_scantable(s, &s->intra_scantable , ff_zigzag_direct);
226 ff_init_scantable(s, &s->intra_h_scantable, ff_alternate_horizontal_scan);
227 ff_init_scantable(s, &s->intra_v_scantable, ff_alternate_vertical_scan);
229 s->mb_width = (s->width + 15) / 16;
230 s->mb_height = (s->height + 15) / 16;
232 /* set default edge pos, will be overriden in decode_header if needed */
233 s->h_edge_pos= s->mb_width*16;
234 s->v_edge_pos= s->mb_height*16;
236 /* convert fourcc to upper case */
237 s->avctx->fourcc= toupper( s->avctx->fourcc &0xFF)
238 + (toupper((s->avctx->fourcc>>8 )&0xFF)<<8 )
239 + (toupper((s->avctx->fourcc>>16)&0xFF)<<16)
240 + (toupper((s->avctx->fourcc>>24)&0xFF)<<24);
242 s->mb_num = s->mb_width * s->mb_height;
243 if(!(s->flags&CODEC_FLAG_DR1)){
244 s->linesize = s->mb_width * 16 + 2 * EDGE_WIDTH;
245 s->uvlinesize = s->mb_width * 8 + EDGE_WIDTH;
248 int w, h, shift, pict_start;
251 h = s->mb_height * 16 + 2 * EDGE_WIDTH;
252 shift = (i == 0) ? 0 : 1;
253 c_size = (s->linesize>>shift) * (h >> shift);
254 pict_start = (s->linesize>>shift) * (EDGE_WIDTH >> shift) + (EDGE_WIDTH >> shift);
256 CHECKED_ALLOCZ(pict, c_size)
257 s->last_picture_base[i] = pict;
258 s->last_picture[i] = pict + pict_start;
259 if(i>0) memset(s->last_picture_base[i], 128, c_size);
261 CHECKED_ALLOCZ(pict, c_size)
262 s->next_picture_base[i] = pict;
263 s->next_picture[i] = pict + pict_start;
264 if(i>0) memset(s->next_picture_base[i], 128, c_size);
266 if (s->has_b_frames || s->codec_id==CODEC_ID_MPEG4) {
267 /* Note the MPEG4 stuff is here cuz of buggy encoders which dont set the low_delay flag but
268 do low-delay encoding, so we cant allways distinguish b-frame containing streams from low_delay streams */
269 CHECKED_ALLOCZ(pict, c_size)
270 s->aux_picture_base[i] = pict;
271 s->aux_picture[i] = pict + pict_start;
272 if(i>0) memset(s->aux_picture_base[i], 128, c_size);
275 s->ip_buffer_count= 2;
278 CHECKED_ALLOCZ(s->edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
282 int mv_table_size= (s->mb_width+2)*(s->mb_height+2);
284 CHECKED_ALLOCZ(s->mb_var , s->mb_num * sizeof(INT16))
285 CHECKED_ALLOCZ(s->mc_mb_var, s->mb_num * sizeof(INT16))
286 CHECKED_ALLOCZ(s->mb_mean , s->mb_num * sizeof(INT8))
288 /* Allocate MV tables */
289 CHECKED_ALLOCZ(s->p_mv_table , mv_table_size * 2 * sizeof(INT16))
290 CHECKED_ALLOCZ(s->b_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
291 CHECKED_ALLOCZ(s->b_back_mv_table , mv_table_size * 2 * sizeof(INT16))
292 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table , mv_table_size * 2 * sizeof(INT16))
293 CHECKED_ALLOCZ(s->b_bidir_back_mv_table , mv_table_size * 2 * sizeof(INT16))
294 CHECKED_ALLOCZ(s->b_direct_forw_mv_table, mv_table_size * 2 * sizeof(INT16))
295 CHECKED_ALLOCZ(s->b_direct_back_mv_table, mv_table_size * 2 * sizeof(INT16))
296 CHECKED_ALLOCZ(s->b_direct_mv_table , mv_table_size * 2 * sizeof(INT16))
298 CHECKED_ALLOCZ(s->me_scratchpad, s->linesize*16*3*sizeof(uint8_t))
300 CHECKED_ALLOCZ(s->me_map , ME_MAP_SIZE*sizeof(uint32_t))
301 CHECKED_ALLOCZ(s->me_score_map, ME_MAP_SIZE*sizeof(uint16_t))
304 for(j=0; j<REORDER_BUFFER_SIZE; j++){
310 h = s->mb_height * 16;
311 shift = (i == 0) ? 0 : 1;
312 c_size = (w >> shift) * (h >> shift);
314 CHECKED_ALLOCZ(pict, c_size);
315 s->picture_buffer[j][i] = pict;
320 if(s->codec_id==CODEC_ID_MPEG4){
321 CHECKED_ALLOCZ(s->tex_pb_buffer, PB_BUFFER_SIZE);
322 CHECKED_ALLOCZ( s->pb2_buffer, PB_BUFFER_SIZE);
325 if(s->msmpeg4_version){
326 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
328 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
331 if (s->out_format == FMT_H263 || s->encoding) {
333 /* Allocate MB type table */
334 CHECKED_ALLOCZ(s->mb_type , s->mb_num * sizeof(UINT8))
337 size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
338 CHECKED_ALLOCZ(s->motion_val, size * 2 * sizeof(INT16));
341 if(s->codec_id==CODEC_ID_MPEG4){
342 /* 4mv and interlaced direct mode decoding tables */
343 CHECKED_ALLOCZ(s->co_located_type_table, s->mb_num * sizeof(UINT8))
344 CHECKED_ALLOCZ(s->field_mv_table, s->mb_num*2*2 * sizeof(INT16))
345 CHECKED_ALLOCZ(s->field_select_table, s->mb_num*2* sizeof(INT8))
348 if (s->h263_pred || s->h263_plus) {
349 int y_size, c_size, i, size;
353 y_size = (2 * s->mb_width + 2) * (2 * s->mb_height + 2);
354 c_size = (s->mb_width + 2) * (s->mb_height + 2);
355 size = y_size + 2 * c_size;
356 CHECKED_ALLOCZ(s->dc_val[0], size * sizeof(INT16));
357 s->dc_val[1] = s->dc_val[0] + y_size;
358 s->dc_val[2] = s->dc_val[1] + c_size;
360 s->dc_val[0][i] = 1024;
363 CHECKED_ALLOCZ(s->ac_val[0], size * sizeof(INT16) * 16);
364 s->ac_val[1] = s->ac_val[0] + y_size;
365 s->ac_val[2] = s->ac_val[1] + c_size;
368 CHECKED_ALLOCZ(s->coded_block, y_size);
370 /* divx501 bitstream reorder buffer */
371 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
373 /* cbp, ac_pred, pred_dir */
374 CHECKED_ALLOCZ(s->cbp_table , s->mb_num * sizeof(UINT8))
375 CHECKED_ALLOCZ(s->pred_dir_table, s->mb_num * sizeof(UINT8))
377 CHECKED_ALLOCZ(s->qscale_table , s->mb_num * sizeof(UINT8))
379 /* which mb is a intra block */
380 CHECKED_ALLOCZ(s->mbintra_table, s->mb_num);
381 memset(s->mbintra_table, 1, s->mb_num);
383 /* default structure is frame */
384 s->picture_structure = PICT_FRAME;
386 /* init macroblock skip table */
387 CHECKED_ALLOCZ(s->mbskip_table, s->mb_num);
389 s->block= s->blocks[0];
391 s->context_initialized = 1;
401 /* init common structure for both encoder and decoder */
402 void MPV_common_end(MpegEncContext *s)
406 av_freep(&s->mb_type);
407 av_freep(&s->mb_var);
408 av_freep(&s->mc_mb_var);
409 av_freep(&s->mb_mean);
410 av_freep(&s->p_mv_table);
411 av_freep(&s->b_forw_mv_table);
412 av_freep(&s->b_back_mv_table);
413 av_freep(&s->b_bidir_forw_mv_table);
414 av_freep(&s->b_bidir_back_mv_table);
415 av_freep(&s->b_direct_forw_mv_table);
416 av_freep(&s->b_direct_back_mv_table);
417 av_freep(&s->b_direct_mv_table);
418 av_freep(&s->motion_val);
419 av_freep(&s->dc_val[0]);
420 av_freep(&s->ac_val[0]);
421 av_freep(&s->coded_block);
422 av_freep(&s->mbintra_table);
423 av_freep(&s->cbp_table);
424 av_freep(&s->pred_dir_table);
425 av_freep(&s->qscale_table);
426 av_freep(&s->me_scratchpad);
427 av_freep(&s->me_map);
428 av_freep(&s->me_score_map);
430 av_freep(&s->mbskip_table);
431 av_freep(&s->bitstream_buffer);
432 av_freep(&s->tex_pb_buffer);
433 av_freep(&s->pb2_buffer);
434 av_freep(&s->edge_emu_buffer);
435 av_freep(&s->co_located_type_table);
436 av_freep(&s->field_mv_table);
437 av_freep(&s->field_select_table);
438 av_freep(&s->avctx->stats_out);
439 av_freep(&s->ac_stats);
443 if(!(s->flags&CODEC_FLAG_DR1)){
444 av_freep(&s->last_picture_base[i]);
445 av_freep(&s->next_picture_base[i]);
446 av_freep(&s->aux_picture_base[i]);
448 s->last_picture_base[i]=
449 s->next_picture_base[i]=
450 s->aux_picture_base [i] = NULL;
453 s->aux_picture [i] = NULL;
455 for(j=0; j<REORDER_BUFFER_SIZE; j++){
456 av_freep(&s->picture_buffer[j][i]);
459 s->context_initialized = 0;
462 /* init video encoder */
463 int MPV_encode_init(AVCodecContext *avctx)
465 MpegEncContext *s = avctx->priv_data;
468 avctx->pix_fmt = PIX_FMT_YUV420P;
470 s->bit_rate = avctx->bit_rate;
471 s->bit_rate_tolerance = avctx->bit_rate_tolerance;
472 s->frame_rate = avctx->frame_rate;
473 s->width = avctx->width;
474 s->height = avctx->height;
475 if(avctx->gop_size > 600){
476 fprintf(stderr, "Warning keyframe interval too large! reducing it ...\n");
479 s->gop_size = avctx->gop_size;
480 s->rtp_mode = avctx->rtp_mode;
481 s->rtp_payload_size = avctx->rtp_payload_size;
482 if (avctx->rtp_callback)
483 s->rtp_callback = avctx->rtp_callback;
484 s->qmin= avctx->qmin;
485 s->qmax= avctx->qmax;
486 s->max_qdiff= avctx->max_qdiff;
487 s->qcompress= avctx->qcompress;
488 s->qblur= avctx->qblur;
490 s->aspect_ratio_info= avctx->aspect_ratio_info;
491 if (avctx->aspect_ratio_info == FF_ASPECT_EXTENDED)
493 s->aspected_width = avctx->aspected_width;
494 s->aspected_height = avctx->aspected_height;
496 s->flags= avctx->flags;
497 s->max_b_frames= avctx->max_b_frames;
498 s->b_frame_strategy= avctx->b_frame_strategy;
499 s->codec_id= avctx->codec->id;
500 s->luma_elim_threshold = avctx->luma_elim_threshold;
501 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
502 s->strict_std_compliance= avctx->strict_std_compliance;
503 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
504 s->mpeg_quant= avctx->mpeg_quant;
506 if (s->gop_size <= 1) {
514 if (avctx->me_method == 0)
515 /* For compatibility */
516 s->me_method = motion_estimation_method;
518 s->me_method = avctx->me_method;
521 s->fixed_qscale = (avctx->flags & CODEC_FLAG_QSCALE);
523 s->adaptive_quant= ( s->avctx->lumi_masking
524 || s->avctx->dark_masking
525 || s->avctx->temporal_cplx_masking
526 || s->avctx->spatial_cplx_masking
527 || s->avctx->p_masking)
530 s->progressive_sequence= !(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
532 switch(avctx->codec->id) {
533 case CODEC_ID_MPEG1VIDEO:
534 s->out_format = FMT_MPEG1;
535 avctx->delay=0; //FIXME not sure, should check the spec
538 s->out_format = FMT_MJPEG;
539 s->intra_only = 1; /* force intra only for jpeg */
540 s->mjpeg_write_tables = 1; /* write all tables */
541 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
542 s->mjpeg_vsample[0] = 2; /* set up default sampling factors */
543 s->mjpeg_vsample[1] = 1; /* the only currently supported values */
544 s->mjpeg_vsample[2] = 1;
545 s->mjpeg_hsample[0] = 2;
546 s->mjpeg_hsample[1] = 1;
547 s->mjpeg_hsample[2] = 1;
548 if (mjpeg_init(s) < 0)
553 if (h263_get_picture_format(s->width, s->height) == 7) {
554 printf("Input picture size isn't suitable for h263 codec! try h263+\n");
557 s->out_format = FMT_H263;
561 s->out_format = FMT_H263;
563 s->rtp_payload_size = 1200;
565 s->unrestricted_mv = 1;
568 /* These are just to be sure */
574 s->out_format = FMT_H263;
579 s->out_format = FMT_H263;
581 s->unrestricted_mv = 1;
582 s->has_b_frames= s->max_b_frames ? 1 : 0;
584 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
586 case CODEC_ID_MSMPEG4V1:
587 s->out_format = FMT_H263;
590 s->unrestricted_mv = 1;
591 s->msmpeg4_version= 1;
594 case CODEC_ID_MSMPEG4V2:
595 s->out_format = FMT_H263;
598 s->unrestricted_mv = 1;
599 s->msmpeg4_version= 2;
602 case CODEC_ID_MSMPEG4V3:
603 s->out_format = FMT_H263;
606 s->unrestricted_mv = 1;
607 s->msmpeg4_version= 3;
611 s->out_format = FMT_H263;
614 s->unrestricted_mv = 1;
615 s->msmpeg4_version= 4;
619 s->out_format = FMT_H263;
622 s->unrestricted_mv = 1;
623 s->msmpeg4_version= 5;
630 { /* set up some save defaults, some codecs might override them later */
635 memset(default_mv_penalty, 0, sizeof(UINT16)*(MAX_FCODE+1)*(2*MAX_MV+1));
636 memset(default_fcode_tab , 0, sizeof(UINT8)*(2*MAX_MV+1));
638 for(i=-16; i<16; i++){
639 default_fcode_tab[i + MAX_MV]= 1;
643 s->mv_penalty= default_mv_penalty;
644 s->fcode_tab= default_fcode_tab;
646 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
648 /* dont use mv_penalty table for crap MV as it would be confused */
649 if (s->me_method < ME_EPZS) s->mv_penalty = default_mv_penalty;
654 if (MPV_common_init(s) < 0)
657 if (s->out_format == FMT_H263)
659 else if (s->out_format == FMT_MPEG1)
660 ff_mpeg1_encode_init(s);
661 if(s->msmpeg4_version)
662 ff_msmpeg4_encode_init(s);
664 /* init default q matrix */
666 int j= s->idct_permutation[i];
667 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
668 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
669 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
670 }else if(s->out_format == FMT_H263){
672 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
674 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
675 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
679 /* precompute matrix */
680 /* for mjpeg, we do include qscale in the matrix */
681 if (s->out_format != FMT_MJPEG) {
682 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16, s->q_intra_matrix16_bias,
683 s->intra_matrix, s->intra_quant_bias, 1, 31);
684 convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16, s->q_inter_matrix16_bias,
685 s->inter_matrix, s->inter_quant_bias, 1, 31);
688 if(ff_rate_control_init(s) < 0)
691 s->picture_number = 0;
692 s->picture_in_gop_number = 0;
693 s->fake_picture_number = 0;
694 /* motion detector init */
701 int MPV_encode_end(AVCodecContext *avctx)
703 MpegEncContext *s = avctx->priv_data;
709 ff_rate_control_uninit(s);
712 if (s->out_format == FMT_MJPEG)
718 /* draw the edges of width 'w' of an image of size width, height */
719 //FIXME check that this is ok for mpeg4 interlaced
720 static void draw_edges_c(UINT8 *buf, int wrap, int width, int height, int w)
722 UINT8 *ptr, *last_line;
725 last_line = buf + (height - 1) * wrap;
728 memcpy(buf - (i + 1) * wrap, buf, width);
729 memcpy(last_line + (i + 1) * wrap, last_line, width);
733 for(i=0;i<height;i++) {
734 memset(ptr - w, ptr[0], w);
735 memset(ptr + width, ptr[width-1], w);
740 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
741 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
742 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
743 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
747 /* generic function for encode/decode called before a frame is coded/decoded */
748 void MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
755 avctx->mbskip_table= s->mbskip_table;
757 if(avctx->flags&CODEC_FLAG_DR1){
758 avctx->get_buffer_callback(avctx, s->width, s->height, s->pict_type);
760 s->linesize = avctx->dr_stride;
761 s->uvlinesize= avctx->dr_uvstride;
762 s->ip_buffer_count= avctx->dr_ip_buffer_count;
764 avctx->dr_ip_buffer_count= s->ip_buffer_count;
766 if (s->pict_type == B_TYPE) {
768 if(avctx->flags&CODEC_FLAG_DR1)
769 s->aux_picture[i]= avctx->dr_buffer[i];
771 //FIXME the following should never be needed, the decoder should drop b frames if no reference is available
772 if(s->next_picture[i]==NULL)
773 s->next_picture[i]= s->aux_picture[i];
774 if(s->last_picture[i]==NULL)
775 s->last_picture[i]= s->next_picture[i];
777 s->current_picture[i] = s->aux_picture[i];
781 /* swap next and last */
782 if(avctx->flags&CODEC_FLAG_DR1)
783 tmp= avctx->dr_buffer[i];
785 tmp = s->last_picture[i];
787 s->last_picture[i] = s->next_picture[i];
788 s->next_picture[i] = tmp;
789 s->current_picture[i] = tmp;
791 if(s->last_picture[i]==NULL)
792 s->last_picture[i]= s->next_picture[i];
794 s->last_dr_opaque= s->next_dr_opaque;
795 s->next_dr_opaque= avctx->dr_opaque_frame;
797 if(s->has_b_frames && s->last_dr_opaque && s->codec_id!=CODEC_ID_SVQ1)
798 avctx->dr_opaque_frame= s->last_dr_opaque;
800 avctx->dr_opaque_frame= s->next_dr_opaque;
803 /* set dequantizer, we cant do it during init as it might change for mpeg4
804 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
805 if(s->out_format == FMT_H263){
807 s->dct_unquantize = s->dct_unquantize_mpeg2;
809 s->dct_unquantize = s->dct_unquantize_h263;
811 s->dct_unquantize = s->dct_unquantize_mpeg1;
814 /* generic function for encode/decode called after a frame has been coded/decoded */
815 void MPV_frame_end(MpegEncContext *s)
817 s->avctx->key_frame = (s->pict_type == I_TYPE);
818 s->avctx->pict_type = s->pict_type;
820 /* draw edge for correct motion prediction if outside */
821 if (s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
822 draw_edges(s->current_picture[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
823 draw_edges(s->current_picture[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
824 draw_edges(s->current_picture[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
828 s->last_pict_type = s->pict_type;
829 if(s->pict_type!=B_TYPE){
830 s->last_non_b_pict_type= s->pict_type;
831 s->num_available_buffers++;
832 if(s->num_available_buffers>2) s->num_available_buffers= 2;
836 /* reorder input for encoding */
837 void reorder_input(MpegEncContext *s, AVPicture *pict)
841 if(s->max_b_frames > FF_MAX_B_FRAMES) s->max_b_frames= FF_MAX_B_FRAMES;
843 // delay= s->max_b_frames+1; (or 0 if no b frames cuz decoder diff)
845 for(j=0; j<REORDER_BUFFER_SIZE-1; j++){
846 s->coded_order[j]= s->coded_order[j+1];
848 s->coded_order[j].picture[0]= s->coded_order[j].picture[1]= s->coded_order[j].picture[2]= NULL; //catch uninitalized buffers
849 s->coded_order[j].pict_type=0;
851 switch(s->input_pict_type){
856 index= s->max_b_frames - s->b_frames_since_non_b;
857 s->b_frames_since_non_b=0;
860 index= s->max_b_frames + 1;
861 s->b_frames_since_non_b++;
864 //printf("index:%d type:%d strides: %d %d\n", index, s->input_pict_type, pict->linesize[0], s->linesize);
865 if( (index==0 || (s->flags&CODEC_FLAG_INPUT_PRESERVED))
866 && pict->linesize[0] == s->linesize
867 && pict->linesize[1] == s->uvlinesize
868 && pict->linesize[2] == s->uvlinesize){
871 s->coded_order[index].picture[i]= pict->data[i];
876 uint8_t *src = pict->data[i];
878 int src_wrap = pict->linesize[i];
879 int dest_wrap = s->linesize;
883 if(index==0) dest= s->last_picture[i]+16; //is current_picture indeed but the switch hapens after reordering
884 else dest= s->picture_buffer[s->picture_buffer_index][i];
892 s->coded_order[index].picture[i]= dest;
894 memcpy(dest, src, w);
900 s->picture_buffer_index++;
901 if(s->picture_buffer_index >= REORDER_BUFFER_SIZE) s->picture_buffer_index=0;
904 s->coded_order[index].pict_type = s->input_pict_type;
905 s->coded_order[index].qscale = s->input_qscale;
906 s->coded_order[index].force_type= s->force_input_type;
907 s->coded_order[index].picture_in_gop_number= s->input_picture_in_gop_number;
908 s->coded_order[index].picture_number= s->input_picture_number;
911 s->new_picture[i]= s->coded_order[0].picture[i];
915 int MPV_encode_picture(AVCodecContext *avctx,
916 unsigned char *buf, int buf_size, void *data)
918 MpegEncContext *s = avctx->priv_data;
919 AVPicture *pict = data;
921 s->input_qscale = avctx->quality;
923 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
925 if(avctx->flags&CODEC_FLAG_TYPE){
927 s->force_input_type= avctx->key_frame ? I_TYPE : P_TYPE;
928 }else if(s->flags&CODEC_FLAG_PASS2){
930 s->force_input_type= s->rc_context.entry[s->input_picture_number].new_pict_type;
932 s->force_input_type=0;
933 if (!s->intra_only) {
934 /* first picture of GOP is intra */
935 if (s->input_picture_in_gop_number % s->gop_size==0){
936 s->input_pict_type = I_TYPE;
937 }else if(s->max_b_frames==0){
938 s->input_pict_type = P_TYPE;
940 if(s->b_frames_since_non_b < s->max_b_frames) //FIXME more IQ
941 s->input_pict_type = B_TYPE;
943 s->input_pict_type = P_TYPE;
946 s->input_pict_type = I_TYPE;
950 if(s->input_pict_type==I_TYPE)
951 s->input_picture_in_gop_number=0;
953 reorder_input(s, pict);
956 if(s->coded_order[0].picture[0]){
958 s->pict_type= s->coded_order[0].pict_type;
959 if (s->fixed_qscale) /* the ratecontrol needs the last qscale so we dont touch it for CBR */
960 s->qscale= s->coded_order[0].qscale;
961 s->force_type= s->coded_order[0].force_type;
962 s->picture_in_gop_number= s->coded_order[0].picture_in_gop_number;
963 s->picture_number= s->coded_order[0].picture_number;
965 MPV_frame_start(s, avctx);
967 encode_picture(s, s->picture_number);
969 avctx->real_pict_num = s->picture_number;
970 avctx->header_bits = s->header_bits;
971 avctx->mv_bits = s->mv_bits;
972 avctx->misc_bits = s->misc_bits;
973 avctx->i_tex_bits = s->i_tex_bits;
974 avctx->p_tex_bits = s->p_tex_bits;
975 avctx->i_count = s->i_count;
976 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
977 avctx->skip_count = s->skip_count;
981 if (s->out_format == FMT_MJPEG)
982 mjpeg_picture_trailer(s);
985 avctx->quality = s->qscale;
987 if(s->flags&CODEC_FLAG_PASS1)
988 ff_write_pass1_stats(s);
992 s->input_picture_number++;
993 s->input_picture_in_gop_number++;
995 flush_put_bits(&s->pb);
996 s->frame_bits = (pbBufPtr(&s->pb) - s->pb.buf) * 8;
998 s->total_bits += s->frame_bits;
999 avctx->frame_bits = s->frame_bits;
1000 //printf("fcode: %d, type: %d, head: %d, mv: %d, misc: %d, frame: %d, itex: %d, ptex: %d\n",
1001 //s->f_code, avctx->key_frame, s->header_bits, s->mv_bits, s->misc_bits, s->frame_bits, s->i_tex_bits, s->p_tex_bits);
1002 #if 0 //dump some stats to stats.txt for testing/debuging
1003 if(s->max_b_frames==0)
1005 static FILE *f=NULL;
1006 if(!f) f= fopen("stats.txt", "wb");
1007 get_psnr(pict->data, s->current_picture,
1008 pict->linesize, s->linesize, avctx);
1009 fprintf(f, "%7d, %7d, %2.4f\n", pbBufPtr(&s->pb) - s->pb.buf, s->qscale, avctx->psnr_y);
1013 if (avctx->get_psnr) {
1014 /* At this point pict->data should have the original frame */
1015 /* an s->current_picture should have the coded/decoded frame */
1016 get_psnr(pict->data, s->current_picture,
1017 pict->linesize, s->linesize, avctx);
1018 // printf("%f\n", avctx->psnr_y);
1020 return pbBufPtr(&s->pb) - s->pb.buf;
1023 static inline void gmc1_motion(MpegEncContext *s,
1024 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1026 UINT8 **ref_picture, int src_offset,
1030 int offset, src_x, src_y, linesize, uvlinesize;
1031 int motion_x, motion_y;
1034 if(s->real_sprite_warping_points>1) printf("more than 1 warp point isnt supported\n");
1035 motion_x= s->sprite_offset[0][0];
1036 motion_y= s->sprite_offset[0][1];
1037 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
1038 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
1039 motion_x<<=(3-s->sprite_warping_accuracy);
1040 motion_y<<=(3-s->sprite_warping_accuracy);
1041 src_x = clip(src_x, -16, s->width);
1042 if (src_x == s->width)
1044 src_y = clip(src_y, -16, s->height);
1045 if (src_y == s->height)
1048 linesize = s->linesize;
1049 uvlinesize = s->uvlinesize;
1050 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1052 dest_y+=dest_offset;
1053 if(s->flags&CODEC_FLAG_EMU_EDGE){
1054 if(src_x<0 || src_y<0 || src_x + (motion_x&15) + 16 > s->h_edge_pos
1055 || src_y + (motion_y&15) + h > s->v_edge_pos){
1056 emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1057 ptr= s->edge_emu_buffer;
1061 gmc1(dest_y , ptr , linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1062 gmc1(dest_y+8, ptr+8, linesize, h, motion_x&15, motion_y&15, s->no_rounding);
1064 motion_x= s->sprite_offset[1][0];
1065 motion_y= s->sprite_offset[1][1];
1066 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
1067 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
1068 motion_x<<=(3-s->sprite_warping_accuracy);
1069 motion_y<<=(3-s->sprite_warping_accuracy);
1070 src_x = clip(src_x, -8, s->width>>1);
1071 if (src_x == s->width>>1)
1073 src_y = clip(src_y, -8, s->height>>1);
1074 if (src_y == s->height>>1)
1077 offset = (src_y * uvlinesize) + src_x + (src_offset>>1);
1078 ptr = ref_picture[1] + offset;
1080 emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1081 ptr= s->edge_emu_buffer;
1083 gmc1(dest_cb + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1085 ptr = ref_picture[2] + offset;
1087 emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1088 ptr= s->edge_emu_buffer;
1090 gmc1(dest_cr + (dest_offset>>1), ptr, uvlinesize, h>>1, motion_x&15, motion_y&15, s->no_rounding);
1095 static void emulated_edge_mc(MpegEncContext *s, UINT8 *src, int linesize, int block_w, int block_h,
1096 int src_x, int src_y, int w, int h){
1098 int start_y, start_x, end_y, end_x;
1099 UINT8 *buf= s->edge_emu_buffer;
1102 src+= (h-1-src_y)*linesize;
1104 }else if(src_y<=-block_h){
1105 src+= (1-block_h-src_y)*linesize;
1111 }else if(src_x<=-block_w){
1112 src+= (1-block_w-src_x);
1116 start_y= MAX(0, -src_y);
1117 start_x= MAX(0, -src_x);
1118 end_y= MIN(block_h, h-src_y);
1119 end_x= MIN(block_w, w-src_x);
1121 // copy existing part
1122 for(y=start_y; y<end_y; y++){
1123 for(x=start_x; x<end_x; x++){
1124 buf[x + y*linesize]= src[x + y*linesize];
1129 for(y=0; y<start_y; y++){
1130 for(x=start_x; x<end_x; x++){
1131 buf[x + y*linesize]= buf[x + start_y*linesize];
1136 for(y=end_y; y<block_h; y++){
1137 for(x=start_x; x<end_x; x++){
1138 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1142 for(y=0; y<block_h; y++){
1144 for(x=0; x<start_x; x++){
1145 buf[x + y*linesize]= buf[start_x + y*linesize];
1149 for(x=end_x; x<block_w; x++){
1150 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1156 /* apply one mpeg motion vector to the three components */
1157 static inline void mpeg_motion(MpegEncContext *s,
1158 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1160 UINT8 **ref_picture, int src_offset,
1161 int field_based, op_pixels_func (*pix_op)[4],
1162 int motion_x, int motion_y, int h)
1165 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1168 if(s->quarter_sample)
1174 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1175 src_x = s->mb_x * 16 + (motion_x >> 1);
1176 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 1);
1178 /* WARNING: do no forget half pels */
1179 height = s->height >> field_based;
1180 v_edge_pos = s->v_edge_pos >> field_based;
1181 src_x = clip(src_x, -16, s->width);
1182 if (src_x == s->width)
1184 src_y = clip(src_y, -16, height);
1185 if (src_y == height)
1187 linesize = s->linesize << field_based;
1188 uvlinesize = s->uvlinesize << field_based;
1189 ptr = ref_picture[0] + (src_y * linesize) + (src_x) + src_offset;
1190 dest_y += dest_offset;
1192 if(s->flags&CODEC_FLAG_EMU_EDGE){
1193 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 16 > s->h_edge_pos
1194 || src_y + (motion_y&1) + h > v_edge_pos){
1195 emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1196 ptr= s->edge_emu_buffer;
1200 pix_op[0][dxy](dest_y, ptr, linesize, h);
1202 if(s->flags&CODEC_FLAG_GRAY) return;
1204 if (s->out_format == FMT_H263) {
1206 if ((motion_x & 3) != 0)
1208 if ((motion_y & 3) != 0)
1215 dxy = ((my & 1) << 1) | (mx & 1);
1220 src_x = s->mb_x * 8 + mx;
1221 src_y = s->mb_y * (8 >> field_based) + my;
1222 src_x = clip(src_x, -8, s->width >> 1);
1223 if (src_x == (s->width >> 1))
1225 src_y = clip(src_y, -8, height >> 1);
1226 if (src_y == (height >> 1))
1228 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1229 ptr = ref_picture[1] + offset;
1231 emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1232 ptr= s->edge_emu_buffer;
1234 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1236 ptr = ref_picture[2] + offset;
1238 emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1239 ptr= s->edge_emu_buffer;
1241 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1244 static inline void qpel_motion(MpegEncContext *s,
1245 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1247 UINT8 **ref_picture, int src_offset,
1248 int field_based, op_pixels_func (*pix_op)[4],
1249 qpel_mc_func (*qpix_op)[16],
1250 int motion_x, int motion_y, int h)
1253 int dxy, offset, mx, my, src_x, src_y, height, v_edge_pos, linesize, uvlinesize;
1256 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1257 src_x = s->mb_x * 16 + (motion_x >> 2);
1258 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
1260 height = s->height >> field_based;
1261 v_edge_pos = s->v_edge_pos >> field_based;
1262 src_x = clip(src_x, -16, s->width);
1263 if (src_x == s->width)
1265 src_y = clip(src_y, -16, height);
1266 if (src_y == height)
1268 linesize = s->linesize << field_based;
1269 uvlinesize = s->uvlinesize << field_based;
1270 ptr = ref_picture[0] + (src_y * linesize) + src_x + src_offset;
1271 dest_y += dest_offset;
1272 //printf("%d %d %d\n", src_x, src_y, dxy);
1274 if(s->flags&CODEC_FLAG_EMU_EDGE){
1275 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 16 > s->h_edge_pos
1276 || src_y + (motion_y&3) + h > v_edge_pos){
1277 emulated_edge_mc(s, ptr, linesize, 17, h+1, src_x, src_y, s->h_edge_pos, v_edge_pos);
1278 ptr= s->edge_emu_buffer;
1283 qpix_op[0][dxy](dest_y, ptr, linesize);
1285 //damn interlaced mode
1286 //FIXME boundary mirroring is not exactly correct here
1287 qpix_op[1][dxy](dest_y , ptr , linesize);
1288 qpix_op[1][dxy](dest_y+8, ptr+8, linesize);
1291 if(s->flags&CODEC_FLAG_GRAY) return;
1296 }else if(s->divx_version){
1297 mx= (motion_x>>1)|(motion_x&1);
1298 my= (motion_y>>1)|(motion_y&1);
1305 dxy= (mx&1) | ((my&1)<<1);
1309 src_x = s->mb_x * 8 + mx;
1310 src_y = s->mb_y * (8 >> field_based) + my;
1311 src_x = clip(src_x, -8, s->width >> 1);
1312 if (src_x == (s->width >> 1))
1314 src_y = clip(src_y, -8, height >> 1);
1315 if (src_y == (height >> 1))
1318 offset = (src_y * uvlinesize) + src_x + (src_offset >> 1);
1319 ptr = ref_picture[1] + offset;
1321 emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1322 ptr= s->edge_emu_buffer;
1324 pix_op[1][dxy](dest_cb + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1326 ptr = ref_picture[2] + offset;
1328 emulated_edge_mc(s, ptr, uvlinesize, 9, (h>>1)+1, src_x, src_y, s->h_edge_pos>>1, v_edge_pos>>1);
1329 ptr= s->edge_emu_buffer;
1331 pix_op[1][dxy](dest_cr + (dest_offset >> 1), ptr, uvlinesize, h >> 1);
1335 static inline void MPV_motion(MpegEncContext *s,
1336 UINT8 *dest_y, UINT8 *dest_cb, UINT8 *dest_cr,
1337 int dir, UINT8 **ref_picture,
1338 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
1340 int dxy, offset, mx, my, src_x, src_y, motion_x, motion_y;
1348 switch(s->mv_type) {
1351 gmc1_motion(s, dest_y, dest_cb, dest_cr, 0,
1354 }else if(s->quarter_sample){
1355 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1358 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1360 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1363 s->mv[dir][0][0], s->mv[dir][0][1], 16);
1369 if(s->quarter_sample){
1371 motion_x = s->mv[dir][i][0];
1372 motion_y = s->mv[dir][i][1];
1374 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
1375 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
1376 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
1378 /* WARNING: do no forget half pels */
1379 src_x = clip(src_x, -16, s->width);
1380 if (src_x == s->width)
1382 src_y = clip(src_y, -16, s->height);
1383 if (src_y == s->height)
1386 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1387 if(s->flags&CODEC_FLAG_EMU_EDGE){
1388 if(src_x<0 || src_y<0 || src_x + (motion_x&3) + 8 > s->h_edge_pos
1389 || src_y + (motion_y&3) + 8 > s->v_edge_pos){
1390 emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1391 ptr= s->edge_emu_buffer;
1394 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1395 qpix_op[1][dxy](dest, ptr, s->linesize);
1397 mx += s->mv[dir][i][0]/2;
1398 my += s->mv[dir][i][1]/2;
1402 motion_x = s->mv[dir][i][0];
1403 motion_y = s->mv[dir][i][1];
1405 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
1406 src_x = mb_x * 16 + (motion_x >> 1) + (i & 1) * 8;
1407 src_y = mb_y * 16 + (motion_y >> 1) + (i >>1) * 8;
1409 /* WARNING: do no forget half pels */
1410 src_x = clip(src_x, -16, s->width);
1411 if (src_x == s->width)
1413 src_y = clip(src_y, -16, s->height);
1414 if (src_y == s->height)
1417 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
1418 if(s->flags&CODEC_FLAG_EMU_EDGE){
1419 if(src_x<0 || src_y<0 || src_x + (motion_x&1) + 8 > s->h_edge_pos
1420 || src_y + (motion_y&1) + 8 > s->v_edge_pos){
1421 emulated_edge_mc(s, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1422 ptr= s->edge_emu_buffer;
1425 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
1426 pix_op[1][dxy](dest, ptr, s->linesize, 8);
1428 mx += s->mv[dir][i][0];
1429 my += s->mv[dir][i][1];
1433 if(s->flags&CODEC_FLAG_GRAY) break;
1434 /* In case of 8X8, we construct a single chroma motion vector
1435 with a special rounding */
1439 mx = (h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1442 mx = -(h263_chroma_roundtab[mx & 0xf] + ((mx >> 3) & ~1));
1445 my = (h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1448 my = -(h263_chroma_roundtab[my & 0xf] + ((my >> 3) & ~1));
1450 dxy = ((my & 1) << 1) | (mx & 1);
1454 src_x = mb_x * 8 + mx;
1455 src_y = mb_y * 8 + my;
1456 src_x = clip(src_x, -8, s->width/2);
1457 if (src_x == s->width/2)
1459 src_y = clip(src_y, -8, s->height/2);
1460 if (src_y == s->height/2)
1463 offset = (src_y * (s->uvlinesize)) + src_x;
1464 ptr = ref_picture[1] + offset;
1465 if(s->flags&CODEC_FLAG_EMU_EDGE){
1466 if(src_x<0 || src_y<0 || src_x + (dxy &1) + 8 > s->h_edge_pos>>1
1467 || src_y + (dxy>>1) + 8 > s->v_edge_pos>>1){
1468 emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1469 ptr= s->edge_emu_buffer;
1473 pix_op[1][dxy](dest_cb, ptr, s->uvlinesize, 8);
1475 ptr = ref_picture[2] + offset;
1477 emulated_edge_mc(s, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
1478 ptr= s->edge_emu_buffer;
1480 pix_op[1][dxy](dest_cr, ptr, s->uvlinesize, 8);
1483 if (s->picture_structure == PICT_FRAME) {
1484 if(s->quarter_sample){
1486 qpel_motion(s, dest_y, dest_cb, dest_cr, 0,
1487 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1489 s->mv[dir][0][0], s->mv[dir][0][1], 8);
1491 qpel_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1492 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1494 s->mv[dir][1][0], s->mv[dir][1][1], 8);
1497 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
1498 ref_picture, s->field_select[dir][0] ? s->linesize : 0,
1500 s->mv[dir][0][0], s->mv[dir][0][1], 8);
1502 mpeg_motion(s, dest_y, dest_cb, dest_cr, s->linesize,
1503 ref_picture, s->field_select[dir][1] ? s->linesize : 0,
1505 s->mv[dir][1][0], s->mv[dir][1][1], 8);
1516 /* put block[] to dest[] */
1517 static inline void put_dct(MpegEncContext *s,
1518 DCTELEM *block, int i, UINT8 *dest, int line_size)
1521 s->dct_unquantize(s, block, i, s->qscale);
1522 s->idct_put (dest, line_size, block);
1525 /* add block[] to dest[] */
1526 static inline void add_dct(MpegEncContext *s,
1527 DCTELEM *block, int i, UINT8 *dest, int line_size)
1529 if (s->block_last_index[i] >= 0) {
1530 s->idct_add (dest, line_size, block);
1534 static inline void add_dequant_dct(MpegEncContext *s,
1535 DCTELEM *block, int i, UINT8 *dest, int line_size)
1537 if (s->block_last_index[i] >= 0) {
1538 s->dct_unquantize(s, block, i, s->qscale);
1540 s->idct_add (dest, line_size, block);
1545 * cleans dc, ac, coded_block for the current non intra MB
1547 void ff_clean_intra_table_entries(MpegEncContext *s)
1549 int wrap = s->block_wrap[0];
1550 int xy = s->block_index[0];
1553 s->dc_val[0][xy + 1 ] =
1554 s->dc_val[0][xy + wrap] =
1555 s->dc_val[0][xy + 1 + wrap] = 1024;
1557 memset(s->ac_val[0][xy ], 0, 32 * sizeof(INT16));
1558 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(INT16));
1559 if (s->msmpeg4_version>=3) {
1560 s->coded_block[xy ] =
1561 s->coded_block[xy + 1 ] =
1562 s->coded_block[xy + wrap] =
1563 s->coded_block[xy + 1 + wrap] = 0;
1566 wrap = s->block_wrap[4];
1567 xy = s->mb_x + 1 + (s->mb_y + 1) * wrap;
1569 s->dc_val[2][xy] = 1024;
1571 memset(s->ac_val[1][xy], 0, 16 * sizeof(INT16));
1572 memset(s->ac_val[2][xy], 0, 16 * sizeof(INT16));
1574 s->mbintra_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1577 /* generic function called after a macroblock has been parsed by the
1578 decoder or after it has been encoded by the encoder.
1580 Important variables used:
1581 s->mb_intra : true if intra macroblock
1582 s->mv_dir : motion vector direction
1583 s->mv_type : motion vector type
1584 s->mv : motion vector
1585 s->interlaced_dct : true if interlaced dct used (mpeg2)
1587 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1590 const int mb_xy = s->mb_y * s->mb_width + s->mb_x;
1595 #ifdef FF_POSTPROCESS
1596 /* Obsolete. Exists for compatibility with mplayer only. */
1597 quant_store[mb_y][mb_x]=s->qscale;
1598 //printf("[%02d][%02d] %d\n",mb_x,mb_y,s->qscale);
1600 /* even more obsolete, exists for mplayer xp only */
1601 if(s->avctx->quant_store) s->avctx->quant_store[mb_y*s->avctx->qstride+mb_x] = s->qscale;
1603 s->qscale_table[mb_xy]= s->qscale;
1605 /* update DC predictors for P macroblocks */
1607 if (s->h263_pred || s->h263_aic) {
1608 if(s->mbintra_table[mb_xy])
1609 ff_clean_intra_table_entries(s);
1613 s->last_dc[2] = 128 << s->intra_dc_precision;
1616 else if (s->h263_pred || s->h263_aic)
1617 s->mbintra_table[mb_xy]=1;
1619 /* update motion predictor, not for B-frames as they need the motion_val from the last P/S-Frame */
1620 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE) { //FIXME move into h263.c if possible, format specific stuff shouldnt be here
1622 const int wrap = s->block_wrap[0];
1623 const int xy = s->block_index[0];
1624 const int mb_index= s->mb_x + s->mb_y*s->mb_width;
1625 if(s->mv_type == MV_TYPE_8X8){
1626 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_4MV;
1628 int motion_x, motion_y;
1632 if(s->co_located_type_table)
1633 s->co_located_type_table[mb_index]= 0;
1634 } else if (s->mv_type == MV_TYPE_16X16) {
1635 motion_x = s->mv[0][0][0];
1636 motion_y = s->mv[0][0][1];
1637 if(s->co_located_type_table)
1638 s->co_located_type_table[mb_index]= 0;
1639 } else /*if (s->mv_type == MV_TYPE_FIELD)*/ {
1641 motion_x = s->mv[0][0][0] + s->mv[0][1][0];
1642 motion_y = s->mv[0][0][1] + s->mv[0][1][1];
1643 motion_x = (motion_x>>1) | (motion_x&1);
1645 s->field_mv_table[mb_index][i][0]= s->mv[0][i][0];
1646 s->field_mv_table[mb_index][i][1]= s->mv[0][i][1];
1647 s->field_select_table[mb_index][i]= s->field_select[0][i];
1649 s->co_located_type_table[mb_index]= CO_LOCATED_TYPE_FIELDMV;
1651 /* no update if 8X8 because it has been done during parsing */
1652 s->motion_val[xy][0] = motion_x;
1653 s->motion_val[xy][1] = motion_y;
1654 s->motion_val[xy + 1][0] = motion_x;
1655 s->motion_val[xy + 1][1] = motion_y;
1656 s->motion_val[xy + wrap][0] = motion_x;
1657 s->motion_val[xy + wrap][1] = motion_y;
1658 s->motion_val[xy + 1 + wrap][0] = motion_x;
1659 s->motion_val[xy + 1 + wrap][1] = motion_y;
1663 if (!(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) {
1664 UINT8 *dest_y, *dest_cb, *dest_cr;
1665 int dct_linesize, dct_offset;
1666 op_pixels_func (*op_pix)[4];
1667 qpel_mc_func (*op_qpix)[16];
1669 /* avoid copy if macroblock skipped in last frame too
1670 dont touch it for B-frames as they need the skip info from the next p-frame */
1671 if (s->pict_type != B_TYPE) {
1672 UINT8 *mbskip_ptr = &s->mbskip_table[mb_xy];
1676 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
1677 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1679 /* if previous was skipped too, then nothing to do !
1680 skip only during decoding as we might trash the buffers during encoding a bit */
1681 if (*mbskip_ptr >= s->ip_buffer_count && !s->encoding)
1684 *mbskip_ptr = 0; /* not skipped */
1688 dest_y = s->current_picture [0] + (mb_y * 16* s->linesize ) + mb_x * 16;
1689 dest_cb = s->current_picture[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1690 dest_cr = s->current_picture[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
1692 if (s->interlaced_dct) {
1693 dct_linesize = s->linesize * 2;
1694 dct_offset = s->linesize;
1696 dct_linesize = s->linesize;
1697 dct_offset = s->linesize * 8;
1701 /* motion handling */
1702 /* decoding or more than one mb_type (MC was allready done otherwise) */
1703 if((!s->encoding) || (s->mb_type[mb_xy]&(s->mb_type[mb_xy]-1))){
1704 if ((!s->no_rounding) || s->pict_type==B_TYPE){
1705 op_pix = put_pixels_tab;
1706 op_qpix= put_qpel_pixels_tab;
1708 op_pix = put_no_rnd_pixels_tab;
1709 op_qpix= put_no_rnd_qpel_pixels_tab;
1712 if (s->mv_dir & MV_DIR_FORWARD) {
1713 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
1714 op_pix = avg_pixels_tab;
1715 op_qpix= avg_qpel_pixels_tab;
1717 if (s->mv_dir & MV_DIR_BACKWARD) {
1718 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
1722 /* skip dequant / idct if we are really late ;) */
1723 if(s->hurry_up>1) goto the_end;
1725 /* add dct residue */
1726 if(s->encoding || !(s->mpeg2 || s->h263_msmpeg4 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1727 add_dequant_dct(s, block[0], 0, dest_y, dct_linesize);
1728 add_dequant_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1729 add_dequant_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1730 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1732 if(!(s->flags&CODEC_FLAG_GRAY)){
1733 add_dequant_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1734 add_dequant_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1737 add_dct(s, block[0], 0, dest_y, dct_linesize);
1738 add_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1739 add_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1740 add_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1742 if(!(s->flags&CODEC_FLAG_GRAY)){
1743 add_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1744 add_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1748 /* dct only in intra block */
1749 put_dct(s, block[0], 0, dest_y, dct_linesize);
1750 put_dct(s, block[1], 1, dest_y + 8, dct_linesize);
1751 put_dct(s, block[2], 2, dest_y + dct_offset, dct_linesize);
1752 put_dct(s, block[3], 3, dest_y + dct_offset + 8, dct_linesize);
1754 if(!(s->flags&CODEC_FLAG_GRAY)){
1755 put_dct(s, block[4], 4, dest_cb, s->uvlinesize);
1756 put_dct(s, block[5], 5, dest_cr, s->uvlinesize);
1761 emms_c(); //FIXME remove
1764 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
1766 static const char tab[64]=
1778 DCTELEM *block= s->block[n];
1779 const int last_index= s->block_last_index[n];
1784 threshold= -threshold;
1788 /* are all which we could set to zero are allready zero? */
1789 if(last_index<=skip_dc - 1) return;
1791 for(i=0; i<=last_index; i++){
1792 const int j = s->intra_scantable.permutated[i];
1793 const int level = ABS(block[j]);
1795 if(skip_dc && i==0) continue;
1804 if(score >= threshold) return;
1805 for(i=skip_dc; i<=last_index; i++){
1806 const int j = s->intra_scantable.permutated[i];
1809 if(block[0]) s->block_last_index[n]= 0;
1810 else s->block_last_index[n]= -1;
1813 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
1816 const int maxlevel= s->max_qcoeff;
1817 const int minlevel= s->min_qcoeff;
1820 i=1; //skip clipping of intra dc
1824 for(;i<=last_index; i++){
1825 const int j= s->intra_scantable.permutated[i];
1826 int level = block[j];
1828 if (level>maxlevel) level=maxlevel;
1829 else if(level<minlevel) level=minlevel;
1834 static inline void requantize_coeffs(MpegEncContext *s, DCTELEM block[64], int oldq, int newq, int n)
1839 i=1; //skip clipping of intra dc
1840 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1844 for(;i<=s->block_last_index[n]; i++){
1845 const int j = s->intra_scantable.permutated[i];
1846 int level = block[j];
1848 block[j]= ROUNDED_DIV(level*oldq, newq);
1851 for(i=s->block_last_index[n]; i>=0; i--){
1852 const int j = s->intra_scantable.permutated[i];
1855 s->block_last_index[n]= i;
1858 static inline void auto_requantize_coeffs(MpegEncContext *s, DCTELEM block[6][64])
1861 const int maxlevel= s->max_qcoeff;
1862 const int minlevel= s->min_qcoeff;
1863 int largest=0, smallest=0;
1865 assert(s->adaptive_quant);
1869 i=1; //skip clipping of intra dc
1870 //FIXME requantize, note (mpeg1/h263/h263p-aic dont need it,...)
1874 for(;i<=s->block_last_index[n]; i++){
1875 const int j = s->intra_scantable.permutated[i];
1876 int level = block[n][j];
1877 if(largest < level) largest = level;
1878 if(smallest > level) smallest= level;
1882 for(newq=s->qscale+1; newq<32; newq++){
1883 if( ROUNDED_DIV(smallest*s->qscale, newq) >= minlevel
1884 && ROUNDED_DIV(largest *s->qscale, newq) <= maxlevel)
1888 if(s->out_format==FMT_H263){
1889 /* h263 like formats cannot change qscale by more than 2 easiely */
1890 if(s->avctx->qmin + 2 < newq)
1891 newq= s->avctx->qmin + 2;
1895 requantize_coeffs(s, block[n], s->qscale, newq, n);
1896 clip_coeffs(s, block[n], s->block_last_index[n]);
1899 s->dquant+= newq - s->qscale;
1903 static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1908 for(x=0; x<16; x+=4){
1909 score+= ABS(s[x ] - s[x +stride]) + ABS(s[x+1] - s[x+1+stride])
1910 +ABS(s[x+2] - s[x+2+stride]) + ABS(s[x+3] - s[x+3+stride]);
1918 static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1923 for(x=0; x<16; x++){
1924 score+= ABS(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
1933 #define SQ(a) ((a)*(a))
1935 static int pix_vcmp16x8(UINT8 *s, int stride){ //FIXME move to dsputil & optimize
1940 for(x=0; x<16; x+=4){
1941 score+= SQ(s[x ] - s[x +stride]) + SQ(s[x+1] - s[x+1+stride])
1942 +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
1950 static int pix_diff_vcmp16x8(UINT8 *s1, UINT8*s2, int stride){ //FIXME move to dsputil & optimize
1955 for(x=0; x<16; x++){
1956 score+= SQ(s1[x ] - s2[x ] - s1[x +stride] + s2[x +stride]);
1966 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
1968 const int mb_x= s->mb_x;
1969 const int mb_y= s->mb_y;
1972 int dct_offset = s->linesize*8; //default for progressive frames
1974 for(i=0; i<6; i++) skip_dct[i]=0;
1976 if(s->adaptive_quant){
1977 s->dquant= s->qscale_table[mb_x + mb_y*s->mb_width] - s->qscale;
1979 if(s->out_format==FMT_H263){
1980 if (s->dquant> 2) s->dquant= 2;
1981 else if(s->dquant<-2) s->dquant=-2;
1984 if(s->codec_id==CODEC_ID_MPEG4){
1986 assert(s->dquant==0 || s->mv_type!=MV_TYPE_8X8);
1988 if(s->mv_dir&MV_DIRECT)
1992 s->qscale+= s->dquant;
1993 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1994 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2002 wrap_y = s->linesize;
2003 ptr = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2005 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2006 emulated_edge_mc(s, ptr, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2007 ptr= s->edge_emu_buffer;
2011 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2012 int progressive_score, interlaced_score;
2014 progressive_score= pix_vcmp16x8(ptr, wrap_y ) + pix_vcmp16x8(ptr + wrap_y*8, wrap_y );
2015 interlaced_score = pix_vcmp16x8(ptr, wrap_y*2) + pix_vcmp16x8(ptr + wrap_y , wrap_y*2);
2017 if(progressive_score > interlaced_score + 100){
2018 s->interlaced_dct=1;
2023 s->interlaced_dct=0;
2026 get_pixels(s->block[0], ptr , wrap_y);
2027 get_pixels(s->block[1], ptr + 8, wrap_y);
2028 get_pixels(s->block[2], ptr + dct_offset , wrap_y);
2029 get_pixels(s->block[3], ptr + dct_offset + 8, wrap_y);
2031 if(s->flags&CODEC_FLAG_GRAY){
2035 int wrap_c = s->uvlinesize;
2036 ptr = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2038 emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2039 ptr= s->edge_emu_buffer;
2041 get_pixels(s->block[4], ptr, wrap_c);
2043 ptr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2045 emulated_edge_mc(s, ptr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2046 ptr= s->edge_emu_buffer;
2048 get_pixels(s->block[5], ptr, wrap_c);
2051 op_pixels_func (*op_pix)[4];
2052 qpel_mc_func (*op_qpix)[16];
2053 UINT8 *dest_y, *dest_cb, *dest_cr;
2054 UINT8 *ptr_y, *ptr_cb, *ptr_cr;
2058 dest_y = s->current_picture[0] + (mb_y * 16 * s->linesize ) + mb_x * 16;
2059 dest_cb = s->current_picture[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2060 dest_cr = s->current_picture[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
2061 wrap_y = s->linesize;
2062 wrap_c = s->uvlinesize;
2063 ptr_y = s->new_picture[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
2064 ptr_cb = s->new_picture[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
2065 ptr_cr = s->new_picture[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
2067 if ((!s->no_rounding) || s->pict_type==B_TYPE){
2068 op_pix = put_pixels_tab;
2069 op_qpix= put_qpel_pixels_tab;
2071 op_pix = put_no_rnd_pixels_tab;
2072 op_qpix= put_no_rnd_qpel_pixels_tab;
2075 if (s->mv_dir & MV_DIR_FORWARD) {
2076 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture, op_pix, op_qpix);
2077 op_pix = avg_pixels_tab;
2078 op_qpix= avg_qpel_pixels_tab;
2080 if (s->mv_dir & MV_DIR_BACKWARD) {
2081 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture, op_pix, op_qpix);
2084 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
2085 emulated_edge_mc(s, ptr_y, wrap_y, 16, 16, mb_x*16, mb_y*16, s->width, s->height);
2086 ptr_y= s->edge_emu_buffer;
2090 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
2091 int progressive_score, interlaced_score;
2093 progressive_score= pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y )
2094 + pix_diff_vcmp16x8(ptr_y + wrap_y*8, dest_y + wrap_y*8, wrap_y );
2095 interlaced_score = pix_diff_vcmp16x8(ptr_y , dest_y , wrap_y*2)
2096 + pix_diff_vcmp16x8(ptr_y + wrap_y , dest_y + wrap_y , wrap_y*2);
2098 if(progressive_score > interlaced_score + 600){
2099 s->interlaced_dct=1;
2104 s->interlaced_dct=0;
2107 diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
2108 diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2109 diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
2110 diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
2112 if(s->flags&CODEC_FLAG_GRAY){
2117 emulated_edge_mc(s, ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2118 ptr_cb= s->edge_emu_buffer;
2120 diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2122 emulated_edge_mc(s, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
2123 ptr_cr= s->edge_emu_buffer;
2125 diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2128 /* pre quantization */
2129 if(s->mc_mb_var[s->mb_width*mb_y+ mb_x]<2*s->qscale*s->qscale){
2131 if(pix_abs8x8(ptr_y , dest_y , wrap_y) < 20*s->qscale) skip_dct[0]= 1;
2132 if(pix_abs8x8(ptr_y + 8, dest_y + 8, wrap_y) < 20*s->qscale) skip_dct[1]= 1;
2133 if(pix_abs8x8(ptr_y +dct_offset , dest_y +dct_offset , wrap_y) < 20*s->qscale) skip_dct[2]= 1;
2134 if(pix_abs8x8(ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y) < 20*s->qscale) skip_dct[3]= 1;
2135 if(pix_abs8x8(ptr_cb , dest_cb , wrap_y) < 20*s->qscale) skip_dct[4]= 1;
2136 if(pix_abs8x8(ptr_cr , dest_cr , wrap_y) < 20*s->qscale) skip_dct[5]= 1;
2142 if(skip_dct[i]) num++;
2145 if(s->mb_x==0 && s->mb_y==0){
2147 printf("%6d %1d\n", stat[i], i);
2160 adap_parm = ((s->avg_mb_var << 1) + s->mb_var[s->mb_width*mb_y+mb_x] + 1.0) /
2161 ((s->mb_var[s->mb_width*mb_y+mb_x] << 1) + s->avg_mb_var + 1.0);
2163 printf("\ntype=%c qscale=%2d adap=%0.2f dquant=%4.2f var=%4d avgvar=%4d",
2164 (s->mb_type[s->mb_width*mb_y+mb_x] > 0) ? 'I' : 'P',
2165 s->qscale, adap_parm, s->qscale*adap_parm,
2166 s->mb_var[s->mb_width*mb_y+mb_x], s->avg_mb_var);
2169 /* DCT & quantize */
2170 if(s->out_format==FMT_MJPEG){
2173 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, 8, &overflow);
2174 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2180 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2181 // FIXME we could decide to change to quantizer instead of clipping
2182 // JS: I don't think that would be a good idea it could lower quality instead
2183 // of improve it. Just INTRADC clipping deserves changes in quantizer
2184 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
2186 s->block_last_index[i]= -1;
2188 if(s->luma_elim_threshold && !s->mb_intra)
2190 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2191 if(s->chroma_elim_threshold && !s->mb_intra)
2193 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2196 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
2197 s->block_last_index[4]=
2198 s->block_last_index[5]= 0;
2200 s->block[5][0]= 128;
2203 /* huffman encode */
2204 switch(s->out_format) {
2206 mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2209 if (s->h263_msmpeg4)
2210 msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2211 else if(s->h263_pred)
2212 mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2214 h263_encode_mb(s, s->block, motion_x, motion_y);
2217 mjpeg_encode_mb(s, s->block);
2222 void ff_copy_bits(PutBitContext *pb, UINT8 *src, int length)
2224 int bytes= length>>4;
2225 int bits= length&15;
2228 if(length==0) return;
2230 for(i=0; i<bytes; i++) put_bits(pb, 16, be2me_16(((uint16_t*)src)[i]));
2231 put_bits(pb, bits, be2me_16(((uint16_t*)src)[i])>>(16-bits));
2234 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2237 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2240 d->mb_incr= s->mb_incr;
2242 d->last_dc[i]= s->last_dc[i];
2245 d->mv_bits= s->mv_bits;
2246 d->i_tex_bits= s->i_tex_bits;
2247 d->p_tex_bits= s->p_tex_bits;
2248 d->i_count= s->i_count;
2249 d->f_count= s->f_count;
2250 d->b_count= s->b_count;
2251 d->skip_count= s->skip_count;
2252 d->misc_bits= s->misc_bits;
2255 d->mb_skiped= s->mb_skiped;
2258 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2261 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2262 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
2265 d->mb_incr= s->mb_incr;
2267 d->last_dc[i]= s->last_dc[i];
2270 d->mv_bits= s->mv_bits;
2271 d->i_tex_bits= s->i_tex_bits;
2272 d->p_tex_bits= s->p_tex_bits;
2273 d->i_count= s->i_count;
2274 d->f_count= s->f_count;
2275 d->b_count= s->b_count;
2276 d->skip_count= s->skip_count;
2277 d->misc_bits= s->misc_bits;
2279 d->mb_intra= s->mb_intra;
2280 d->mb_skiped= s->mb_skiped;
2281 d->mv_type= s->mv_type;
2282 d->mv_dir= s->mv_dir;
2284 if(s->data_partitioning){
2286 d->tex_pb= s->tex_pb;
2290 d->block_last_index[i]= s->block_last_index[i];
2293 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2294 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2295 int *dmin, int *next_block, int motion_x, int motion_y)
2299 copy_context_before_encode(s, backup, type);
2301 s->block= s->blocks[*next_block];
2302 s->pb= pb[*next_block];
2303 if(s->data_partitioning){
2304 s->pb2 = pb2 [*next_block];
2305 s->tex_pb= tex_pb[*next_block];
2308 encode_mb(s, motion_x, motion_y);
2310 bits_count= get_bit_count(&s->pb);
2311 if(s->data_partitioning){
2312 bits_count+= get_bit_count(&s->pb2);
2313 bits_count+= get_bit_count(&s->tex_pb);
2316 if(bits_count<*dmin){
2320 copy_context_after_encode(best, s, type);
2324 static void encode_picture(MpegEncContext *s, int picture_number)
2326 int mb_x, mb_y, last_gob, pdif = 0;
2329 MpegEncContext best_s, backup_s;
2330 UINT8 bit_buf[2][3000];
2331 UINT8 bit_buf2[2][3000];
2332 UINT8 bit_buf_tex[2][3000];
2333 PutBitContext pb[2], pb2[2], tex_pb[2];
2336 init_put_bits(&pb [i], bit_buf [i], 3000, NULL, NULL);
2337 init_put_bits(&pb2 [i], bit_buf2 [i], 3000, NULL, NULL);
2338 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000, NULL, NULL);
2341 s->picture_number = picture_number;
2346 s->block_wrap[3]= s->mb_width*2 + 2;
2348 s->block_wrap[5]= s->mb_width + 2;
2350 /* Reset the average MB variance */
2352 s->mc_mb_var_sum = 0;
2354 /* we need to initialize some time vars before we can encode b-frames */
2355 if (s->h263_pred && !s->h263_msmpeg4)
2356 ff_set_mpeg4_time(s, s->picture_number);
2358 s->scene_change_score=0;
2360 s->qscale= (int)(s->frame_qscale + 0.5); //FIXME qscale / ... stuff for ME ratedistoration
2362 /* Estimate motion for every MB */
2363 if(s->pict_type != I_TYPE){
2364 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2365 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2366 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2367 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2368 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2369 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2372 s->block_index[0]+=2;
2373 s->block_index[1]+=2;
2374 s->block_index[2]+=2;
2375 s->block_index[3]+=2;
2377 /* compute motion vector & mb_type and store in context */
2378 if(s->pict_type==B_TYPE)
2379 ff_estimate_b_frame_motion(s, mb_x, mb_y);
2381 ff_estimate_p_frame_motion(s, mb_x, mb_y);
2382 // s->mb_type[mb_y*s->mb_width + mb_x]=MB_TYPE_INTER;
2386 }else /* if(s->pict_type == I_TYPE) */{
2388 //FIXME do we need to zero them?
2389 memset(s->motion_val[0], 0, sizeof(INT16)*(s->mb_width*2 + 2)*(s->mb_height*2 + 2)*2);
2390 memset(s->p_mv_table , 0, sizeof(INT16)*(s->mb_width+2)*(s->mb_height+2)*2);
2391 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2393 if(!s->fixed_qscale){
2394 /* finding spatial complexity for I-frame rate control */
2395 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2396 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2399 uint8_t *pix = s->new_picture[0] + (yy * s->linesize) + xx;
2401 int sum = pix_sum(pix, s->linesize);
2404 varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
2406 s->mb_var [s->mb_width * mb_y + mb_x] = varc;
2407 s->mb_mean[s->mb_width * mb_y + mb_x] = (sum+7)>>4;
2408 s->mb_var_sum += varc;
2413 if(s->scene_change_score > 0 && s->pict_type == P_TYPE){
2414 s->pict_type= I_TYPE;
2415 memset(s->mb_type , MB_TYPE_INTRA, sizeof(UINT8)*s->mb_width*s->mb_height);
2416 if(s->max_b_frames==0){
2417 s->input_pict_type= I_TYPE;
2418 s->input_picture_in_gop_number=0;
2420 //printf("Scene change detected, encoding as I Frame %d %d\n", s->mb_var_sum, s->mc_mb_var_sum);
2423 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE)
2424 s->f_code= ff_get_best_fcode(s, s->p_mv_table, MB_TYPE_INTER);
2425 ff_fix_long_p_mvs(s);
2426 if(s->pict_type==B_TYPE){
2427 s->f_code= ff_get_best_fcode(s, s->b_forw_mv_table, MB_TYPE_FORWARD);
2428 s->b_code= ff_get_best_fcode(s, s->b_back_mv_table, MB_TYPE_BACKWARD);
2430 ff_fix_long_b_mvs(s, s->b_forw_mv_table, s->f_code, MB_TYPE_FORWARD);
2431 ff_fix_long_b_mvs(s, s->b_back_mv_table, s->b_code, MB_TYPE_BACKWARD);
2432 ff_fix_long_b_mvs(s, s->b_bidir_forw_mv_table, s->f_code, MB_TYPE_BIDIR);
2433 ff_fix_long_b_mvs(s, s->b_bidir_back_mv_table, s->b_code, MB_TYPE_BIDIR);
2436 if (s->fixed_qscale)
2437 s->frame_qscale = s->avctx->quality;
2439 s->frame_qscale = ff_rate_estimate_qscale(s);
2441 if(s->adaptive_quant){
2442 switch(s->codec_id){
2443 case CODEC_ID_MPEG4:
2444 ff_clean_mpeg4_qscales(s);
2447 case CODEC_ID_H263P:
2448 ff_clean_h263_qscales(s);
2452 s->qscale= s->qscale_table[0];
2454 s->qscale= (int)(s->frame_qscale + 0.5);
2456 if (s->out_format == FMT_MJPEG) {
2457 /* for mjpeg, we do include qscale in the matrix */
2458 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
2460 int j= s->idct_permutation[i];
2462 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
2464 convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
2465 s->q_intra_matrix16_bias, s->intra_matrix, s->intra_quant_bias, 8, 8);
2468 s->last_bits= get_bit_count(&s->pb);
2469 switch(s->out_format) {
2471 mjpeg_picture_header(s);
2474 if (s->h263_msmpeg4)
2475 msmpeg4_encode_picture_header(s, picture_number);
2476 else if (s->h263_pred)
2477 mpeg4_encode_picture_header(s, picture_number);
2478 else if (s->h263_rv10)
2479 rv10_encode_picture_header(s, picture_number);
2481 h263_encode_picture_header(s, picture_number);
2484 mpeg1_encode_picture_header(s, picture_number);
2487 bits= get_bit_count(&s->pb);
2488 s->header_bits= bits - s->last_bits;
2499 /* init last dc values */
2500 /* note: quant matrix value (8) is implied here */
2501 s->last_dc[0] = 128;
2502 s->last_dc[1] = 128;
2503 s->last_dc[2] = 128;
2505 s->last_mv[0][0][0] = 0;
2506 s->last_mv[0][0][1] = 0;
2508 /* Get the GOB height based on picture height */
2509 if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4) {
2510 if (s->height <= 400)
2512 else if (s->height <= 800)
2516 }else if(s->codec_id==CODEC_ID_MPEG4){
2520 if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2521 ff_mpeg4_init_partitions(s);
2525 for(mb_y=0; mb_y < s->mb_height; mb_y++) {
2526 /* Put GOB header based on RTP MTU for formats which support it per line (H263*)*/
2527 /* TODO: Put all this stuff in a separate generic function */
2530 s->ptr_lastgob = s->pb.buf;
2531 s->ptr_last_mb_line = s->pb.buf;
2532 } else if (s->out_format == FMT_H263 && !s->h263_pred && !s->h263_msmpeg4 && !(mb_y % s->gob_index)) {
2533 // MN: we could move the space check from h263 -> here, as its not h263 specific
2534 last_gob = h263_encode_gob_header(s, mb_y);
2536 s->first_slice_line = 1;
2538 /*MN: we reset it here instead at the end of each line cuz mpeg4 can have
2539 slice lines starting & ending in the middle*/
2540 s->first_slice_line = 0;
2545 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
2546 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
2548 s->block_index[0]= s->block_wrap[0]*(mb_y*2 + 1) - 1;
2549 s->block_index[1]= s->block_wrap[0]*(mb_y*2 + 1);
2550 s->block_index[2]= s->block_wrap[0]*(mb_y*2 + 2) - 1;
2551 s->block_index[3]= s->block_wrap[0]*(mb_y*2 + 2);
2552 s->block_index[4]= s->block_wrap[4]*(mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2);
2553 s->block_index[5]= s->block_wrap[4]*(mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2);
2554 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2555 const int mb_type= s->mb_type[mb_y * s->mb_width + mb_x];
2556 const int xy= (mb_y+1) * (s->mb_width+2) + mb_x + 1;
2562 s->block_index[0]+=2;
2563 s->block_index[1]+=2;
2564 s->block_index[2]+=2;
2565 s->block_index[3]+=2;
2566 s->block_index[4]++;
2567 s->block_index[5]++;
2569 /* write gob / video packet header for formats which support it at any MB (MPEG4) */
2570 if(s->rtp_mode && s->mb_y>0 && s->codec_id==CODEC_ID_MPEG4){
2571 int pdif= pbBufPtr(&s->pb) - s->ptr_lastgob;
2573 //the *2 is there so we stay below the requested size
2574 if(pdif + s->mb_line_avgsize/s->mb_width >= s->rtp_payload_size){
2575 if(s->codec_id==CODEC_ID_MPEG4){
2576 if(s->data_partitioning && s->pict_type!=B_TYPE){
2577 ff_mpeg4_merge_partitions(s);
2578 ff_mpeg4_init_partitions(s);
2580 ff_mpeg4_encode_video_packet_header(s);
2582 if(s->flags&CODEC_FLAG_PASS1){
2583 int bits= get_bit_count(&s->pb);
2584 s->misc_bits+= bits - s->last_bits;
2587 ff_mpeg4_clean_buffers(s);
2589 s->ptr_lastgob = pbBufPtr(&s->pb);
2590 s->first_slice_line=1;
2591 s->resync_mb_x=mb_x;
2592 s->resync_mb_y=mb_y;
2595 if( (s->resync_mb_x == s->mb_x)
2596 && s->resync_mb_y+1 == s->mb_y){
2597 s->first_slice_line=0;
2601 if(mb_type & (mb_type-1)){ // more than 1 MB type possible
2603 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2605 copy_context_before_encode(&backup_s, s, -1);
2607 best_s.data_partitioning= s->data_partitioning;
2608 if(s->data_partitioning){
2609 backup_s.pb2= s->pb2;
2610 backup_s.tex_pb= s->tex_pb;
2613 if(mb_type&MB_TYPE_INTER){
2614 s->mv_dir = MV_DIR_FORWARD;
2615 s->mv_type = MV_TYPE_16X16;
2617 s->mv[0][0][0] = s->p_mv_table[xy][0];
2618 s->mv[0][0][1] = s->p_mv_table[xy][1];
2619 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER, pb, pb2, tex_pb,
2620 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2622 if(mb_type&MB_TYPE_INTER4V){
2623 s->mv_dir = MV_DIR_FORWARD;
2624 s->mv_type = MV_TYPE_8X8;
2627 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2628 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2630 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTER4V, pb, pb2, tex_pb,
2631 &dmin, &next_block, 0, 0);
2633 if(mb_type&MB_TYPE_FORWARD){
2634 s->mv_dir = MV_DIR_FORWARD;
2635 s->mv_type = MV_TYPE_16X16;
2637 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2638 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2639 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_FORWARD, pb, pb2, tex_pb,
2640 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2642 if(mb_type&MB_TYPE_BACKWARD){
2643 s->mv_dir = MV_DIR_BACKWARD;
2644 s->mv_type = MV_TYPE_16X16;
2646 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2647 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2648 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2649 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2651 if(mb_type&MB_TYPE_BIDIR){
2652 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2653 s->mv_type = MV_TYPE_16X16;
2655 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2656 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2657 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2658 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2659 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_BIDIR, pb, pb2, tex_pb,
2660 &dmin, &next_block, 0, 0);
2662 if(mb_type&MB_TYPE_DIRECT){
2663 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2664 s->mv_type = MV_TYPE_16X16; //FIXME
2666 s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2667 s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2668 s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2669 s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2670 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_DIRECT, pb, pb2, tex_pb,
2671 &dmin, &next_block, s->b_direct_mv_table[xy][0], s->b_direct_mv_table[xy][1]);
2673 if(mb_type&MB_TYPE_INTRA){
2674 s->mv_dir = MV_DIR_FORWARD;
2675 s->mv_type = MV_TYPE_16X16;
2679 encode_mb_hq(s, &backup_s, &best_s, MB_TYPE_INTRA, pb, pb2, tex_pb,
2680 &dmin, &next_block, 0, 0);
2681 /* force cleaning of ac/dc pred stuff if needed ... */
2682 if(s->h263_pred || s->h263_aic)
2683 s->mbintra_table[mb_x + mb_y*s->mb_width]=1;
2685 copy_context_after_encode(s, &best_s, -1);
2687 pb_bits_count= get_bit_count(&s->pb);
2688 flush_put_bits(&s->pb);
2689 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2692 if(s->data_partitioning){
2693 pb2_bits_count= get_bit_count(&s->pb2);
2694 flush_put_bits(&s->pb2);
2695 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2696 s->pb2= backup_s.pb2;
2698 tex_pb_bits_count= get_bit_count(&s->tex_pb);
2699 flush_put_bits(&s->tex_pb);
2700 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2701 s->tex_pb= backup_s.tex_pb;
2703 s->last_bits= get_bit_count(&s->pb);
2705 int motion_x, motion_y;
2706 s->mv_type=MV_TYPE_16X16;
2707 // only one MB-Type possible
2710 s->mv_dir = MV_DIR_FORWARD;
2712 motion_x= s->mv[0][0][0] = 0;
2713 motion_y= s->mv[0][0][1] = 0;
2716 s->mv_dir = MV_DIR_FORWARD;
2718 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2719 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2721 case MB_TYPE_INTER4V:
2722 s->mv_dir = MV_DIR_FORWARD;
2723 s->mv_type = MV_TYPE_8X8;
2726 s->mv[0][i][0] = s->motion_val[s->block_index[i]][0];
2727 s->mv[0][i][1] = s->motion_val[s->block_index[i]][1];
2729 motion_x= motion_y= 0;
2731 case MB_TYPE_DIRECT:
2732 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2734 motion_x=s->b_direct_mv_table[xy][0];
2735 motion_y=s->b_direct_mv_table[xy][1];
2736 s->mv[0][0][0] = s->b_direct_forw_mv_table[xy][0];
2737 s->mv[0][0][1] = s->b_direct_forw_mv_table[xy][1];
2738 s->mv[1][0][0] = s->b_direct_back_mv_table[xy][0];
2739 s->mv[1][0][1] = s->b_direct_back_mv_table[xy][1];
2742 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2746 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2747 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2748 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2749 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2751 case MB_TYPE_BACKWARD:
2752 s->mv_dir = MV_DIR_BACKWARD;
2754 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2755 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2757 case MB_TYPE_FORWARD:
2758 s->mv_dir = MV_DIR_FORWARD;
2760 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2761 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2762 // printf(" %d %d ", motion_x, motion_y);
2765 motion_x=motion_y=0; //gcc warning fix
2766 printf("illegal MB type\n");
2768 encode_mb(s, motion_x, motion_y);
2770 /* clean the MV table in IPS frames for direct mode in B frames */
2771 if(s->mb_intra /* && I,P,S_TYPE */){
2772 s->p_mv_table[xy][0]=0;
2773 s->p_mv_table[xy][1]=0;
2776 MPV_decode_mb(s, s->block);
2777 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_width, get_bit_count(&s->pb));
2781 /* Obtain average GOB size for RTP */
2784 s->mb_line_avgsize = pbBufPtr(&s->pb) - s->ptr_last_mb_line;
2785 else if (!(mb_y % s->gob_index)) {
2786 s->mb_line_avgsize = (s->mb_line_avgsize + pbBufPtr(&s->pb) - s->ptr_last_mb_line) >> 1;
2787 s->ptr_last_mb_line = pbBufPtr(&s->pb);
2789 //fprintf(stderr, "\nMB line: %d\tSize: %u\tAvg. Size: %u", s->mb_y,
2790 // (s->pb.buf_ptr - s->ptr_last_mb_line), s->mb_line_avgsize);
2791 if(s->codec_id!=CODEC_ID_MPEG4) s->first_slice_line = 0; //FIXME clean
2796 if(s->codec_id==CODEC_ID_MPEG4 && s->data_partitioning && s->pict_type!=B_TYPE)
2797 ff_mpeg4_merge_partitions(s);
2799 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
2800 msmpeg4_encode_ext_header(s);
2802 if(s->codec_id==CODEC_ID_MPEG4)
2803 ff_mpeg4_stuffing(&s->pb);
2805 //if (s->gob_number)
2806 // fprintf(stderr,"\nNumber of GOB: %d", s->gob_number);
2808 /* Send the last GOB if RTP */
2810 flush_put_bits(&s->pb);
2811 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
2812 /* Call the RTP callback to send the last GOB */
2813 if (s->rtp_callback)
2814 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
2815 s->ptr_lastgob = pbBufPtr(&s->pb);
2816 //fprintf(stderr,"\nGOB: %2d size: %d (last)", s->gob_number, pdif);
2820 static int dct_quantize_c(MpegEncContext *s,
2821 DCTELEM *block, int n,
2822 int qscale, int *overflow)
2824 int i, j, level, last_non_zero, q;
2828 unsigned int threshold1, threshold2;
2832 #ifndef ARCH_ALPHA /* Alpha uses unpermuted matrix */
2833 /* we need this permutation so that we correct the IDCT
2834 permutation. will be moved into DCT code */
2835 block_permute(block, s->idct_permutation); //FIXME remove
2846 /* For AIC we skip quant/dequant of INTRADC */
2849 /* note: block[0] is assumed to be positive */
2850 block[0] = (block[0] + (q >> 1)) / q;
2853 qmat = s->q_intra_matrix[qscale];
2854 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
2858 qmat = s->q_inter_matrix[qscale];
2859 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
2861 threshold1= (1<<QMAT_SHIFT) - bias - 1;
2862 threshold2= (threshold1<<1);
2865 j = s->intra_scantable.permutated[i];
2867 level = level * qmat[j];
2869 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
2870 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
2871 if(((unsigned)(level+threshold1))>threshold2){
2873 level= (bias + level)>>QMAT_SHIFT;
2876 level= (bias - level)>>QMAT_SHIFT;
2885 *overflow= s->max_qcoeff < max; //overflow might have happend
2887 return last_non_zero;
2890 static void dct_unquantize_mpeg1_c(MpegEncContext *s,
2891 DCTELEM *block, int n, int qscale)
2893 int i, level, nCoeffs;
2894 const UINT16 *quant_matrix;
2896 nCoeffs= s->block_last_index[n];
2900 block[0] = block[0] * s->y_dc_scale;
2902 block[0] = block[0] * s->c_dc_scale;
2903 /* XXX: only mpeg1 */
2904 quant_matrix = s->intra_matrix;
2905 for(i=1;i<=nCoeffs;i++) {
2906 int j= s->intra_scantable.permutated[i];
2911 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2912 level = (level - 1) | 1;
2915 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2916 level = (level - 1) | 1;
2919 if (level < -2048 || level > 2047)
2920 fprintf(stderr, "unquant error %d %d\n", i, level);
2927 quant_matrix = s->inter_matrix;
2928 for(;i<=nCoeffs;i++) {
2929 int j= s->intra_scantable.permutated[i];
2934 level = (((level << 1) + 1) * qscale *
2935 ((int) (quant_matrix[j]))) >> 4;
2936 level = (level - 1) | 1;
2939 level = (((level << 1) + 1) * qscale *
2940 ((int) (quant_matrix[j]))) >> 4;
2941 level = (level - 1) | 1;
2944 if (level < -2048 || level > 2047)
2945 fprintf(stderr, "unquant error %d %d\n", i, level);
2953 static void dct_unquantize_mpeg2_c(MpegEncContext *s,
2954 DCTELEM *block, int n, int qscale)
2956 int i, level, nCoeffs;
2957 const UINT16 *quant_matrix;
2959 if(s->alternate_scan) nCoeffs= 63;
2960 else nCoeffs= s->block_last_index[n];
2964 block[0] = block[0] * s->y_dc_scale;
2966 block[0] = block[0] * s->c_dc_scale;
2967 quant_matrix = s->intra_matrix;
2968 for(i=1;i<=nCoeffs;i++) {
2969 int j= s->intra_scantable.permutated[i];
2974 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2977 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2980 if (level < -2048 || level > 2047)
2981 fprintf(stderr, "unquant error %d %d\n", i, level);
2989 quant_matrix = s->inter_matrix;
2990 for(;i<=nCoeffs;i++) {
2991 int j= s->intra_scantable.permutated[i];
2996 level = (((level << 1) + 1) * qscale *
2997 ((int) (quant_matrix[j]))) >> 4;
3000 level = (((level << 1) + 1) * qscale *
3001 ((int) (quant_matrix[j]))) >> 4;
3004 if (level < -2048 || level > 2047)
3005 fprintf(stderr, "unquant error %d %d\n", i, level);
3016 static void dct_unquantize_h263_c(MpegEncContext *s,
3017 DCTELEM *block, int n, int qscale)
3019 int i, level, qmul, qadd;
3022 assert(s->block_last_index[n]>=0);
3024 qadd = (qscale - 1) | 1;
3030 block[0] = block[0] * s->y_dc_scale;
3032 block[0] = block[0] * s->c_dc_scale;
3036 nCoeffs= 63; //does not allways use zigzag table
3039 nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
3042 for(;i<=nCoeffs;i++) {
3046 level = level * qmul - qadd;
3048 level = level * qmul + qadd;
3051 if (level < -2048 || level > 2047)
3052 fprintf(stderr, "unquant error %d %d\n", i, level);
3059 static void remove_ac(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int mb_x, int mb_y)
3061 int dc, dcb, dcr, y, i;
3063 dc= s->dc_val[0][mb_x*2+1 + (i&1) + (mb_y*2+1 + (i>>1))*(s->mb_width*2+2)];
3067 dest_y[x + (i&1)*8 + (y + (i>>1)*8)*s->linesize]= dc/8;
3071 dcb = s->dc_val[1][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
3072 dcr= s->dc_val[2][mb_x+1 + (mb_y+1)*(s->mb_width+2)];
3076 dest_cb[x + y*(s->uvlinesize)]= dcb/8;
3077 dest_cr[x + y*(s->uvlinesize)]= dcr/8;
3083 * will conceal past errors, and allso drop b frames if needed
3086 void ff_conceal_past_errors(MpegEncContext *s, int unknown_pos)
3091 int i, intra_count=0, inter_count=0;
3092 int intra_conceal= s->msmpeg4_version ? 50 : 50; //FIXME finetune
3093 int inter_conceal= s->msmpeg4_version ? 50 : 50;
3096 if(mb_x>=s->mb_width) mb_x= s->mb_width -1;
3097 if(mb_y>=s->mb_height) mb_y= s->mb_height-1;
3099 if(s->decoding_error==0 && unknown_pos){
3100 if(s->data_partitioning && s->pict_type!=B_TYPE)
3101 s->decoding_error= DECODING_AC_LOST;
3103 s->decoding_error= DECODING_DESYNC;
3106 if(s->decoding_error==DECODING_DESYNC && s->pict_type!=B_TYPE) s->next_p_frame_damaged=1;
3108 for(i=mb_x + mb_y*s->mb_width; i>=0; i--){
3109 if(s->mbintra_table[i]) intra_count++;
3113 if(s->decoding_error==DECODING_AC_LOST){
3116 }else if(s->decoding_error==DECODING_ACDC_LOST){
3121 if(unknown_pos && (intra_count<inter_count)){
3122 intra_conceal= inter_conceal= s->mb_num;
3123 // printf("%d %d\n",intra_count, inter_count);
3126 fprintf(stderr, "concealing errors\n");
3128 /* for all MBs from the current one back until the last resync marker */
3129 for(; mb_y>=0 && mb_y>=s->resync_mb_y; mb_y--){
3130 for(; mb_x>=0; mb_x--){
3131 uint8_t *dest_y = s->current_picture[0] + (mb_y * 16* s->linesize ) + mb_x * 16;
3132 uint8_t *dest_cb = s->current_picture[1] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3133 uint8_t *dest_cr = s->current_picture[2] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
3134 int mb_x_backup= s->mb_x; //FIXME pass xy to mpeg_motion
3135 int mb_y_backup= s->mb_y;
3138 if(s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<intra_conceal){
3139 if(s->decoding_error==DECODING_AC_LOST){
3140 remove_ac(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
3141 // printf("remove ac to %d %d\n", mb_x, mb_y);
3143 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
3144 s->last_picture, 0, 0, put_pixels_tab,
3145 0/*mx*/, 0/*my*/, 16);
3148 else if(!s->mbintra_table[mb_y*s->mb_width + mb_x] && mb_dist<inter_conceal){
3152 if(s->decoding_error!=DECODING_DESYNC){
3153 int xy= mb_x*2+1 + (mb_y*2+1)*(s->mb_width*2+2);
3154 mx= s->motion_val[ xy ][0];
3155 my= s->motion_val[ xy ][1];
3158 mpeg_motion(s, dest_y, dest_cb, dest_cr, 0,
3159 s->last_picture, 0, 0, put_pixels_tab,
3162 s->mb_x= mb_x_backup;
3163 s->mb_y= mb_y_backup;
3165 if(mb_x== s->resync_mb_x && mb_y== s->resync_mb_y) return;
3166 if(!s->mbskip_table[mb_x + mb_y*s->mb_width]) mb_dist++;
3172 AVCodec mpeg1video_encoder = {
3175 CODEC_ID_MPEG1VIDEO,
3176 sizeof(MpegEncContext),
3182 AVCodec h263_encoder = {
3186 sizeof(MpegEncContext),
3192 AVCodec h263p_encoder = {
3196 sizeof(MpegEncContext),
3202 AVCodec rv10_encoder = {
3206 sizeof(MpegEncContext),
3212 AVCodec mjpeg_encoder = {
3216 sizeof(MpegEncContext),
3222 AVCodec mpeg4_encoder = {
3226 sizeof(MpegEncContext),
3232 AVCodec msmpeg4v1_encoder = {
3236 sizeof(MpegEncContext),
3242 AVCodec msmpeg4v2_encoder = {
3246 sizeof(MpegEncContext),
3252 AVCodec msmpeg4v3_encoder = {
3256 sizeof(MpegEncContext),
3262 AVCodec wmv1_encoder = {
3266 sizeof(MpegEncContext),
3272 AVCodec wmv2_encoder = {
3276 sizeof(MpegEncContext),