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->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
961 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
962 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
963 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
967 s->last_pict_type = s->pict_type;
968 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
969 if(s->pict_type!=FF_B_TYPE){
970 s->last_non_b_pict_type= s->pict_type;
973 /* copy back current_picture variables */
974 for(i=0; i<MAX_PICTURE_COUNT; i++){
975 if(s->picture[i].data[0] == s->current_picture.data[0]){
976 s->picture[i]= s->current_picture;
980 assert(i<MAX_PICTURE_COUNT);
984 /* release non-reference frames */
985 for(i=0; i<MAX_PICTURE_COUNT; i++){
986 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
987 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
991 // clear copies, to avoid confusion
993 memset(&s->last_picture, 0, sizeof(Picture));
994 memset(&s->next_picture, 0, sizeof(Picture));
995 memset(&s->current_picture, 0, sizeof(Picture));
997 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1001 * draws an line from (ex, ey) -> (sx, sy).
1002 * @param w width of the image
1003 * @param h height of the image
1004 * @param stride stride/linesize of the image
1005 * @param color color of the arrow
1007 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1010 sx= av_clip(sx, 0, w-1);
1011 sy= av_clip(sy, 0, h-1);
1012 ex= av_clip(ex, 0, w-1);
1013 ey= av_clip(ey, 0, h-1);
1015 buf[sy*stride + sx]+= color;
1017 if(FFABS(ex - sx) > FFABS(ey - sy)){
1019 FFSWAP(int, sx, ex);
1020 FFSWAP(int, sy, ey);
1022 buf+= sx + sy*stride;
1024 f= ((ey-sy)<<16)/ex;
1025 for(x= 0; x <= ex; x++){
1028 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1029 buf[(y+1)*stride + x]+= (color* fr )>>16;
1033 FFSWAP(int, sx, ex);
1034 FFSWAP(int, sy, ey);
1036 buf+= sx + sy*stride;
1038 if(ey) f= ((ex-sx)<<16)/ey;
1040 for(y= 0; y <= ey; y++){
1043 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1044 buf[y*stride + x+1]+= (color* fr )>>16;
1050 * draws an arrow from (ex, ey) -> (sx, sy).
1051 * @param w width of the image
1052 * @param h height of the image
1053 * @param stride stride/linesize of the image
1054 * @param color color of the arrow
1056 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1059 sx= av_clip(sx, -100, w+100);
1060 sy= av_clip(sy, -100, h+100);
1061 ex= av_clip(ex, -100, w+100);
1062 ey= av_clip(ey, -100, h+100);
1067 if(dx*dx + dy*dy > 3*3){
1070 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1072 //FIXME subpixel accuracy
1073 rx= ROUNDED_DIV(rx*3<<4, length);
1074 ry= ROUNDED_DIV(ry*3<<4, length);
1076 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1077 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1079 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1083 * prints debuging info for the given picture.
1085 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1087 if(!pict || !pict->mb_type) return;
1089 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1092 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1093 switch (pict->pict_type) {
1094 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1095 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1096 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1097 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1098 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1099 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1101 for(y=0; y<s->mb_height; y++){
1102 for(x=0; x<s->mb_width; x++){
1103 if(s->avctx->debug&FF_DEBUG_SKIP){
1104 int count= s->mbskip_table[x + y*s->mb_stride];
1105 if(count>9) count=9;
1106 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1108 if(s->avctx->debug&FF_DEBUG_QP){
1109 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1111 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1112 int mb_type= pict->mb_type[x + y*s->mb_stride];
1113 //Type & MV direction
1115 av_log(s->avctx, AV_LOG_DEBUG, "P");
1116 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1117 av_log(s->avctx, AV_LOG_DEBUG, "A");
1118 else if(IS_INTRA4x4(mb_type))
1119 av_log(s->avctx, AV_LOG_DEBUG, "i");
1120 else if(IS_INTRA16x16(mb_type))
1121 av_log(s->avctx, AV_LOG_DEBUG, "I");
1122 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1123 av_log(s->avctx, AV_LOG_DEBUG, "d");
1124 else if(IS_DIRECT(mb_type))
1125 av_log(s->avctx, AV_LOG_DEBUG, "D");
1126 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1127 av_log(s->avctx, AV_LOG_DEBUG, "g");
1128 else if(IS_GMC(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "G");
1130 else if(IS_SKIP(mb_type))
1131 av_log(s->avctx, AV_LOG_DEBUG, "S");
1132 else if(!USES_LIST(mb_type, 1))
1133 av_log(s->avctx, AV_LOG_DEBUG, ">");
1134 else if(!USES_LIST(mb_type, 0))
1135 av_log(s->avctx, AV_LOG_DEBUG, "<");
1137 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1138 av_log(s->avctx, AV_LOG_DEBUG, "X");
1143 av_log(s->avctx, AV_LOG_DEBUG, "+");
1144 else if(IS_16X8(mb_type))
1145 av_log(s->avctx, AV_LOG_DEBUG, "-");
1146 else if(IS_8X16(mb_type))
1147 av_log(s->avctx, AV_LOG_DEBUG, "|");
1148 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1149 av_log(s->avctx, AV_LOG_DEBUG, " ");
1151 av_log(s->avctx, AV_LOG_DEBUG, "?");
1154 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1155 av_log(s->avctx, AV_LOG_DEBUG, "=");
1157 av_log(s->avctx, AV_LOG_DEBUG, " ");
1159 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1161 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1165 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1166 const int shift= 1 + s->quarter_sample;
1170 int h_chroma_shift, v_chroma_shift, block_height;
1171 const int width = s->avctx->width;
1172 const int height= s->avctx->height;
1173 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1174 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1175 s->low_delay=0; //needed to see the vectors without trashing the buffers
1177 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1179 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1180 pict->data[i]= s->visualization_buffer[i];
1182 pict->type= FF_BUFFER_TYPE_COPY;
1184 block_height = 16>>v_chroma_shift;
1186 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1188 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1189 const int mb_index= mb_x + mb_y*s->mb_stride;
1190 if((s->avctx->debug_mv) && pict->motion_val){
1192 for(type=0; type<3; type++){
1195 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1199 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1203 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1208 if(!USES_LIST(pict->mb_type[mb_index], direction))
1211 if(IS_8X8(pict->mb_type[mb_index])){
1214 int sx= mb_x*16 + 4 + 8*(i&1);
1215 int sy= mb_y*16 + 4 + 8*(i>>1);
1216 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1217 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1218 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1219 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1221 }else if(IS_16X8(pict->mb_type[mb_index])){
1225 int sy=mb_y*16 + 4 + 8*i;
1226 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1227 int mx=(pict->motion_val[direction][xy][0]>>shift);
1228 int my=(pict->motion_val[direction][xy][1]>>shift);
1230 if(IS_INTERLACED(pict->mb_type[mb_index]))
1233 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1235 }else if(IS_8X16(pict->mb_type[mb_index])){
1238 int sx=mb_x*16 + 4 + 8*i;
1240 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1241 int mx=(pict->motion_val[direction][xy][0]>>shift);
1242 int my=(pict->motion_val[direction][xy][1]>>shift);
1244 if(IS_INTERLACED(pict->mb_type[mb_index]))
1247 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1250 int sx= mb_x*16 + 8;
1251 int sy= mb_y*16 + 8;
1252 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1253 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1254 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1255 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1259 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1260 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1262 for(y=0; y<block_height; y++){
1263 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1264 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1267 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1268 int mb_type= pict->mb_type[mb_index];
1271 #define COLOR(theta, r)\
1272 u= (int)(128 + r*cos(theta*3.141592/180));\
1273 v= (int)(128 + r*sin(theta*3.141592/180));
1277 if(IS_PCM(mb_type)){
1279 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1281 }else if(IS_INTRA4x4(mb_type)){
1283 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1285 }else if(IS_DIRECT(mb_type)){
1287 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1289 }else if(IS_GMC(mb_type)){
1291 }else if(IS_SKIP(mb_type)){
1293 }else if(!USES_LIST(mb_type, 1)){
1295 }else if(!USES_LIST(mb_type, 0)){
1298 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1302 u*= 0x0101010101010101ULL;
1303 v*= 0x0101010101010101ULL;
1304 for(y=0; y<block_height; y++){
1305 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1306 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1310 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1311 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1312 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1314 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1316 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1318 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1319 int dm= 1 << (mv_sample_log2-2);
1321 int sx= mb_x*16 + 8*(i&1);
1322 int sy= mb_y*16 + 8*(i>>1);
1323 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1325 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1326 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1328 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1329 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1330 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1334 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1338 s->mbskip_table[mb_index]=0;
1344 static inline int hpel_motion_lowres(MpegEncContext *s,
1345 uint8_t *dest, uint8_t *src,
1346 int field_based, int field_select,
1347 int src_x, int src_y,
1348 int width, int height, int stride,
1349 int h_edge_pos, int v_edge_pos,
1350 int w, int h, h264_chroma_mc_func *pix_op,
1351 int motion_x, int motion_y)
1353 const int lowres= s->avctx->lowres;
1354 const int s_mask= (2<<lowres)-1;
1358 if(s->quarter_sample){
1363 sx= motion_x & s_mask;
1364 sy= motion_y & s_mask;
1365 src_x += motion_x >> (lowres+1);
1366 src_y += motion_y >> (lowres+1);
1368 src += src_y * stride + src_x;
1370 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1371 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1372 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1373 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1374 src= s->edge_emu_buffer;
1382 pix_op[lowres](dest, src, stride, h, sx, sy);
1386 /* apply one mpeg motion vector to the three components */
1387 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1388 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1389 int field_based, int bottom_field, int field_select,
1390 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1391 int motion_x, int motion_y, int h)
1393 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1394 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1395 const int lowres= s->avctx->lowres;
1396 const int block_s= 8>>lowres;
1397 const int s_mask= (2<<lowres)-1;
1398 const int h_edge_pos = s->h_edge_pos >> lowres;
1399 const int v_edge_pos = s->v_edge_pos >> lowres;
1400 linesize = s->current_picture.linesize[0] << field_based;
1401 uvlinesize = s->current_picture.linesize[1] << field_based;
1403 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1409 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1412 sx= motion_x & s_mask;
1413 sy= motion_y & s_mask;
1414 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1415 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1417 if (s->out_format == FMT_H263) {
1418 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1419 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1422 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1425 uvsx = (2*mx) & s_mask;
1426 uvsy = (2*my) & s_mask;
1427 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1428 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1434 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1435 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1438 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1439 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1440 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1442 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1443 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1444 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1445 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1446 ptr_y = s->edge_emu_buffer;
1447 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1448 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1449 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1450 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1451 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1452 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1458 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1459 dest_y += s->linesize;
1460 dest_cb+= s->uvlinesize;
1461 dest_cr+= s->uvlinesize;
1465 ptr_y += s->linesize;
1466 ptr_cb+= s->uvlinesize;
1467 ptr_cr+= s->uvlinesize;
1472 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1474 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1475 uvsx <<= 2 - lowres;
1476 uvsy <<= 2 - lowres;
1477 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1478 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1480 //FIXME h261 lowres loop filter
1483 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1484 uint8_t *dest_cb, uint8_t *dest_cr,
1485 uint8_t **ref_picture,
1486 h264_chroma_mc_func *pix_op,
1488 const int lowres= s->avctx->lowres;
1489 const int block_s= 8>>lowres;
1490 const int s_mask= (2<<lowres)-1;
1491 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1492 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1493 int emu=0, src_x, src_y, offset, sx, sy;
1496 if(s->quarter_sample){
1501 /* In case of 8X8, we construct a single chroma motion vector
1502 with a special rounding */
1503 mx= ff_h263_round_chroma(mx);
1504 my= ff_h263_round_chroma(my);
1508 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1509 src_y = s->mb_y*block_s + (my >> (lowres+1));
1511 offset = src_y * s->uvlinesize + src_x;
1512 ptr = ref_picture[1] + offset;
1513 if(s->flags&CODEC_FLAG_EMU_EDGE){
1514 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1515 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1516 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1517 ptr= s->edge_emu_buffer;
1523 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1525 ptr = ref_picture[2] + offset;
1527 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1528 ptr= s->edge_emu_buffer;
1530 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1534 * motion compensation of a single macroblock
1536 * @param dest_y luma destination pointer
1537 * @param dest_cb chroma cb/u destination pointer
1538 * @param dest_cr chroma cr/v destination pointer
1539 * @param dir direction (0->forward, 1->backward)
1540 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1541 * @param pic_op halfpel motion compensation function (average or put normally)
1542 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1544 static inline void MPV_motion_lowres(MpegEncContext *s,
1545 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1546 int dir, uint8_t **ref_picture,
1547 h264_chroma_mc_func *pix_op)
1551 const int lowres= s->avctx->lowres;
1552 const int block_s= 8>>lowres;
1557 switch(s->mv_type) {
1559 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1561 ref_picture, pix_op,
1562 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1568 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1569 ref_picture[0], 0, 0,
1570 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1571 s->width, s->height, s->linesize,
1572 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1573 block_s, block_s, pix_op,
1574 s->mv[dir][i][0], s->mv[dir][i][1]);
1576 mx += s->mv[dir][i][0];
1577 my += s->mv[dir][i][1];
1580 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1581 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1584 if (s->picture_structure == PICT_FRAME) {
1586 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1587 1, 0, s->field_select[dir][0],
1588 ref_picture, pix_op,
1589 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1591 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1592 1, 1, s->field_select[dir][1],
1593 ref_picture, pix_op,
1594 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1596 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1597 ref_picture= s->current_picture_ptr->data;
1600 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1601 0, 0, s->field_select[dir][0],
1602 ref_picture, pix_op,
1603 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1608 uint8_t ** ref2picture;
1610 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1611 ref2picture= ref_picture;
1613 ref2picture= s->current_picture_ptr->data;
1616 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1617 0, 0, s->field_select[dir][i],
1618 ref2picture, pix_op,
1619 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1621 dest_y += 2*block_s*s->linesize;
1622 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1623 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1627 if(s->picture_structure == PICT_FRAME){
1631 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1633 ref_picture, pix_op,
1634 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1636 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1640 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1641 0, 0, s->picture_structure != i+1,
1642 ref_picture, pix_op,
1643 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1645 // after put we make avg of the same block
1646 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1648 //opposite parity is always in the same frame if this is second field
1649 if(!s->first_field){
1650 ref_picture = s->current_picture_ptr->data;
1659 /* put block[] to dest[] */
1660 static inline void put_dct(MpegEncContext *s,
1661 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1663 s->dct_unquantize_intra(s, block, i, qscale);
1664 s->dsp.idct_put (dest, line_size, block);
1667 /* add block[] to dest[] */
1668 static inline void add_dct(MpegEncContext *s,
1669 DCTELEM *block, int i, uint8_t *dest, int line_size)
1671 if (s->block_last_index[i] >= 0) {
1672 s->dsp.idct_add (dest, line_size, block);
1676 static inline void add_dequant_dct(MpegEncContext *s,
1677 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1679 if (s->block_last_index[i] >= 0) {
1680 s->dct_unquantize_inter(s, block, i, qscale);
1682 s->dsp.idct_add (dest, line_size, block);
1687 * cleans dc, ac, coded_block for the current non intra MB
1689 void ff_clean_intra_table_entries(MpegEncContext *s)
1691 int wrap = s->b8_stride;
1692 int xy = s->block_index[0];
1695 s->dc_val[0][xy + 1 ] =
1696 s->dc_val[0][xy + wrap] =
1697 s->dc_val[0][xy + 1 + wrap] = 1024;
1699 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1700 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1701 if (s->msmpeg4_version>=3) {
1702 s->coded_block[xy ] =
1703 s->coded_block[xy + 1 ] =
1704 s->coded_block[xy + wrap] =
1705 s->coded_block[xy + 1 + wrap] = 0;
1708 wrap = s->mb_stride;
1709 xy = s->mb_x + s->mb_y * wrap;
1711 s->dc_val[2][xy] = 1024;
1713 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1714 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1716 s->mbintra_table[xy]= 0;
1719 /* generic function called after a macroblock has been parsed by the
1720 decoder or after it has been encoded by the encoder.
1722 Important variables used:
1723 s->mb_intra : true if intra macroblock
1724 s->mv_dir : motion vector direction
1725 s->mv_type : motion vector type
1726 s->mv : motion vector
1727 s->interlaced_dct : true if interlaced dct used (mpeg2)
1729 static av_always_inline
1730 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1731 int lowres_flag, int is_mpeg12)
1734 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1736 if(s->avctx->xvmc_acceleration){
1737 XVMC_decode_mb(s);//xvmc uses pblocks
1745 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1746 /* save DCT coefficients */
1748 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1751 *dct++ = block[i][s->dsp.idct_permutation[j]];
1754 s->current_picture.qscale_table[mb_xy]= s->qscale;
1756 /* update DC predictors for P macroblocks */
1758 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1759 if(s->mbintra_table[mb_xy])
1760 ff_clean_intra_table_entries(s);
1764 s->last_dc[2] = 128 << s->intra_dc_precision;
1767 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1768 s->mbintra_table[mb_xy]=1;
1770 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
1771 uint8_t *dest_y, *dest_cb, *dest_cr;
1772 int dct_linesize, dct_offset;
1773 op_pixels_func (*op_pix)[4];
1774 qpel_mc_func (*op_qpix)[16];
1775 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1776 const int uvlinesize= s->current_picture.linesize[1];
1777 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1778 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1780 /* avoid copy if macroblock skipped in last frame too */
1781 /* skip only during decoding as we might trash the buffers during encoding a bit */
1783 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1784 const int age= s->current_picture.age;
1788 if (s->mb_skipped) {
1790 assert(s->pict_type!=FF_I_TYPE);
1792 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1793 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1795 /* if previous was skipped too, then nothing to do ! */
1796 if (*mbskip_ptr >= age && s->current_picture.reference){
1799 } else if(!s->current_picture.reference){
1800 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1801 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1803 *mbskip_ptr = 0; /* not skipped */
1807 dct_linesize = linesize << s->interlaced_dct;
1808 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1812 dest_cb= s->dest[1];
1813 dest_cr= s->dest[2];
1815 dest_y = s->b_scratchpad;
1816 dest_cb= s->b_scratchpad+16*linesize;
1817 dest_cr= s->b_scratchpad+32*linesize;
1821 /* motion handling */
1822 /* decoding or more than one mb_type (MC was already done otherwise) */
1825 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1827 if (s->mv_dir & MV_DIR_FORWARD) {
1828 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1829 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1831 if (s->mv_dir & MV_DIR_BACKWARD) {
1832 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1835 op_qpix= s->me.qpel_put;
1836 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1837 op_pix = s->dsp.put_pixels_tab;
1839 op_pix = s->dsp.put_no_rnd_pixels_tab;
1841 if (s->mv_dir & MV_DIR_FORWARD) {
1842 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1843 op_pix = s->dsp.avg_pixels_tab;
1844 op_qpix= s->me.qpel_avg;
1846 if (s->mv_dir & MV_DIR_BACKWARD) {
1847 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1852 /* skip dequant / idct if we are really late ;) */
1853 if(s->hurry_up>1) goto skip_idct;
1854 if(s->avctx->skip_idct){
1855 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1856 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1857 || s->avctx->skip_idct >= AVDISCARD_ALL)
1861 /* add dct residue */
1862 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1863 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1864 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1865 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1866 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1867 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1869 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1870 if (s->chroma_y_shift){
1871 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1872 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1876 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1877 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1878 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1879 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1882 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1883 add_dct(s, block[0], 0, dest_y , dct_linesize);
1884 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1885 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1886 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1888 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1889 if(s->chroma_y_shift){//Chroma420
1890 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1891 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1894 dct_linesize = uvlinesize << s->interlaced_dct;
1895 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1897 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1898 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1899 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1900 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1901 if(!s->chroma_x_shift){//Chroma444
1902 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1903 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1904 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1905 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1910 else if (ENABLE_WMV2) {
1911 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1914 /* dct only in intra block */
1915 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1916 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1917 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1918 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1919 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1921 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1922 if(s->chroma_y_shift){
1923 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1924 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1928 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1929 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1930 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1931 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1935 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1936 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1937 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1938 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1940 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1941 if(s->chroma_y_shift){
1942 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1943 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1946 dct_linesize = uvlinesize << s->interlaced_dct;
1947 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1949 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1950 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1951 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1952 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1953 if(!s->chroma_x_shift){//Chroma444
1954 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1955 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1956 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1957 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1965 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1966 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1967 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1972 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1973 #ifndef CONFIG_SMALL
1974 if(s->out_format == FMT_MPEG1) {
1975 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1976 else MPV_decode_mb_internal(s, block, 0, 1);
1979 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1980 else MPV_decode_mb_internal(s, block, 0, 0);
1985 * @param h is the normal height, this will be reduced automatically if needed for the last row
1987 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1988 if (s->avctx->draw_horiz_band) {
1992 if(s->picture_structure != PICT_FRAME){
1995 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1998 h= FFMIN(h, s->avctx->height - y);
2000 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2001 src= (AVFrame*)s->current_picture_ptr;
2002 else if(s->last_picture_ptr)
2003 src= (AVFrame*)s->last_picture_ptr;
2007 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2013 offset[0]= y * s->linesize;
2015 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2021 s->avctx->draw_horiz_band(s->avctx, src, offset,
2022 y, s->picture_structure, h);
2026 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2027 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2028 const int uvlinesize= s->current_picture.linesize[1];
2029 const int mb_size= 4 - s->avctx->lowres;
2031 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2032 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2033 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2034 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2035 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2036 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;
2037 //block_index is not used by mpeg2, so it is not affected by chroma_format
2039 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2040 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2041 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2043 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2045 s->dest[0] += s->mb_y * linesize << mb_size;
2046 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2047 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2051 void ff_mpeg_flush(AVCodecContext *avctx){
2053 MpegEncContext *s = avctx->priv_data;
2055 if(s==NULL || s->picture==NULL)
2058 for(i=0; i<MAX_PICTURE_COUNT; i++){
2059 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2060 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2061 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2063 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2065 s->mb_x= s->mb_y= 0;
2067 s->parse_context.state= -1;
2068 s->parse_context.frame_start_found= 0;
2069 s->parse_context.overread= 0;
2070 s->parse_context.overread_index= 0;
2071 s->parse_context.index= 0;
2072 s->parse_context.last_index= 0;
2073 s->bitstream_buffer_size=0;
2077 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2078 DCTELEM *block, int n, int qscale)
2080 int i, level, nCoeffs;
2081 const uint16_t *quant_matrix;
2083 nCoeffs= s->block_last_index[n];
2086 block[0] = block[0] * s->y_dc_scale;
2088 block[0] = block[0] * s->c_dc_scale;
2089 /* XXX: only mpeg1 */
2090 quant_matrix = s->intra_matrix;
2091 for(i=1;i<=nCoeffs;i++) {
2092 int j= s->intra_scantable.permutated[i];
2097 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2098 level = (level - 1) | 1;
2101 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2102 level = (level - 1) | 1;
2109 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2110 DCTELEM *block, int n, int qscale)
2112 int i, level, nCoeffs;
2113 const uint16_t *quant_matrix;
2115 nCoeffs= s->block_last_index[n];
2117 quant_matrix = s->inter_matrix;
2118 for(i=0; i<=nCoeffs; i++) {
2119 int j= s->intra_scantable.permutated[i];
2124 level = (((level << 1) + 1) * qscale *
2125 ((int) (quant_matrix[j]))) >> 4;
2126 level = (level - 1) | 1;
2129 level = (((level << 1) + 1) * qscale *
2130 ((int) (quant_matrix[j]))) >> 4;
2131 level = (level - 1) | 1;
2138 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2139 DCTELEM *block, int n, int qscale)
2141 int i, level, nCoeffs;
2142 const uint16_t *quant_matrix;
2144 if(s->alternate_scan) nCoeffs= 63;
2145 else nCoeffs= s->block_last_index[n];
2148 block[0] = block[0] * s->y_dc_scale;
2150 block[0] = block[0] * s->c_dc_scale;
2151 quant_matrix = s->intra_matrix;
2152 for(i=1;i<=nCoeffs;i++) {
2153 int j= s->intra_scantable.permutated[i];
2158 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2161 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2168 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2169 DCTELEM *block, int n, int qscale)
2171 int i, level, nCoeffs;
2172 const uint16_t *quant_matrix;
2175 if(s->alternate_scan) nCoeffs= 63;
2176 else nCoeffs= s->block_last_index[n];
2179 block[0] = block[0] * s->y_dc_scale;
2181 block[0] = block[0] * s->c_dc_scale;
2182 quant_matrix = s->intra_matrix;
2183 for(i=1;i<=nCoeffs;i++) {
2184 int j= s->intra_scantable.permutated[i];
2189 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2192 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2201 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2202 DCTELEM *block, int n, int qscale)
2204 int i, level, nCoeffs;
2205 const uint16_t *quant_matrix;
2208 if(s->alternate_scan) nCoeffs= 63;
2209 else nCoeffs= s->block_last_index[n];
2211 quant_matrix = s->inter_matrix;
2212 for(i=0; i<=nCoeffs; i++) {
2213 int j= s->intra_scantable.permutated[i];
2218 level = (((level << 1) + 1) * qscale *
2219 ((int) (quant_matrix[j]))) >> 4;
2222 level = (((level << 1) + 1) * qscale *
2223 ((int) (quant_matrix[j]))) >> 4;
2232 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2233 DCTELEM *block, int n, int qscale)
2235 int i, level, qmul, qadd;
2238 assert(s->block_last_index[n]>=0);
2244 block[0] = block[0] * s->y_dc_scale;
2246 block[0] = block[0] * s->c_dc_scale;
2247 qadd = (qscale - 1) | 1;
2254 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2256 for(i=1; i<=nCoeffs; i++) {
2260 level = level * qmul - qadd;
2262 level = level * qmul + qadd;
2269 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2270 DCTELEM *block, int n, int qscale)
2272 int i, level, qmul, qadd;
2275 assert(s->block_last_index[n]>=0);
2277 qadd = (qscale - 1) | 1;
2280 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2282 for(i=0; i<=nCoeffs; i++) {
2286 level = level * qmul - qadd;
2288 level = level * qmul + qadd;
2296 * set qscale and update qscale dependent variables.
2298 void ff_set_qscale(MpegEncContext * s, int qscale)
2302 else if (qscale > 31)
2306 s->chroma_qscale= s->chroma_qscale_table[qscale];
2308 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2309 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];