2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
33 #include "mpegvideo_common.h"
42 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
43 DCTELEM *block, int n, int qscale);
44 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
57 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58 extern void XVMC_field_end(MpegEncContext *s);
59 extern void XVMC_decode_mb(MpegEncContext *s);
62 /* enable all paranoid tests for rounding, overflows, etc... */
68 static const uint8_t ff_default_chroma_qscale_table[32]={
69 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
70 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
73 const uint8_t ff_mpeg1_dc_scale_table[128]={
74 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
90 uint32_t tmp= *state << 8;
92 if(tmp == 0x100 || p==end)
97 if (p[-1] > 1 ) p+= 3;
98 else if(p[-2] ) p+= 2;
99 else if(p[-3]|(p[-1]-1)) p++;
112 /* init common dct for both encoder and decoder */
113 int ff_dct_common_init(MpegEncContext *s)
115 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
116 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
117 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
118 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
119 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
120 if(s->flags & CODEC_FLAG_BITEXACT)
121 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
122 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
124 #if defined(HAVE_MMX)
125 MPV_common_init_mmx(s);
126 #elif defined(ARCH_ALPHA)
127 MPV_common_init_axp(s);
128 #elif defined(CONFIG_MLIB)
129 MPV_common_init_mlib(s);
130 #elif defined(HAVE_MMI)
131 MPV_common_init_mmi(s);
132 #elif defined(ARCH_ARMV4L)
133 MPV_common_init_armv4l(s);
134 #elif defined(HAVE_ALTIVEC)
135 MPV_common_init_altivec(s);
136 #elif defined(ARCH_BFIN)
137 MPV_common_init_bfin(s);
140 /* load & permutate scantables
141 note: only wmv uses different ones
143 if(s->alternate_scan){
144 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
145 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
147 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
148 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
150 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
151 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
156 void ff_copy_picture(Picture *dst, Picture *src){
158 dst->type= FF_BUFFER_TYPE_COPY;
162 * allocates a Picture
163 * The pixels are allocated/set by calling get_buffer() if shared=0
165 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
166 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
167 const int mb_array_size= s->mb_stride*s->mb_height;
168 const int b8_array_size= s->b8_stride*s->mb_height*2;
169 const int b4_array_size= s->b4_stride*s->mb_height*4;
174 assert(pic->data[0]);
175 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
176 pic->type= FF_BUFFER_TYPE_SHARED;
178 assert(!pic->data[0]);
180 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
182 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
183 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
187 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
188 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
189 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
193 if(pic->linesize[1] != pic->linesize[2]){
194 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
195 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
199 s->linesize = pic->linesize[0];
200 s->uvlinesize= pic->linesize[1];
203 if(pic->qscale_table==NULL){
205 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
206 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
207 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
210 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
211 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
212 CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
213 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
214 if(s->out_format == FMT_H264){
216 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
217 pic->motion_val[i]= pic->motion_val_base[i]+4;
218 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
220 pic->motion_subsample_log2= 2;
221 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
223 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
224 pic->motion_val[i]= pic->motion_val_base[i]+4;
225 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
227 pic->motion_subsample_log2= 3;
229 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
230 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
232 pic->qstride= s->mb_stride;
233 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
236 /* It might be nicer if the application would keep track of these
237 * but it would require an API change. */
238 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
239 s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
240 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
241 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
244 fail: //for the CHECKED_ALLOCZ macro
246 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
251 * deallocates a picture
253 static void free_picture(MpegEncContext *s, Picture *pic){
256 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
257 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
260 av_freep(&pic->mb_var);
261 av_freep(&pic->mc_mb_var);
262 av_freep(&pic->mb_mean);
263 av_freep(&pic->mbskip_table);
264 av_freep(&pic->qscale_table);
265 av_freep(&pic->mb_type_base);
266 av_freep(&pic->dct_coeff);
267 av_freep(&pic->pan_scan);
270 av_freep(&pic->motion_val_base[i]);
271 av_freep(&pic->ref_index[i]);
274 if(pic->type == FF_BUFFER_TYPE_SHARED){
283 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
286 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
287 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
288 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
290 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
291 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
292 s->rd_scratchpad= s->me.scratchpad;
293 s->b_scratchpad= s->me.scratchpad;
294 s->obmc_scratchpad= s->me.scratchpad + 16;
296 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
297 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
298 if(s->avctx->noise_reduction){
299 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
302 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
303 s->block= s->blocks[0];
306 s->pblocks[i] = (short *)(&s->block[i]);
310 return -1; //free() through MPV_common_end()
313 static void free_duplicate_context(MpegEncContext *s){
316 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
317 av_freep(&s->me.scratchpad);
320 s->obmc_scratchpad= NULL;
322 av_freep(&s->dct_error_sum);
323 av_freep(&s->me.map);
324 av_freep(&s->me.score_map);
325 av_freep(&s->blocks);
329 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
330 #define COPY(a) bak->a= src->a
331 COPY(allocated_edge_emu_buffer);
332 COPY(edge_emu_buffer);
336 COPY(obmc_scratchpad);
343 COPY(me.map_generation);
351 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
354 //FIXME copy only needed parts
356 backup_duplicate_context(&bak, dst);
357 memcpy(dst, src, sizeof(MpegEncContext));
358 backup_duplicate_context(dst, &bak);
360 dst->pblocks[i] = (short *)(&dst->block[i]);
362 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
366 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
367 * the changed fields will not depend upon the prior state of the MpegEncContext.
369 void MPV_common_defaults(MpegEncContext *s){
371 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
372 s->chroma_qscale_table= ff_default_chroma_qscale_table;
373 s->progressive_frame= 1;
374 s->progressive_sequence= 1;
375 s->picture_structure= PICT_FRAME;
377 s->coded_picture_number = 0;
378 s->picture_number = 0;
379 s->input_picture_number = 0;
381 s->picture_in_gop_number = 0;
388 * sets the given MpegEncContext to defaults for decoding.
389 * the changed fields will not depend upon the prior state of the MpegEncContext.
391 void MPV_decode_defaults(MpegEncContext *s){
392 MPV_common_defaults(s);
396 * init common structure for both encoder and decoder.
397 * this assumes that some variables like width/height are already set
399 int MPV_common_init(MpegEncContext *s)
401 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
403 s->mb_height = (s->height + 15) / 16;
405 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
406 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
410 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
413 dsputil_init(&s->dsp, s->avctx);
414 ff_dct_common_init(s);
416 s->flags= s->avctx->flags;
417 s->flags2= s->avctx->flags2;
419 s->mb_width = (s->width + 15) / 16;
420 s->mb_stride = s->mb_width + 1;
421 s->b8_stride = s->mb_width*2 + 1;
422 s->b4_stride = s->mb_width*4 + 1;
423 mb_array_size= s->mb_height * s->mb_stride;
424 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
426 /* set chroma shifts */
427 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
428 &(s->chroma_y_shift) );
430 /* set default edge pos, will be overriden in decode_header if needed */
431 s->h_edge_pos= s->mb_width*16;
432 s->v_edge_pos= s->mb_height*16;
434 s->mb_num = s->mb_width * s->mb_height;
439 s->block_wrap[3]= s->b8_stride;
441 s->block_wrap[5]= s->mb_stride;
443 y_size = s->b8_stride * (2 * s->mb_height + 1);
444 c_size = s->mb_stride * (s->mb_height + 1);
445 yc_size = y_size + 2 * c_size;
447 /* convert fourcc to upper case */
448 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
449 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
450 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
451 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
453 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
454 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
455 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
456 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
458 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
460 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
461 for(y=0; y<s->mb_height; y++){
462 for(x=0; x<s->mb_width; x++){
463 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
466 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
469 /* Allocate MV tables */
470 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
471 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
472 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
473 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
474 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
477 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
478 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
479 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
480 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
481 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
483 if(s->msmpeg4_version){
484 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
486 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
488 /* Allocate MB type table */
489 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
491 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
493 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
494 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
495 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
496 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
497 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
498 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
500 if(s->avctx->noise_reduction){
501 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
504 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
506 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
508 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
509 /* interlaced direct mode decoding tables */
514 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
515 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
517 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
518 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
519 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
521 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
524 if (s->out_format == FMT_H263) {
526 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
527 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
528 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
529 s->ac_val[2] = s->ac_val[1] + c_size;
532 CHECKED_ALLOCZ(s->coded_block_base, y_size);
533 s->coded_block= s->coded_block_base + s->b8_stride + 1;
535 /* cbp, ac_pred, pred_dir */
536 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
537 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
540 if (s->h263_pred || s->h263_plus || !s->encoding) {
542 //MN: we need these for error resilience of intra-frames
543 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
544 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
545 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
546 s->dc_val[2] = s->dc_val[1] + c_size;
547 for(i=0;i<yc_size;i++)
548 s->dc_val_base[i] = 1024;
551 /* which mb is a intra block */
552 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
553 memset(s->mbintra_table, 1, mb_array_size);
555 /* init macroblock skip table */
556 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
557 //Note the +1 is for a quicker mpeg4 slice_end detection
558 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
560 s->parse_context.state= -1;
561 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
562 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
563 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
564 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
567 s->context_initialized = 1;
569 s->thread_context[0]= s;
570 threads = s->avctx->thread_count;
572 for(i=1; i<threads; i++){
573 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
574 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
577 for(i=0; i<threads; i++){
578 if(init_duplicate_context(s->thread_context[i], s) < 0)
580 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
581 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
590 /* init common structure for both encoder and decoder */
591 void MPV_common_end(MpegEncContext *s)
595 for(i=0; i<s->avctx->thread_count; i++){
596 free_duplicate_context(s->thread_context[i]);
598 for(i=1; i<s->avctx->thread_count; i++){
599 av_freep(&s->thread_context[i]);
602 av_freep(&s->parse_context.buffer);
603 s->parse_context.buffer_size=0;
605 av_freep(&s->mb_type);
606 av_freep(&s->p_mv_table_base);
607 av_freep(&s->b_forw_mv_table_base);
608 av_freep(&s->b_back_mv_table_base);
609 av_freep(&s->b_bidir_forw_mv_table_base);
610 av_freep(&s->b_bidir_back_mv_table_base);
611 av_freep(&s->b_direct_mv_table_base);
613 s->b_forw_mv_table= NULL;
614 s->b_back_mv_table= NULL;
615 s->b_bidir_forw_mv_table= NULL;
616 s->b_bidir_back_mv_table= NULL;
617 s->b_direct_mv_table= NULL;
621 av_freep(&s->b_field_mv_table_base[i][j][k]);
622 s->b_field_mv_table[i][j][k]=NULL;
624 av_freep(&s->b_field_select_table[i][j]);
625 av_freep(&s->p_field_mv_table_base[i][j]);
626 s->p_field_mv_table[i][j]=NULL;
628 av_freep(&s->p_field_select_table[i]);
631 av_freep(&s->dc_val_base);
632 av_freep(&s->ac_val_base);
633 av_freep(&s->coded_block_base);
634 av_freep(&s->mbintra_table);
635 av_freep(&s->cbp_table);
636 av_freep(&s->pred_dir_table);
638 av_freep(&s->mbskip_table);
639 av_freep(&s->prev_pict_types);
640 av_freep(&s->bitstream_buffer);
641 s->allocated_bitstream_buffer_size=0;
643 av_freep(&s->avctx->stats_out);
644 av_freep(&s->ac_stats);
645 av_freep(&s->error_status_table);
646 av_freep(&s->mb_index2xy);
647 av_freep(&s->lambda_table);
648 av_freep(&s->q_intra_matrix);
649 av_freep(&s->q_inter_matrix);
650 av_freep(&s->q_intra_matrix16);
651 av_freep(&s->q_inter_matrix16);
652 av_freep(&s->input_picture);
653 av_freep(&s->reordered_input_picture);
654 av_freep(&s->dct_offset);
657 for(i=0; i<MAX_PICTURE_COUNT; i++){
658 free_picture(s, &s->picture[i]);
661 av_freep(&s->picture);
662 s->context_initialized = 0;
665 s->current_picture_ptr= NULL;
666 s->linesize= s->uvlinesize= 0;
669 av_freep(&s->visualization_buffer[i]);
671 avcodec_default_free_buffers(s->avctx);
674 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
676 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
677 uint8_t index_run[MAX_RUN+1];
678 int last, run, level, start, end, i;
680 /* If table is static, we can quit if rl->max_level[0] is not NULL */
681 if(static_store && rl->max_level[0])
684 /* compute max_level[], max_run[] and index_run[] */
685 for(last=0;last<2;last++) {
694 memset(max_level, 0, MAX_RUN + 1);
695 memset(max_run, 0, MAX_LEVEL + 1);
696 memset(index_run, rl->n, MAX_RUN + 1);
697 for(i=start;i<end;i++) {
698 run = rl->table_run[i];
699 level = rl->table_level[i];
700 if (index_run[run] == rl->n)
702 if (level > max_level[run])
703 max_level[run] = level;
704 if (run > max_run[level])
705 max_run[level] = run;
708 rl->max_level[last] = static_store[last];
710 rl->max_level[last] = av_malloc(MAX_RUN + 1);
711 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
713 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
715 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
716 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
718 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
720 rl->index_run[last] = av_malloc(MAX_RUN + 1);
721 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
725 void init_vlc_rl(RLTable *rl)
737 for(i=0; i<rl->vlc.table_size; i++){
738 int code= rl->vlc.table[i][0];
739 int len = rl->vlc.table[i][1];
742 if(len==0){ // illegal code
745 }else if(len<0){ //more bits needed
749 if(code==rl->n){ //esc
753 run= rl->table_run [code] + 1;
754 level= rl->table_level[code] * qmul + qadd;
755 if(code >= rl->last) run+=192;
758 rl->rl_vlc[q][i].len= len;
759 rl->rl_vlc[q][i].level= level;
760 rl->rl_vlc[q][i].run= run;
765 int ff_find_unused_picture(MpegEncContext *s, int shared){
769 for(i=0; i<MAX_PICTURE_COUNT; i++){
770 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
773 for(i=0; i<MAX_PICTURE_COUNT; i++){
774 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
776 for(i=0; i<MAX_PICTURE_COUNT; i++){
777 if(s->picture[i].data[0]==NULL) return i;
781 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
782 /* We could return -1, but the codec would crash trying to draw into a
783 * non-existing frame anyway. This is safer than waiting for a random crash.
784 * Also the return of this is never useful, an encoder must only allocate
785 * as much as allowed in the specification. This has no relationship to how
786 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
787 * enough for such valid streams).
788 * Plus, a decoder has to check stream validity and remove frames if too
789 * many reference frames are around. Waiting for "OOM" is not correct at
790 * all. Similarly, missing reference frames have to be replaced by
791 * interpolated/MC frames, anything else is a bug in the codec ...
797 static void update_noise_reduction(MpegEncContext *s){
800 for(intra=0; intra<2; intra++){
801 if(s->dct_count[intra] > (1<<16)){
803 s->dct_error_sum[intra][i] >>=1;
805 s->dct_count[intra] >>= 1;
809 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
815 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
817 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
823 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
825 /* mark&release old frames */
826 if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
827 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
828 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
830 /* release forgotten pictures */
831 /* if(mpeg124/h263) */
833 for(i=0; i<MAX_PICTURE_COUNT; i++){
834 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
835 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
836 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
844 /* release non reference frames */
845 for(i=0; i<MAX_PICTURE_COUNT; i++){
846 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
847 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
851 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
852 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
854 i= ff_find_unused_picture(s, 0);
855 pic= (AVFrame*)&s->picture[i];
860 if (s->codec_id == CODEC_ID_H264)
861 pic->reference = s->picture_structure;
862 else if (s->pict_type != FF_B_TYPE)
866 pic->coded_picture_number= s->coded_picture_number++;
868 if( alloc_picture(s, (Picture*)pic, 0) < 0)
871 s->current_picture_ptr= (Picture*)pic;
872 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
873 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
876 s->current_picture_ptr->pict_type= s->pict_type;
877 // if(s->flags && CODEC_FLAG_QSCALE)
878 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
879 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
881 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
883 if (s->pict_type != FF_B_TYPE) {
884 s->last_picture_ptr= s->next_picture_ptr;
886 s->next_picture_ptr= s->current_picture_ptr;
888 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
889 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
890 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
891 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
892 s->pict_type, s->dropable);*/
894 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
895 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
897 if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable && s->codec_id != CODEC_ID_H264){
898 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
899 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
903 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
905 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
908 if(s->picture_structure == PICT_BOTTOM_FIELD){
909 s->current_picture.data[i] += s->current_picture.linesize[i];
911 s->current_picture.linesize[i] *= 2;
912 s->last_picture.linesize[i] *=2;
913 s->next_picture.linesize[i] *=2;
917 s->hurry_up= s->avctx->hurry_up;
918 s->error_recognition= avctx->error_recognition;
920 /* set dequantizer, we can't do it during init as it might change for mpeg4
921 and we can't do it in the header decode as init is not called for mpeg4 there yet */
922 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
923 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
924 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
925 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
926 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
927 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
929 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
930 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
933 if(s->dct_error_sum){
934 assert(s->avctx->noise_reduction && s->encoding);
936 update_noise_reduction(s);
940 if(s->avctx->xvmc_acceleration)
941 return XVMC_field_start(s, avctx);
946 /* generic function for encode/decode called after a frame has been coded/decoded */
947 void MPV_frame_end(MpegEncContext *s)
950 /* draw edge for correct motion prediction if outside */
952 //just to make sure that all data is rendered.
953 if(s->avctx->xvmc_acceleration){
957 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
958 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
959 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
960 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
964 s->last_pict_type = s->pict_type;
965 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
966 if(s->pict_type!=FF_B_TYPE){
967 s->last_non_b_pict_type= s->pict_type;
970 /* copy back current_picture variables */
971 for(i=0; i<MAX_PICTURE_COUNT; i++){
972 if(s->picture[i].data[0] == s->current_picture.data[0]){
973 s->picture[i]= s->current_picture;
977 assert(i<MAX_PICTURE_COUNT);
981 /* release non-reference frames */
982 for(i=0; i<MAX_PICTURE_COUNT; i++){
983 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
984 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
988 // clear copies, to avoid confusion
990 memset(&s->last_picture, 0, sizeof(Picture));
991 memset(&s->next_picture, 0, sizeof(Picture));
992 memset(&s->current_picture, 0, sizeof(Picture));
994 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
998 * draws an line from (ex, ey) -> (sx, sy).
999 * @param w width of the image
1000 * @param h height of the image
1001 * @param stride stride/linesize of the image
1002 * @param color color of the arrow
1004 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1007 sx= av_clip(sx, 0, w-1);
1008 sy= av_clip(sy, 0, h-1);
1009 ex= av_clip(ex, 0, w-1);
1010 ey= av_clip(ey, 0, h-1);
1012 buf[sy*stride + sx]+= color;
1014 if(FFABS(ex - sx) > FFABS(ey - sy)){
1016 FFSWAP(int, sx, ex);
1017 FFSWAP(int, sy, ey);
1019 buf+= sx + sy*stride;
1021 f= ((ey-sy)<<16)/ex;
1022 for(x= 0; x <= ex; x++){
1025 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1026 buf[(y+1)*stride + x]+= (color* fr )>>16;
1030 FFSWAP(int, sx, ex);
1031 FFSWAP(int, sy, ey);
1033 buf+= sx + sy*stride;
1035 if(ey) f= ((ex-sx)<<16)/ey;
1037 for(y= 0; y <= ey; y++){
1040 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1041 buf[y*stride + x+1]+= (color* fr )>>16;
1047 * draws an arrow from (ex, ey) -> (sx, sy).
1048 * @param w width of the image
1049 * @param h height of the image
1050 * @param stride stride/linesize of the image
1051 * @param color color of the arrow
1053 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1056 sx= av_clip(sx, -100, w+100);
1057 sy= av_clip(sy, -100, h+100);
1058 ex= av_clip(ex, -100, w+100);
1059 ey= av_clip(ey, -100, h+100);
1064 if(dx*dx + dy*dy > 3*3){
1067 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1069 //FIXME subpixel accuracy
1070 rx= ROUNDED_DIV(rx*3<<4, length);
1071 ry= ROUNDED_DIV(ry*3<<4, length);
1073 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1074 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1076 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1080 * prints debuging info for the given picture.
1082 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1084 if(!pict || !pict->mb_type) return;
1086 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1089 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1090 switch (pict->pict_type) {
1091 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1092 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1093 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1094 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1095 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1096 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1098 for(y=0; y<s->mb_height; y++){
1099 for(x=0; x<s->mb_width; x++){
1100 if(s->avctx->debug&FF_DEBUG_SKIP){
1101 int count= s->mbskip_table[x + y*s->mb_stride];
1102 if(count>9) count=9;
1103 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1105 if(s->avctx->debug&FF_DEBUG_QP){
1106 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1108 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1109 int mb_type= pict->mb_type[x + y*s->mb_stride];
1110 //Type & MV direction
1112 av_log(s->avctx, AV_LOG_DEBUG, "P");
1113 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1114 av_log(s->avctx, AV_LOG_DEBUG, "A");
1115 else if(IS_INTRA4x4(mb_type))
1116 av_log(s->avctx, AV_LOG_DEBUG, "i");
1117 else if(IS_INTRA16x16(mb_type))
1118 av_log(s->avctx, AV_LOG_DEBUG, "I");
1119 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1120 av_log(s->avctx, AV_LOG_DEBUG, "d");
1121 else if(IS_DIRECT(mb_type))
1122 av_log(s->avctx, AV_LOG_DEBUG, "D");
1123 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1124 av_log(s->avctx, AV_LOG_DEBUG, "g");
1125 else if(IS_GMC(mb_type))
1126 av_log(s->avctx, AV_LOG_DEBUG, "G");
1127 else if(IS_SKIP(mb_type))
1128 av_log(s->avctx, AV_LOG_DEBUG, "S");
1129 else if(!USES_LIST(mb_type, 1))
1130 av_log(s->avctx, AV_LOG_DEBUG, ">");
1131 else if(!USES_LIST(mb_type, 0))
1132 av_log(s->avctx, AV_LOG_DEBUG, "<");
1134 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1135 av_log(s->avctx, AV_LOG_DEBUG, "X");
1140 av_log(s->avctx, AV_LOG_DEBUG, "+");
1141 else if(IS_16X8(mb_type))
1142 av_log(s->avctx, AV_LOG_DEBUG, "-");
1143 else if(IS_8X16(mb_type))
1144 av_log(s->avctx, AV_LOG_DEBUG, "|");
1145 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1146 av_log(s->avctx, AV_LOG_DEBUG, " ");
1148 av_log(s->avctx, AV_LOG_DEBUG, "?");
1151 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1152 av_log(s->avctx, AV_LOG_DEBUG, "=");
1154 av_log(s->avctx, AV_LOG_DEBUG, " ");
1156 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1158 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1162 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1163 const int shift= 1 + s->quarter_sample;
1167 int h_chroma_shift, v_chroma_shift, block_height;
1168 const int width = s->avctx->width;
1169 const int height= s->avctx->height;
1170 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1171 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1172 s->low_delay=0; //needed to see the vectors without trashing the buffers
1174 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1176 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1177 pict->data[i]= s->visualization_buffer[i];
1179 pict->type= FF_BUFFER_TYPE_COPY;
1181 block_height = 16>>v_chroma_shift;
1183 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1185 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1186 const int mb_index= mb_x + mb_y*s->mb_stride;
1187 if((s->avctx->debug_mv) && pict->motion_val){
1189 for(type=0; type<3; type++){
1192 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1196 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1200 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1205 if(!USES_LIST(pict->mb_type[mb_index], direction))
1208 if(IS_8X8(pict->mb_type[mb_index])){
1211 int sx= mb_x*16 + 4 + 8*(i&1);
1212 int sy= mb_y*16 + 4 + 8*(i>>1);
1213 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1214 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1215 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1216 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1218 }else if(IS_16X8(pict->mb_type[mb_index])){
1222 int sy=mb_y*16 + 4 + 8*i;
1223 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1224 int mx=(pict->motion_val[direction][xy][0]>>shift);
1225 int my=(pict->motion_val[direction][xy][1]>>shift);
1227 if(IS_INTERLACED(pict->mb_type[mb_index]))
1230 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1232 }else if(IS_8X16(pict->mb_type[mb_index])){
1235 int sx=mb_x*16 + 4 + 8*i;
1237 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1238 int mx=(pict->motion_val[direction][xy][0]>>shift);
1239 int my=(pict->motion_val[direction][xy][1]>>shift);
1241 if(IS_INTERLACED(pict->mb_type[mb_index]))
1244 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1247 int sx= mb_x*16 + 8;
1248 int sy= mb_y*16 + 8;
1249 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1250 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1251 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1252 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1256 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1257 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1259 for(y=0; y<block_height; y++){
1260 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1261 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1264 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1265 int mb_type= pict->mb_type[mb_index];
1268 #define COLOR(theta, r)\
1269 u= (int)(128 + r*cos(theta*3.141592/180));\
1270 v= (int)(128 + r*sin(theta*3.141592/180));
1274 if(IS_PCM(mb_type)){
1276 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1278 }else if(IS_INTRA4x4(mb_type)){
1280 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1282 }else if(IS_DIRECT(mb_type)){
1284 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1286 }else if(IS_GMC(mb_type)){
1288 }else if(IS_SKIP(mb_type)){
1290 }else if(!USES_LIST(mb_type, 1)){
1292 }else if(!USES_LIST(mb_type, 0)){
1295 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1299 u*= 0x0101010101010101ULL;
1300 v*= 0x0101010101010101ULL;
1301 for(y=0; y<block_height; y++){
1302 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1303 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1307 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1308 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1309 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1311 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1313 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1315 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1316 int dm= 1 << (mv_sample_log2-2);
1318 int sx= mb_x*16 + 8*(i&1);
1319 int sy= mb_y*16 + 8*(i>>1);
1320 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1322 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1323 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1325 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1326 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1327 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1331 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1335 s->mbskip_table[mb_index]=0;
1341 static inline int hpel_motion_lowres(MpegEncContext *s,
1342 uint8_t *dest, uint8_t *src,
1343 int field_based, int field_select,
1344 int src_x, int src_y,
1345 int width, int height, int stride,
1346 int h_edge_pos, int v_edge_pos,
1347 int w, int h, h264_chroma_mc_func *pix_op,
1348 int motion_x, int motion_y)
1350 const int lowres= s->avctx->lowres;
1351 const int s_mask= (2<<lowres)-1;
1355 if(s->quarter_sample){
1360 sx= motion_x & s_mask;
1361 sy= motion_y & s_mask;
1362 src_x += motion_x >> (lowres+1);
1363 src_y += motion_y >> (lowres+1);
1365 src += src_y * stride + src_x;
1367 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1368 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1369 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1370 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1371 src= s->edge_emu_buffer;
1379 pix_op[lowres](dest, src, stride, h, sx, sy);
1383 /* apply one mpeg motion vector to the three components */
1384 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1385 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1386 int field_based, int bottom_field, int field_select,
1387 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1388 int motion_x, int motion_y, int h)
1390 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1391 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1392 const int lowres= s->avctx->lowres;
1393 const int block_s= 8>>lowres;
1394 const int s_mask= (2<<lowres)-1;
1395 const int h_edge_pos = s->h_edge_pos >> lowres;
1396 const int v_edge_pos = s->v_edge_pos >> lowres;
1397 linesize = s->current_picture.linesize[0] << field_based;
1398 uvlinesize = s->current_picture.linesize[1] << field_based;
1400 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1406 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1409 sx= motion_x & s_mask;
1410 sy= motion_y & s_mask;
1411 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1412 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1414 if (s->out_format == FMT_H263) {
1415 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1416 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1419 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1422 uvsx = (2*mx) & s_mask;
1423 uvsy = (2*my) & s_mask;
1424 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1425 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1431 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1432 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1435 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1436 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1437 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1439 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1440 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1441 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1442 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1443 ptr_y = s->edge_emu_buffer;
1444 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1445 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1446 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1447 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1448 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1449 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1455 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1456 dest_y += s->linesize;
1457 dest_cb+= s->uvlinesize;
1458 dest_cr+= s->uvlinesize;
1462 ptr_y += s->linesize;
1463 ptr_cb+= s->uvlinesize;
1464 ptr_cr+= s->uvlinesize;
1469 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1471 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1472 uvsx <<= 2 - lowres;
1473 uvsy <<= 2 - lowres;
1474 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1475 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1477 //FIXME h261 lowres loop filter
1480 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1481 uint8_t *dest_cb, uint8_t *dest_cr,
1482 uint8_t **ref_picture,
1483 h264_chroma_mc_func *pix_op,
1485 const int lowres= s->avctx->lowres;
1486 const int block_s= 8>>lowres;
1487 const int s_mask= (2<<lowres)-1;
1488 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1489 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1490 int emu=0, src_x, src_y, offset, sx, sy;
1493 if(s->quarter_sample){
1498 /* In case of 8X8, we construct a single chroma motion vector
1499 with a special rounding */
1500 mx= ff_h263_round_chroma(mx);
1501 my= ff_h263_round_chroma(my);
1505 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1506 src_y = s->mb_y*block_s + (my >> (lowres+1));
1508 offset = src_y * s->uvlinesize + src_x;
1509 ptr = ref_picture[1] + offset;
1510 if(s->flags&CODEC_FLAG_EMU_EDGE){
1511 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1512 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1513 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1514 ptr= s->edge_emu_buffer;
1520 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1522 ptr = ref_picture[2] + offset;
1524 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1525 ptr= s->edge_emu_buffer;
1527 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1531 * motion compensation of a single macroblock
1533 * @param dest_y luma destination pointer
1534 * @param dest_cb chroma cb/u destination pointer
1535 * @param dest_cr chroma cr/v destination pointer
1536 * @param dir direction (0->forward, 1->backward)
1537 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1538 * @param pic_op halfpel motion compensation function (average or put normally)
1539 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1541 static inline void MPV_motion_lowres(MpegEncContext *s,
1542 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1543 int dir, uint8_t **ref_picture,
1544 h264_chroma_mc_func *pix_op)
1548 const int lowres= s->avctx->lowres;
1549 const int block_s= 8>>lowres;
1554 switch(s->mv_type) {
1556 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1558 ref_picture, pix_op,
1559 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1565 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1566 ref_picture[0], 0, 0,
1567 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1568 s->width, s->height, s->linesize,
1569 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1570 block_s, block_s, pix_op,
1571 s->mv[dir][i][0], s->mv[dir][i][1]);
1573 mx += s->mv[dir][i][0];
1574 my += s->mv[dir][i][1];
1577 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1578 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1581 if (s->picture_structure == PICT_FRAME) {
1583 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1584 1, 0, s->field_select[dir][0],
1585 ref_picture, pix_op,
1586 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1588 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1589 1, 1, s->field_select[dir][1],
1590 ref_picture, pix_op,
1591 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1593 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1594 ref_picture= s->current_picture_ptr->data;
1597 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1598 0, 0, s->field_select[dir][0],
1599 ref_picture, pix_op,
1600 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1605 uint8_t ** ref2picture;
1607 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1608 ref2picture= ref_picture;
1610 ref2picture= s->current_picture_ptr->data;
1613 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1614 0, 0, s->field_select[dir][i],
1615 ref2picture, pix_op,
1616 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1618 dest_y += 2*block_s*s->linesize;
1619 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1620 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1624 if(s->picture_structure == PICT_FRAME){
1628 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1630 ref_picture, pix_op,
1631 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1633 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1637 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1638 0, 0, s->picture_structure != i+1,
1639 ref_picture, pix_op,
1640 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1642 // after put we make avg of the same block
1643 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1645 //opposite parity is always in the same frame if this is second field
1646 if(!s->first_field){
1647 ref_picture = s->current_picture_ptr->data;
1656 /* put block[] to dest[] */
1657 static inline void put_dct(MpegEncContext *s,
1658 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1660 s->dct_unquantize_intra(s, block, i, qscale);
1661 s->dsp.idct_put (dest, line_size, block);
1664 /* add block[] to dest[] */
1665 static inline void add_dct(MpegEncContext *s,
1666 DCTELEM *block, int i, uint8_t *dest, int line_size)
1668 if (s->block_last_index[i] >= 0) {
1669 s->dsp.idct_add (dest, line_size, block);
1673 static inline void add_dequant_dct(MpegEncContext *s,
1674 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1676 if (s->block_last_index[i] >= 0) {
1677 s->dct_unquantize_inter(s, block, i, qscale);
1679 s->dsp.idct_add (dest, line_size, block);
1684 * cleans dc, ac, coded_block for the current non intra MB
1686 void ff_clean_intra_table_entries(MpegEncContext *s)
1688 int wrap = s->b8_stride;
1689 int xy = s->block_index[0];
1692 s->dc_val[0][xy + 1 ] =
1693 s->dc_val[0][xy + wrap] =
1694 s->dc_val[0][xy + 1 + wrap] = 1024;
1696 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1697 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1698 if (s->msmpeg4_version>=3) {
1699 s->coded_block[xy ] =
1700 s->coded_block[xy + 1 ] =
1701 s->coded_block[xy + wrap] =
1702 s->coded_block[xy + 1 + wrap] = 0;
1705 wrap = s->mb_stride;
1706 xy = s->mb_x + s->mb_y * wrap;
1708 s->dc_val[2][xy] = 1024;
1710 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1711 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1713 s->mbintra_table[xy]= 0;
1716 /* generic function called after a macroblock has been parsed by the
1717 decoder or after it has been encoded by the encoder.
1719 Important variables used:
1720 s->mb_intra : true if intra macroblock
1721 s->mv_dir : motion vector direction
1722 s->mv_type : motion vector type
1723 s->mv : motion vector
1724 s->interlaced_dct : true if interlaced dct used (mpeg2)
1726 static av_always_inline
1727 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1728 int lowres_flag, int is_mpeg12)
1731 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1733 if(s->avctx->xvmc_acceleration){
1734 XVMC_decode_mb(s);//xvmc uses pblocks
1742 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1743 /* save DCT coefficients */
1745 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1748 *dct++ = block[i][s->dsp.idct_permutation[j]];
1751 s->current_picture.qscale_table[mb_xy]= s->qscale;
1753 /* update DC predictors for P macroblocks */
1755 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1756 if(s->mbintra_table[mb_xy])
1757 ff_clean_intra_table_entries(s);
1761 s->last_dc[2] = 128 << s->intra_dc_precision;
1764 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1765 s->mbintra_table[mb_xy]=1;
1767 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1768 uint8_t *dest_y, *dest_cb, *dest_cr;
1769 int dct_linesize, dct_offset;
1770 op_pixels_func (*op_pix)[4];
1771 qpel_mc_func (*op_qpix)[16];
1772 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1773 const int uvlinesize= s->current_picture.linesize[1];
1774 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1775 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1777 /* avoid copy if macroblock skipped in last frame too */
1778 /* skip only during decoding as we might trash the buffers during encoding a bit */
1780 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1781 const int age= s->current_picture.age;
1785 if (s->mb_skipped) {
1787 assert(s->pict_type!=FF_I_TYPE);
1789 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1790 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1792 /* if previous was skipped too, then nothing to do ! */
1793 if (*mbskip_ptr >= age && s->current_picture.reference){
1796 } else if(!s->current_picture.reference){
1797 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1798 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1800 *mbskip_ptr = 0; /* not skipped */
1804 dct_linesize = linesize << s->interlaced_dct;
1805 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1809 dest_cb= s->dest[1];
1810 dest_cr= s->dest[2];
1812 dest_y = s->b_scratchpad;
1813 dest_cb= s->b_scratchpad+16*linesize;
1814 dest_cr= s->b_scratchpad+32*linesize;
1818 /* motion handling */
1819 /* decoding or more than one mb_type (MC was already done otherwise) */
1822 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1824 if (s->mv_dir & MV_DIR_FORWARD) {
1825 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1826 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1828 if (s->mv_dir & MV_DIR_BACKWARD) {
1829 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1832 op_qpix= s->me.qpel_put;
1833 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1834 op_pix = s->dsp.put_pixels_tab;
1836 op_pix = s->dsp.put_no_rnd_pixels_tab;
1838 if (s->mv_dir & MV_DIR_FORWARD) {
1839 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1840 op_pix = s->dsp.avg_pixels_tab;
1841 op_qpix= s->me.qpel_avg;
1843 if (s->mv_dir & MV_DIR_BACKWARD) {
1844 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1849 /* skip dequant / idct if we are really late ;) */
1850 if(s->hurry_up>1) goto skip_idct;
1851 if(s->avctx->skip_idct){
1852 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1853 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1854 || s->avctx->skip_idct >= AVDISCARD_ALL)
1858 /* add dct residue */
1859 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1860 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1861 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1862 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1863 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1864 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1866 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1867 if (s->chroma_y_shift){
1868 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1869 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1873 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1874 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1875 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1876 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1879 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1880 add_dct(s, block[0], 0, dest_y , dct_linesize);
1881 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1882 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1883 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1885 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1886 if(s->chroma_y_shift){//Chroma420
1887 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1888 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1891 dct_linesize = uvlinesize << s->interlaced_dct;
1892 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1894 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1895 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1896 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1897 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1898 if(!s->chroma_x_shift){//Chroma444
1899 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1900 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1901 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1902 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1907 else if (ENABLE_WMV2) {
1908 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1911 /* dct only in intra block */
1912 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1913 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1914 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1915 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1916 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1918 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1919 if(s->chroma_y_shift){
1920 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1921 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1925 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1926 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1927 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1928 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1932 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1933 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1934 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1935 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1937 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1938 if(s->chroma_y_shift){
1939 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1940 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1943 dct_linesize = uvlinesize << s->interlaced_dct;
1944 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1946 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1947 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1948 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1949 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1950 if(!s->chroma_x_shift){//Chroma444
1951 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1952 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1953 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1954 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1962 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1963 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1964 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1969 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1970 #ifndef CONFIG_SMALL
1971 if(s->out_format == FMT_MPEG1) {
1972 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1973 else MPV_decode_mb_internal(s, block, 0, 1);
1976 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1977 else MPV_decode_mb_internal(s, block, 0, 0);
1982 * @param h is the normal height, this will be reduced automatically if needed for the last row
1984 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1985 if (s->avctx->draw_horiz_band) {
1989 if(s->picture_structure != PICT_FRAME){
1992 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1995 h= FFMIN(h, s->avctx->height - y);
1997 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
1998 src= (AVFrame*)s->current_picture_ptr;
1999 else if(s->last_picture_ptr)
2000 src= (AVFrame*)s->last_picture_ptr;
2004 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2010 offset[0]= y * s->linesize;
2012 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2018 s->avctx->draw_horiz_band(s->avctx, src, offset,
2019 y, s->picture_structure, h);
2023 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2024 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2025 const int uvlinesize= s->current_picture.linesize[1];
2026 const int mb_size= 4 - s->avctx->lowres;
2028 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2029 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2030 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2031 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2032 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2033 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2034 //block_index is not used by mpeg2, so it is not affected by chroma_format
2036 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2037 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2038 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2040 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2042 s->dest[0] += s->mb_y * linesize << mb_size;
2043 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2044 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2048 void ff_mpeg_flush(AVCodecContext *avctx){
2050 MpegEncContext *s = avctx->priv_data;
2052 if(s==NULL || s->picture==NULL)
2055 for(i=0; i<MAX_PICTURE_COUNT; i++){
2056 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2057 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2058 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2060 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2062 s->mb_x= s->mb_y= 0;
2064 s->parse_context.state= -1;
2065 s->parse_context.frame_start_found= 0;
2066 s->parse_context.overread= 0;
2067 s->parse_context.overread_index= 0;
2068 s->parse_context.index= 0;
2069 s->parse_context.last_index= 0;
2070 s->bitstream_buffer_size=0;
2074 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2075 DCTELEM *block, int n, int qscale)
2077 int i, level, nCoeffs;
2078 const uint16_t *quant_matrix;
2080 nCoeffs= s->block_last_index[n];
2083 block[0] = block[0] * s->y_dc_scale;
2085 block[0] = block[0] * s->c_dc_scale;
2086 /* XXX: only mpeg1 */
2087 quant_matrix = s->intra_matrix;
2088 for(i=1;i<=nCoeffs;i++) {
2089 int j= s->intra_scantable.permutated[i];
2094 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2095 level = (level - 1) | 1;
2098 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2099 level = (level - 1) | 1;
2106 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2107 DCTELEM *block, int n, int qscale)
2109 int i, level, nCoeffs;
2110 const uint16_t *quant_matrix;
2112 nCoeffs= s->block_last_index[n];
2114 quant_matrix = s->inter_matrix;
2115 for(i=0; i<=nCoeffs; i++) {
2116 int j= s->intra_scantable.permutated[i];
2121 level = (((level << 1) + 1) * qscale *
2122 ((int) (quant_matrix[j]))) >> 4;
2123 level = (level - 1) | 1;
2126 level = (((level << 1) + 1) * qscale *
2127 ((int) (quant_matrix[j]))) >> 4;
2128 level = (level - 1) | 1;
2135 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2136 DCTELEM *block, int n, int qscale)
2138 int i, level, nCoeffs;
2139 const uint16_t *quant_matrix;
2141 if(s->alternate_scan) nCoeffs= 63;
2142 else nCoeffs= s->block_last_index[n];
2145 block[0] = block[0] * s->y_dc_scale;
2147 block[0] = block[0] * s->c_dc_scale;
2148 quant_matrix = s->intra_matrix;
2149 for(i=1;i<=nCoeffs;i++) {
2150 int j= s->intra_scantable.permutated[i];
2155 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2158 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2165 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2166 DCTELEM *block, int n, int qscale)
2168 int i, level, nCoeffs;
2169 const uint16_t *quant_matrix;
2172 if(s->alternate_scan) nCoeffs= 63;
2173 else nCoeffs= s->block_last_index[n];
2176 block[0] = block[0] * s->y_dc_scale;
2178 block[0] = block[0] * s->c_dc_scale;
2179 quant_matrix = s->intra_matrix;
2180 for(i=1;i<=nCoeffs;i++) {
2181 int j= s->intra_scantable.permutated[i];
2186 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2189 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2198 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2199 DCTELEM *block, int n, int qscale)
2201 int i, level, nCoeffs;
2202 const uint16_t *quant_matrix;
2205 if(s->alternate_scan) nCoeffs= 63;
2206 else nCoeffs= s->block_last_index[n];
2208 quant_matrix = s->inter_matrix;
2209 for(i=0; i<=nCoeffs; i++) {
2210 int j= s->intra_scantable.permutated[i];
2215 level = (((level << 1) + 1) * qscale *
2216 ((int) (quant_matrix[j]))) >> 4;
2219 level = (((level << 1) + 1) * qscale *
2220 ((int) (quant_matrix[j]))) >> 4;
2229 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2230 DCTELEM *block, int n, int qscale)
2232 int i, level, qmul, qadd;
2235 assert(s->block_last_index[n]>=0);
2241 block[0] = block[0] * s->y_dc_scale;
2243 block[0] = block[0] * s->c_dc_scale;
2244 qadd = (qscale - 1) | 1;
2251 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2253 for(i=1; i<=nCoeffs; i++) {
2257 level = level * qmul - qadd;
2259 level = level * qmul + qadd;
2266 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2267 DCTELEM *block, int n, int qscale)
2269 int i, level, qmul, qadd;
2272 assert(s->block_last_index[n]>=0);
2274 qadd = (qscale - 1) | 1;
2277 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2279 for(i=0; i<=nCoeffs; i++) {
2283 level = level * qmul - qadd;
2285 level = level * qmul + qadd;
2293 * set qscale and update qscale dependent variables.
2295 void ff_set_qscale(MpegEncContext * s, int qscale)
2299 else if (qscale > 31)
2303 s->chroma_qscale= s->chroma_qscale_table[qscale];
2305 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2306 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];