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 int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58 void XVMC_field_end(MpegEncContext *s);
59 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_ARM)
133 MPV_common_init_arm(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->me.temp= s->me.scratchpad;
293 s->rd_scratchpad= s->me.scratchpad;
294 s->b_scratchpad= s->me.scratchpad;
295 s->obmc_scratchpad= s->me.scratchpad + 16;
297 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
298 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
299 if(s->avctx->noise_reduction){
300 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
303 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
304 s->block= s->blocks[0];
307 s->pblocks[i] = (short *)(&s->block[i]);
311 return -1; //free() through MPV_common_end()
314 static void free_duplicate_context(MpegEncContext *s){
317 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
318 av_freep(&s->me.scratchpad);
322 s->obmc_scratchpad= NULL;
324 av_freep(&s->dct_error_sum);
325 av_freep(&s->me.map);
326 av_freep(&s->me.score_map);
327 av_freep(&s->blocks);
331 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
332 #define COPY(a) bak->a= src->a
333 COPY(allocated_edge_emu_buffer);
334 COPY(edge_emu_buffer);
339 COPY(obmc_scratchpad);
346 COPY(me.map_generation);
354 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
357 //FIXME copy only needed parts
359 backup_duplicate_context(&bak, dst);
360 memcpy(dst, src, sizeof(MpegEncContext));
361 backup_duplicate_context(dst, &bak);
363 dst->pblocks[i] = (short *)(&dst->block[i]);
365 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
369 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
370 * the changed fields will not depend upon the prior state of the MpegEncContext.
372 void MPV_common_defaults(MpegEncContext *s){
374 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
375 s->chroma_qscale_table= ff_default_chroma_qscale_table;
376 s->progressive_frame= 1;
377 s->progressive_sequence= 1;
378 s->picture_structure= PICT_FRAME;
380 s->coded_picture_number = 0;
381 s->picture_number = 0;
382 s->input_picture_number = 0;
384 s->picture_in_gop_number = 0;
391 * sets the given MpegEncContext to defaults for decoding.
392 * the changed fields will not depend upon the prior state of the MpegEncContext.
394 void MPV_decode_defaults(MpegEncContext *s){
395 MPV_common_defaults(s);
399 * init common structure for both encoder and decoder.
400 * this assumes that some variables like width/height are already set
402 int MPV_common_init(MpegEncContext *s)
404 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
406 s->mb_height = (s->height + 15) / 16;
408 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
409 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
413 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
416 dsputil_init(&s->dsp, s->avctx);
417 ff_dct_common_init(s);
419 s->flags= s->avctx->flags;
420 s->flags2= s->avctx->flags2;
422 s->mb_width = (s->width + 15) / 16;
423 s->mb_stride = s->mb_width + 1;
424 s->b8_stride = s->mb_width*2 + 1;
425 s->b4_stride = s->mb_width*4 + 1;
426 mb_array_size= s->mb_height * s->mb_stride;
427 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
429 /* set chroma shifts */
430 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
431 &(s->chroma_y_shift) );
433 /* set default edge pos, will be overriden in decode_header if needed */
434 s->h_edge_pos= s->mb_width*16;
435 s->v_edge_pos= s->mb_height*16;
437 s->mb_num = s->mb_width * s->mb_height;
442 s->block_wrap[3]= s->b8_stride;
444 s->block_wrap[5]= s->mb_stride;
446 y_size = s->b8_stride * (2 * s->mb_height + 1);
447 c_size = s->mb_stride * (s->mb_height + 1);
448 yc_size = y_size + 2 * c_size;
450 /* convert fourcc to upper case */
451 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
452 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
453 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
454 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
456 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
457 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
458 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
459 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
461 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
463 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
464 for(y=0; y<s->mb_height; y++){
465 for(x=0; x<s->mb_width; x++){
466 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
469 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
472 /* Allocate MV tables */
473 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
474 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
477 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
478 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
479 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
480 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
481 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
482 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
483 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
484 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
486 if(s->msmpeg4_version){
487 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
489 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
491 /* Allocate MB type table */
492 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
494 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
496 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
497 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
498 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
499 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
500 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
501 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
503 if(s->avctx->noise_reduction){
504 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
507 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
509 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
511 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
512 /* interlaced direct mode decoding tables */
517 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
518 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
520 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
521 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
522 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
524 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
527 if (s->out_format == FMT_H263) {
529 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
530 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
531 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
532 s->ac_val[2] = s->ac_val[1] + c_size;
535 CHECKED_ALLOCZ(s->coded_block_base, y_size);
536 s->coded_block= s->coded_block_base + s->b8_stride + 1;
538 /* cbp, ac_pred, pred_dir */
539 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
540 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
543 if (s->h263_pred || s->h263_plus || !s->encoding) {
545 //MN: we need these for error resilience of intra-frames
546 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
547 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
548 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
549 s->dc_val[2] = s->dc_val[1] + c_size;
550 for(i=0;i<yc_size;i++)
551 s->dc_val_base[i] = 1024;
554 /* which mb is a intra block */
555 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
556 memset(s->mbintra_table, 1, mb_array_size);
558 /* init macroblock skip table */
559 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
560 //Note the +1 is for a quicker mpeg4 slice_end detection
561 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
563 s->parse_context.state= -1;
564 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
565 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
566 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
567 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
570 s->context_initialized = 1;
572 s->thread_context[0]= s;
573 threads = s->avctx->thread_count;
575 for(i=1; i<threads; i++){
576 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
577 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
580 for(i=0; i<threads; i++){
581 if(init_duplicate_context(s->thread_context[i], s) < 0)
583 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
584 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
593 /* init common structure for both encoder and decoder */
594 void MPV_common_end(MpegEncContext *s)
598 for(i=0; i<s->avctx->thread_count; i++){
599 free_duplicate_context(s->thread_context[i]);
601 for(i=1; i<s->avctx->thread_count; i++){
602 av_freep(&s->thread_context[i]);
605 av_freep(&s->parse_context.buffer);
606 s->parse_context.buffer_size=0;
608 av_freep(&s->mb_type);
609 av_freep(&s->p_mv_table_base);
610 av_freep(&s->b_forw_mv_table_base);
611 av_freep(&s->b_back_mv_table_base);
612 av_freep(&s->b_bidir_forw_mv_table_base);
613 av_freep(&s->b_bidir_back_mv_table_base);
614 av_freep(&s->b_direct_mv_table_base);
616 s->b_forw_mv_table= NULL;
617 s->b_back_mv_table= NULL;
618 s->b_bidir_forw_mv_table= NULL;
619 s->b_bidir_back_mv_table= NULL;
620 s->b_direct_mv_table= NULL;
624 av_freep(&s->b_field_mv_table_base[i][j][k]);
625 s->b_field_mv_table[i][j][k]=NULL;
627 av_freep(&s->b_field_select_table[i][j]);
628 av_freep(&s->p_field_mv_table_base[i][j]);
629 s->p_field_mv_table[i][j]=NULL;
631 av_freep(&s->p_field_select_table[i]);
634 av_freep(&s->dc_val_base);
635 av_freep(&s->ac_val_base);
636 av_freep(&s->coded_block_base);
637 av_freep(&s->mbintra_table);
638 av_freep(&s->cbp_table);
639 av_freep(&s->pred_dir_table);
641 av_freep(&s->mbskip_table);
642 av_freep(&s->prev_pict_types);
643 av_freep(&s->bitstream_buffer);
644 s->allocated_bitstream_buffer_size=0;
646 av_freep(&s->avctx->stats_out);
647 av_freep(&s->ac_stats);
648 av_freep(&s->error_status_table);
649 av_freep(&s->mb_index2xy);
650 av_freep(&s->lambda_table);
651 av_freep(&s->q_intra_matrix);
652 av_freep(&s->q_inter_matrix);
653 av_freep(&s->q_intra_matrix16);
654 av_freep(&s->q_inter_matrix16);
655 av_freep(&s->input_picture);
656 av_freep(&s->reordered_input_picture);
657 av_freep(&s->dct_offset);
660 for(i=0; i<MAX_PICTURE_COUNT; i++){
661 free_picture(s, &s->picture[i]);
664 av_freep(&s->picture);
665 s->context_initialized = 0;
668 s->current_picture_ptr= NULL;
669 s->linesize= s->uvlinesize= 0;
672 av_freep(&s->visualization_buffer[i]);
674 avcodec_default_free_buffers(s->avctx);
677 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
679 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
680 uint8_t index_run[MAX_RUN+1];
681 int last, run, level, start, end, i;
683 /* If table is static, we can quit if rl->max_level[0] is not NULL */
684 if(static_store && rl->max_level[0])
687 /* compute max_level[], max_run[] and index_run[] */
688 for(last=0;last<2;last++) {
697 memset(max_level, 0, MAX_RUN + 1);
698 memset(max_run, 0, MAX_LEVEL + 1);
699 memset(index_run, rl->n, MAX_RUN + 1);
700 for(i=start;i<end;i++) {
701 run = rl->table_run[i];
702 level = rl->table_level[i];
703 if (index_run[run] == rl->n)
705 if (level > max_level[run])
706 max_level[run] = level;
707 if (run > max_run[level])
708 max_run[level] = run;
711 rl->max_level[last] = static_store[last];
713 rl->max_level[last] = av_malloc(MAX_RUN + 1);
714 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
716 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
718 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
719 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
721 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
723 rl->index_run[last] = av_malloc(MAX_RUN + 1);
724 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
728 void init_vlc_rl(RLTable *rl)
740 for(i=0; i<rl->vlc.table_size; i++){
741 int code= rl->vlc.table[i][0];
742 int len = rl->vlc.table[i][1];
745 if(len==0){ // illegal code
748 }else if(len<0){ //more bits needed
752 if(code==rl->n){ //esc
756 run= rl->table_run [code] + 1;
757 level= rl->table_level[code] * qmul + qadd;
758 if(code >= rl->last) run+=192;
761 rl->rl_vlc[q][i].len= len;
762 rl->rl_vlc[q][i].level= level;
763 rl->rl_vlc[q][i].run= run;
768 int ff_find_unused_picture(MpegEncContext *s, int shared){
772 for(i=0; i<MAX_PICTURE_COUNT; i++){
773 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
776 for(i=0; i<MAX_PICTURE_COUNT; i++){
777 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
779 for(i=0; i<MAX_PICTURE_COUNT; i++){
780 if(s->picture[i].data[0]==NULL) return i;
784 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
785 /* We could return -1, but the codec would crash trying to draw into a
786 * non-existing frame anyway. This is safer than waiting for a random crash.
787 * Also the return of this is never useful, an encoder must only allocate
788 * as much as allowed in the specification. This has no relationship to how
789 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
790 * enough for such valid streams).
791 * Plus, a decoder has to check stream validity and remove frames if too
792 * many reference frames are around. Waiting for "OOM" is not correct at
793 * all. Similarly, missing reference frames have to be replaced by
794 * interpolated/MC frames, anything else is a bug in the codec ...
800 static void update_noise_reduction(MpegEncContext *s){
803 for(intra=0; intra<2; intra++){
804 if(s->dct_count[intra] > (1<<16)){
806 s->dct_error_sum[intra][i] >>=1;
808 s->dct_count[intra] >>= 1;
812 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);
818 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
820 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
826 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
828 /* mark&release old frames */
829 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]) {
830 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
831 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
833 /* release forgotten pictures */
834 /* if(mpeg124/h263) */
836 for(i=0; i<MAX_PICTURE_COUNT; i++){
837 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
838 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
839 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
847 /* release non reference frames */
848 for(i=0; i<MAX_PICTURE_COUNT; i++){
849 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
850 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
854 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
855 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
857 i= ff_find_unused_picture(s, 0);
858 pic= (AVFrame*)&s->picture[i];
863 if (s->codec_id == CODEC_ID_H264)
864 pic->reference = s->picture_structure;
865 else if (s->pict_type != FF_B_TYPE)
869 pic->coded_picture_number= s->coded_picture_number++;
871 if( alloc_picture(s, (Picture*)pic, 0) < 0)
874 s->current_picture_ptr= (Picture*)pic;
875 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
876 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
879 s->current_picture_ptr->pict_type= s->pict_type;
880 // if(s->flags && CODEC_FLAG_QSCALE)
881 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
882 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
884 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
886 if (s->pict_type != FF_B_TYPE) {
887 s->last_picture_ptr= s->next_picture_ptr;
889 s->next_picture_ptr= s->current_picture_ptr;
891 /* 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,
892 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
893 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
894 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
895 s->pict_type, s->dropable);*/
897 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
898 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
900 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){
901 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
902 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
906 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
908 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
911 if(s->picture_structure == PICT_BOTTOM_FIELD){
912 s->current_picture.data[i] += s->current_picture.linesize[i];
914 s->current_picture.linesize[i] *= 2;
915 s->last_picture.linesize[i] *=2;
916 s->next_picture.linesize[i] *=2;
920 s->hurry_up= s->avctx->hurry_up;
921 s->error_recognition= avctx->error_recognition;
923 /* set dequantizer, we can't do it during init as it might change for mpeg4
924 and we can't do it in the header decode as init is not called for mpeg4 there yet */
925 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
926 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
927 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
928 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
929 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
930 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
932 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
933 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
936 if(s->dct_error_sum){
937 assert(s->avctx->noise_reduction && s->encoding);
939 update_noise_reduction(s);
943 if(s->avctx->xvmc_acceleration)
944 return XVMC_field_start(s, avctx);
949 /* generic function for encode/decode called after a frame has been coded/decoded */
950 void MPV_frame_end(MpegEncContext *s)
953 /* draw edge for correct motion prediction if outside */
955 //just to make sure that all data is rendered.
956 if(s->avctx->xvmc_acceleration){
960 if(!(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
961 && s->unrestricted_mv
962 && s->current_picture.reference
964 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
965 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
966 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
967 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
971 s->last_pict_type = s->pict_type;
972 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
973 if(s->pict_type!=FF_B_TYPE){
974 s->last_non_b_pict_type= s->pict_type;
977 /* copy back current_picture variables */
978 for(i=0; i<MAX_PICTURE_COUNT; i++){
979 if(s->picture[i].data[0] == s->current_picture.data[0]){
980 s->picture[i]= s->current_picture;
984 assert(i<MAX_PICTURE_COUNT);
988 /* release non-reference frames */
989 for(i=0; i<MAX_PICTURE_COUNT; i++){
990 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
991 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
995 // clear copies, to avoid confusion
997 memset(&s->last_picture, 0, sizeof(Picture));
998 memset(&s->next_picture, 0, sizeof(Picture));
999 memset(&s->current_picture, 0, sizeof(Picture));
1001 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1005 * draws an line from (ex, ey) -> (sx, sy).
1006 * @param w width of the image
1007 * @param h height of the image
1008 * @param stride stride/linesize of the image
1009 * @param color color of the arrow
1011 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1014 sx= av_clip(sx, 0, w-1);
1015 sy= av_clip(sy, 0, h-1);
1016 ex= av_clip(ex, 0, w-1);
1017 ey= av_clip(ey, 0, h-1);
1019 buf[sy*stride + sx]+= color;
1021 if(FFABS(ex - sx) > FFABS(ey - sy)){
1023 FFSWAP(int, sx, ex);
1024 FFSWAP(int, sy, ey);
1026 buf+= sx + sy*stride;
1028 f= ((ey-sy)<<16)/ex;
1029 for(x= 0; x <= ex; x++){
1032 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1033 buf[(y+1)*stride + x]+= (color* fr )>>16;
1037 FFSWAP(int, sx, ex);
1038 FFSWAP(int, sy, ey);
1040 buf+= sx + sy*stride;
1042 if(ey) f= ((ex-sx)<<16)/ey;
1044 for(y= 0; y <= ey; y++){
1047 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1048 buf[y*stride + x+1]+= (color* fr )>>16;
1054 * draws an arrow from (ex, ey) -> (sx, sy).
1055 * @param w width of the image
1056 * @param h height of the image
1057 * @param stride stride/linesize of the image
1058 * @param color color of the arrow
1060 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1063 sx= av_clip(sx, -100, w+100);
1064 sy= av_clip(sy, -100, h+100);
1065 ex= av_clip(ex, -100, w+100);
1066 ey= av_clip(ey, -100, h+100);
1071 if(dx*dx + dy*dy > 3*3){
1074 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1076 //FIXME subpixel accuracy
1077 rx= ROUNDED_DIV(rx*3<<4, length);
1078 ry= ROUNDED_DIV(ry*3<<4, length);
1080 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1081 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1083 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1087 * prints debuging info for the given picture.
1089 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1091 if(!pict || !pict->mb_type) return;
1093 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1096 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1097 switch (pict->pict_type) {
1098 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1099 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1100 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1101 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1102 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1103 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1105 for(y=0; y<s->mb_height; y++){
1106 for(x=0; x<s->mb_width; x++){
1107 if(s->avctx->debug&FF_DEBUG_SKIP){
1108 int count= s->mbskip_table[x + y*s->mb_stride];
1109 if(count>9) count=9;
1110 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1112 if(s->avctx->debug&FF_DEBUG_QP){
1113 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1115 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1116 int mb_type= pict->mb_type[x + y*s->mb_stride];
1117 //Type & MV direction
1119 av_log(s->avctx, AV_LOG_DEBUG, "P");
1120 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1121 av_log(s->avctx, AV_LOG_DEBUG, "A");
1122 else if(IS_INTRA4x4(mb_type))
1123 av_log(s->avctx, AV_LOG_DEBUG, "i");
1124 else if(IS_INTRA16x16(mb_type))
1125 av_log(s->avctx, AV_LOG_DEBUG, "I");
1126 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1127 av_log(s->avctx, AV_LOG_DEBUG, "d");
1128 else if(IS_DIRECT(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "D");
1130 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1131 av_log(s->avctx, AV_LOG_DEBUG, "g");
1132 else if(IS_GMC(mb_type))
1133 av_log(s->avctx, AV_LOG_DEBUG, "G");
1134 else if(IS_SKIP(mb_type))
1135 av_log(s->avctx, AV_LOG_DEBUG, "S");
1136 else if(!USES_LIST(mb_type, 1))
1137 av_log(s->avctx, AV_LOG_DEBUG, ">");
1138 else if(!USES_LIST(mb_type, 0))
1139 av_log(s->avctx, AV_LOG_DEBUG, "<");
1141 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1142 av_log(s->avctx, AV_LOG_DEBUG, "X");
1147 av_log(s->avctx, AV_LOG_DEBUG, "+");
1148 else if(IS_16X8(mb_type))
1149 av_log(s->avctx, AV_LOG_DEBUG, "-");
1150 else if(IS_8X16(mb_type))
1151 av_log(s->avctx, AV_LOG_DEBUG, "|");
1152 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1153 av_log(s->avctx, AV_LOG_DEBUG, " ");
1155 av_log(s->avctx, AV_LOG_DEBUG, "?");
1158 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1159 av_log(s->avctx, AV_LOG_DEBUG, "=");
1161 av_log(s->avctx, AV_LOG_DEBUG, " ");
1163 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1165 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1169 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1170 const int shift= 1 + s->quarter_sample;
1174 int h_chroma_shift, v_chroma_shift, block_height;
1175 const int width = s->avctx->width;
1176 const int height= s->avctx->height;
1177 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1178 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1179 s->low_delay=0; //needed to see the vectors without trashing the buffers
1181 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1183 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1184 pict->data[i]= s->visualization_buffer[i];
1186 pict->type= FF_BUFFER_TYPE_COPY;
1188 block_height = 16>>v_chroma_shift;
1190 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1192 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1193 const int mb_index= mb_x + mb_y*s->mb_stride;
1194 if((s->avctx->debug_mv) && pict->motion_val){
1196 for(type=0; type<3; type++){
1199 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1203 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1207 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1212 if(!USES_LIST(pict->mb_type[mb_index], direction))
1215 if(IS_8X8(pict->mb_type[mb_index])){
1218 int sx= mb_x*16 + 4 + 8*(i&1);
1219 int sy= mb_y*16 + 4 + 8*(i>>1);
1220 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1221 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1222 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1223 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1225 }else if(IS_16X8(pict->mb_type[mb_index])){
1229 int sy=mb_y*16 + 4 + 8*i;
1230 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1231 int mx=(pict->motion_val[direction][xy][0]>>shift);
1232 int my=(pict->motion_val[direction][xy][1]>>shift);
1234 if(IS_INTERLACED(pict->mb_type[mb_index]))
1237 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1239 }else if(IS_8X16(pict->mb_type[mb_index])){
1242 int sx=mb_x*16 + 4 + 8*i;
1244 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1245 int mx=(pict->motion_val[direction][xy][0]>>shift);
1246 int my=(pict->motion_val[direction][xy][1]>>shift);
1248 if(IS_INTERLACED(pict->mb_type[mb_index]))
1251 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1254 int sx= mb_x*16 + 8;
1255 int sy= mb_y*16 + 8;
1256 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1257 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1258 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1259 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1263 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1264 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1266 for(y=0; y<block_height; y++){
1267 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1268 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1271 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1272 int mb_type= pict->mb_type[mb_index];
1275 #define COLOR(theta, r)\
1276 u= (int)(128 + r*cos(theta*3.141592/180));\
1277 v= (int)(128 + r*sin(theta*3.141592/180));
1281 if(IS_PCM(mb_type)){
1283 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1285 }else if(IS_INTRA4x4(mb_type)){
1287 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1289 }else if(IS_DIRECT(mb_type)){
1291 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1293 }else if(IS_GMC(mb_type)){
1295 }else if(IS_SKIP(mb_type)){
1297 }else if(!USES_LIST(mb_type, 1)){
1299 }else if(!USES_LIST(mb_type, 0)){
1302 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1306 u*= 0x0101010101010101ULL;
1307 v*= 0x0101010101010101ULL;
1308 for(y=0; y<block_height; y++){
1309 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1310 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1314 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1315 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1316 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1318 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1320 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1322 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1323 int dm= 1 << (mv_sample_log2-2);
1325 int sx= mb_x*16 + 8*(i&1);
1326 int sy= mb_y*16 + 8*(i>>1);
1327 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1329 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1330 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1332 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1333 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1334 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1338 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1342 s->mbskip_table[mb_index]=0;
1348 static inline int hpel_motion_lowres(MpegEncContext *s,
1349 uint8_t *dest, uint8_t *src,
1350 int field_based, int field_select,
1351 int src_x, int src_y,
1352 int width, int height, int stride,
1353 int h_edge_pos, int v_edge_pos,
1354 int w, int h, h264_chroma_mc_func *pix_op,
1355 int motion_x, int motion_y)
1357 const int lowres= s->avctx->lowres;
1358 const int s_mask= (2<<lowres)-1;
1362 if(s->quarter_sample){
1367 sx= motion_x & s_mask;
1368 sy= motion_y & s_mask;
1369 src_x += motion_x >> (lowres+1);
1370 src_y += motion_y >> (lowres+1);
1372 src += src_y * stride + src_x;
1374 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1375 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1376 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1377 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1378 src= s->edge_emu_buffer;
1386 pix_op[lowres](dest, src, stride, h, sx, sy);
1390 /* apply one mpeg motion vector to the three components */
1391 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1392 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1393 int field_based, int bottom_field, int field_select,
1394 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1395 int motion_x, int motion_y, int h)
1397 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1398 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1399 const int lowres= s->avctx->lowres;
1400 const int block_s= 8>>lowres;
1401 const int s_mask= (2<<lowres)-1;
1402 const int h_edge_pos = s->h_edge_pos >> lowres;
1403 const int v_edge_pos = s->v_edge_pos >> lowres;
1404 linesize = s->current_picture.linesize[0] << field_based;
1405 uvlinesize = s->current_picture.linesize[1] << field_based;
1407 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1413 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1416 sx= motion_x & s_mask;
1417 sy= motion_y & s_mask;
1418 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1419 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1421 if (s->out_format == FMT_H263) {
1422 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1423 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1426 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1429 uvsx = (2*mx) & s_mask;
1430 uvsy = (2*my) & s_mask;
1431 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1432 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1438 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1439 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1442 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1443 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1444 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1446 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1447 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1448 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1449 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1450 ptr_y = s->edge_emu_buffer;
1451 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1452 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1453 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1454 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1455 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1456 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1462 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1463 dest_y += s->linesize;
1464 dest_cb+= s->uvlinesize;
1465 dest_cr+= s->uvlinesize;
1469 ptr_y += s->linesize;
1470 ptr_cb+= s->uvlinesize;
1471 ptr_cr+= s->uvlinesize;
1476 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1478 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1479 uvsx <<= 2 - lowres;
1480 uvsy <<= 2 - lowres;
1481 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1482 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1484 //FIXME h261 lowres loop filter
1487 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1488 uint8_t *dest_cb, uint8_t *dest_cr,
1489 uint8_t **ref_picture,
1490 h264_chroma_mc_func *pix_op,
1492 const int lowres= s->avctx->lowres;
1493 const int block_s= 8>>lowres;
1494 const int s_mask= (2<<lowres)-1;
1495 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1496 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1497 int emu=0, src_x, src_y, offset, sx, sy;
1500 if(s->quarter_sample){
1505 /* In case of 8X8, we construct a single chroma motion vector
1506 with a special rounding */
1507 mx= ff_h263_round_chroma(mx);
1508 my= ff_h263_round_chroma(my);
1512 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1513 src_y = s->mb_y*block_s + (my >> (lowres+1));
1515 offset = src_y * s->uvlinesize + src_x;
1516 ptr = ref_picture[1] + offset;
1517 if(s->flags&CODEC_FLAG_EMU_EDGE){
1518 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1519 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1520 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1521 ptr= s->edge_emu_buffer;
1527 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1529 ptr = ref_picture[2] + offset;
1531 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1532 ptr= s->edge_emu_buffer;
1534 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1538 * motion compensation of a single macroblock
1540 * @param dest_y luma destination pointer
1541 * @param dest_cb chroma cb/u destination pointer
1542 * @param dest_cr chroma cr/v destination pointer
1543 * @param dir direction (0->forward, 1->backward)
1544 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1545 * @param pic_op halfpel motion compensation function (average or put normally)
1546 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1548 static inline void MPV_motion_lowres(MpegEncContext *s,
1549 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1550 int dir, uint8_t **ref_picture,
1551 h264_chroma_mc_func *pix_op)
1555 const int lowres= s->avctx->lowres;
1556 const int block_s= 8>>lowres;
1561 switch(s->mv_type) {
1563 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1565 ref_picture, pix_op,
1566 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1572 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1573 ref_picture[0], 0, 0,
1574 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1575 s->width, s->height, s->linesize,
1576 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1577 block_s, block_s, pix_op,
1578 s->mv[dir][i][0], s->mv[dir][i][1]);
1580 mx += s->mv[dir][i][0];
1581 my += s->mv[dir][i][1];
1584 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1585 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1588 if (s->picture_structure == PICT_FRAME) {
1590 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1591 1, 0, s->field_select[dir][0],
1592 ref_picture, pix_op,
1593 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1595 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1596 1, 1, s->field_select[dir][1],
1597 ref_picture, pix_op,
1598 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1600 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1601 ref_picture= s->current_picture_ptr->data;
1604 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1605 0, 0, s->field_select[dir][0],
1606 ref_picture, pix_op,
1607 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1612 uint8_t ** ref2picture;
1614 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1615 ref2picture= ref_picture;
1617 ref2picture= s->current_picture_ptr->data;
1620 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1621 0, 0, s->field_select[dir][i],
1622 ref2picture, pix_op,
1623 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1625 dest_y += 2*block_s*s->linesize;
1626 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1627 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1631 if(s->picture_structure == PICT_FRAME){
1635 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1637 ref_picture, pix_op,
1638 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1640 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1644 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1645 0, 0, s->picture_structure != i+1,
1646 ref_picture, pix_op,
1647 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1649 // after put we make avg of the same block
1650 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1652 //opposite parity is always in the same frame if this is second field
1653 if(!s->first_field){
1654 ref_picture = s->current_picture_ptr->data;
1663 /* put block[] to dest[] */
1664 static inline void put_dct(MpegEncContext *s,
1665 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1667 s->dct_unquantize_intra(s, block, i, qscale);
1668 s->dsp.idct_put (dest, line_size, block);
1671 /* add block[] to dest[] */
1672 static inline void add_dct(MpegEncContext *s,
1673 DCTELEM *block, int i, uint8_t *dest, int line_size)
1675 if (s->block_last_index[i] >= 0) {
1676 s->dsp.idct_add (dest, line_size, block);
1680 static inline void add_dequant_dct(MpegEncContext *s,
1681 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1683 if (s->block_last_index[i] >= 0) {
1684 s->dct_unquantize_inter(s, block, i, qscale);
1686 s->dsp.idct_add (dest, line_size, block);
1691 * cleans dc, ac, coded_block for the current non intra MB
1693 void ff_clean_intra_table_entries(MpegEncContext *s)
1695 int wrap = s->b8_stride;
1696 int xy = s->block_index[0];
1699 s->dc_val[0][xy + 1 ] =
1700 s->dc_val[0][xy + wrap] =
1701 s->dc_val[0][xy + 1 + wrap] = 1024;
1703 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1704 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1705 if (s->msmpeg4_version>=3) {
1706 s->coded_block[xy ] =
1707 s->coded_block[xy + 1 ] =
1708 s->coded_block[xy + wrap] =
1709 s->coded_block[xy + 1 + wrap] = 0;
1712 wrap = s->mb_stride;
1713 xy = s->mb_x + s->mb_y * wrap;
1715 s->dc_val[2][xy] = 1024;
1717 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1718 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1720 s->mbintra_table[xy]= 0;
1723 /* generic function called after a macroblock has been parsed by the
1724 decoder or after it has been encoded by the encoder.
1726 Important variables used:
1727 s->mb_intra : true if intra macroblock
1728 s->mv_dir : motion vector direction
1729 s->mv_type : motion vector type
1730 s->mv : motion vector
1731 s->interlaced_dct : true if interlaced dct used (mpeg2)
1733 static av_always_inline
1734 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1735 int lowres_flag, int is_mpeg12)
1738 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1740 if(s->avctx->xvmc_acceleration){
1741 XVMC_decode_mb(s);//xvmc uses pblocks
1749 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1750 /* save DCT coefficients */
1752 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1755 *dct++ = block[i][s->dsp.idct_permutation[j]];
1758 s->current_picture.qscale_table[mb_xy]= s->qscale;
1760 /* update DC predictors for P macroblocks */
1762 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1763 if(s->mbintra_table[mb_xy])
1764 ff_clean_intra_table_entries(s);
1768 s->last_dc[2] = 128 << s->intra_dc_precision;
1771 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1772 s->mbintra_table[mb_xy]=1;
1774 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
1775 uint8_t *dest_y, *dest_cb, *dest_cr;
1776 int dct_linesize, dct_offset;
1777 op_pixels_func (*op_pix)[4];
1778 qpel_mc_func (*op_qpix)[16];
1779 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1780 const int uvlinesize= s->current_picture.linesize[1];
1781 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1782 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1784 /* avoid copy if macroblock skipped in last frame too */
1785 /* skip only during decoding as we might trash the buffers during encoding a bit */
1787 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1788 const int age= s->current_picture.age;
1792 if (s->mb_skipped) {
1794 assert(s->pict_type!=FF_I_TYPE);
1796 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1797 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1799 /* if previous was skipped too, then nothing to do ! */
1800 if (*mbskip_ptr >= age && s->current_picture.reference){
1803 } else if(!s->current_picture.reference){
1804 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1805 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1807 *mbskip_ptr = 0; /* not skipped */
1811 dct_linesize = linesize << s->interlaced_dct;
1812 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1816 dest_cb= s->dest[1];
1817 dest_cr= s->dest[2];
1819 dest_y = s->b_scratchpad;
1820 dest_cb= s->b_scratchpad+16*linesize;
1821 dest_cr= s->b_scratchpad+32*linesize;
1825 /* motion handling */
1826 /* decoding or more than one mb_type (MC was already done otherwise) */
1829 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1831 if (s->mv_dir & MV_DIR_FORWARD) {
1832 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1833 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1835 if (s->mv_dir & MV_DIR_BACKWARD) {
1836 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1839 op_qpix= s->me.qpel_put;
1840 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1841 op_pix = s->dsp.put_pixels_tab;
1843 op_pix = s->dsp.put_no_rnd_pixels_tab;
1845 if (s->mv_dir & MV_DIR_FORWARD) {
1846 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1847 op_pix = s->dsp.avg_pixels_tab;
1848 op_qpix= s->me.qpel_avg;
1850 if (s->mv_dir & MV_DIR_BACKWARD) {
1851 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1856 /* skip dequant / idct if we are really late ;) */
1857 if(s->hurry_up>1) goto skip_idct;
1858 if(s->avctx->skip_idct){
1859 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1860 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1861 || s->avctx->skip_idct >= AVDISCARD_ALL)
1865 /* add dct residue */
1866 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1867 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1868 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1869 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1870 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1871 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1873 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1874 if (s->chroma_y_shift){
1875 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1876 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1880 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1881 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1882 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1883 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1886 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1887 add_dct(s, block[0], 0, dest_y , dct_linesize);
1888 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1889 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1890 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1892 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1893 if(s->chroma_y_shift){//Chroma420
1894 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1895 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1898 dct_linesize = uvlinesize << s->interlaced_dct;
1899 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1901 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1902 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1903 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1904 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1905 if(!s->chroma_x_shift){//Chroma444
1906 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1907 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1908 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1909 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1914 else if (ENABLE_WMV2) {
1915 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1918 /* dct only in intra block */
1919 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1920 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1921 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1922 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1923 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1925 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1926 if(s->chroma_y_shift){
1927 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1928 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1932 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1933 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1934 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1935 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1939 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1940 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1941 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1942 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1944 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1945 if(s->chroma_y_shift){
1946 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1947 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1950 dct_linesize = uvlinesize << s->interlaced_dct;
1951 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1953 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1954 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1955 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1956 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1957 if(!s->chroma_x_shift){//Chroma444
1958 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1959 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1960 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1961 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1969 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1970 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1971 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1976 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1977 #ifndef CONFIG_SMALL
1978 if(s->out_format == FMT_MPEG1) {
1979 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1980 else MPV_decode_mb_internal(s, block, 0, 1);
1983 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1984 else MPV_decode_mb_internal(s, block, 0, 0);
1989 * @param h is the normal height, this will be reduced automatically if needed for the last row
1991 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1992 if (s->avctx->draw_horiz_band) {
1996 if(s->picture_structure != PICT_FRAME){
1999 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2002 h= FFMIN(h, s->avctx->height - y);
2004 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2005 src= (AVFrame*)s->current_picture_ptr;
2006 else if(s->last_picture_ptr)
2007 src= (AVFrame*)s->last_picture_ptr;
2011 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2017 offset[0]= y * s->linesize;
2019 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2025 s->avctx->draw_horiz_band(s->avctx, src, offset,
2026 y, s->picture_structure, h);
2030 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2031 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2032 const int uvlinesize= s->current_picture.linesize[1];
2033 const int mb_size= 4 - s->avctx->lowres;
2035 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2036 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2037 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2038 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2039 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2040 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;
2041 //block_index is not used by mpeg2, so it is not affected by chroma_format
2043 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2044 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2045 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2047 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2049 s->dest[0] += s->mb_y * linesize << mb_size;
2050 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2051 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2055 void ff_mpeg_flush(AVCodecContext *avctx){
2057 MpegEncContext *s = avctx->priv_data;
2059 if(s==NULL || s->picture==NULL)
2062 for(i=0; i<MAX_PICTURE_COUNT; i++){
2063 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2064 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2065 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2067 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2069 s->mb_x= s->mb_y= 0;
2071 s->parse_context.state= -1;
2072 s->parse_context.frame_start_found= 0;
2073 s->parse_context.overread= 0;
2074 s->parse_context.overread_index= 0;
2075 s->parse_context.index= 0;
2076 s->parse_context.last_index= 0;
2077 s->bitstream_buffer_size=0;
2081 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2082 DCTELEM *block, int n, int qscale)
2084 int i, level, nCoeffs;
2085 const uint16_t *quant_matrix;
2087 nCoeffs= s->block_last_index[n];
2090 block[0] = block[0] * s->y_dc_scale;
2092 block[0] = block[0] * s->c_dc_scale;
2093 /* XXX: only mpeg1 */
2094 quant_matrix = s->intra_matrix;
2095 for(i=1;i<=nCoeffs;i++) {
2096 int j= s->intra_scantable.permutated[i];
2101 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2102 level = (level - 1) | 1;
2105 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2106 level = (level - 1) | 1;
2113 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2114 DCTELEM *block, int n, int qscale)
2116 int i, level, nCoeffs;
2117 const uint16_t *quant_matrix;
2119 nCoeffs= s->block_last_index[n];
2121 quant_matrix = s->inter_matrix;
2122 for(i=0; i<=nCoeffs; i++) {
2123 int j= s->intra_scantable.permutated[i];
2128 level = (((level << 1) + 1) * qscale *
2129 ((int) (quant_matrix[j]))) >> 4;
2130 level = (level - 1) | 1;
2133 level = (((level << 1) + 1) * qscale *
2134 ((int) (quant_matrix[j]))) >> 4;
2135 level = (level - 1) | 1;
2142 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2143 DCTELEM *block, int n, int qscale)
2145 int i, level, nCoeffs;
2146 const uint16_t *quant_matrix;
2148 if(s->alternate_scan) nCoeffs= 63;
2149 else nCoeffs= s->block_last_index[n];
2152 block[0] = block[0] * s->y_dc_scale;
2154 block[0] = block[0] * s->c_dc_scale;
2155 quant_matrix = s->intra_matrix;
2156 for(i=1;i<=nCoeffs;i++) {
2157 int j= s->intra_scantable.permutated[i];
2162 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2165 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2172 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2173 DCTELEM *block, int n, int qscale)
2175 int i, level, nCoeffs;
2176 const uint16_t *quant_matrix;
2179 if(s->alternate_scan) nCoeffs= 63;
2180 else nCoeffs= s->block_last_index[n];
2183 block[0] = block[0] * s->y_dc_scale;
2185 block[0] = block[0] * s->c_dc_scale;
2186 quant_matrix = s->intra_matrix;
2187 for(i=1;i<=nCoeffs;i++) {
2188 int j= s->intra_scantable.permutated[i];
2193 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2196 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2205 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2206 DCTELEM *block, int n, int qscale)
2208 int i, level, nCoeffs;
2209 const uint16_t *quant_matrix;
2212 if(s->alternate_scan) nCoeffs= 63;
2213 else nCoeffs= s->block_last_index[n];
2215 quant_matrix = s->inter_matrix;
2216 for(i=0; i<=nCoeffs; i++) {
2217 int j= s->intra_scantable.permutated[i];
2222 level = (((level << 1) + 1) * qscale *
2223 ((int) (quant_matrix[j]))) >> 4;
2226 level = (((level << 1) + 1) * qscale *
2227 ((int) (quant_matrix[j]))) >> 4;
2236 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2237 DCTELEM *block, int n, int qscale)
2239 int i, level, qmul, qadd;
2242 assert(s->block_last_index[n]>=0);
2248 block[0] = block[0] * s->y_dc_scale;
2250 block[0] = block[0] * s->c_dc_scale;
2251 qadd = (qscale - 1) | 1;
2258 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2260 for(i=1; i<=nCoeffs; i++) {
2264 level = level * qmul - qadd;
2266 level = level * qmul + qadd;
2273 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2274 DCTELEM *block, int n, int qscale)
2276 int i, level, qmul, qadd;
2279 assert(s->block_last_index[n]>=0);
2281 qadd = (qscale - 1) | 1;
2284 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2286 for(i=0; i<=nCoeffs; i++) {
2290 level = level * qmul - qadd;
2292 level = level * qmul + qadd;
2300 * set qscale and update qscale dependent variables.
2302 void ff_set_qscale(MpegEncContext * s, int qscale)
2306 else if (qscale > 31)
2310 s->chroma_qscale= s->chroma_qscale_table[qscale];
2312 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2313 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];