2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
33 #include "mpegvideo_common.h"
42 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
43 DCTELEM *block, int n, int qscale);
44 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
57 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
58 extern void XVMC_field_end(MpegEncContext *s);
59 extern void XVMC_decode_mb(MpegEncContext *s);
62 /* enable all paranoid tests for rounding, overflows, etc... */
68 static const uint8_t ff_default_chroma_qscale_table[32]={
69 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
70 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
73 const uint8_t ff_mpeg1_dc_scale_table[128]={
74 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
90 uint32_t tmp= *state << 8;
92 if(tmp == 0x100 || p==end)
97 if (p[-1] > 1 ) p+= 3;
98 else if(p[-2] ) p+= 2;
99 else if(p[-3]|(p[-1]-1)) p++;
112 /* init common dct for both encoder and decoder */
113 int ff_dct_common_init(MpegEncContext *s)
115 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
116 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
117 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
118 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
119 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
120 if(s->flags & CODEC_FLAG_BITEXACT)
121 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
122 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
124 #if defined(HAVE_MMX)
125 MPV_common_init_mmx(s);
126 #elif defined(ARCH_ALPHA)
127 MPV_common_init_axp(s);
128 #elif defined(CONFIG_MLIB)
129 MPV_common_init_mlib(s);
130 #elif defined(HAVE_MMI)
131 MPV_common_init_mmi(s);
132 #elif defined(ARCH_ARMV4L)
133 MPV_common_init_armv4l(s);
134 #elif defined(HAVE_ALTIVEC)
135 MPV_common_init_altivec(s);
136 #elif defined(ARCH_BFIN)
137 MPV_common_init_bfin(s);
140 /* load & permutate scantables
141 note: only wmv uses different ones
143 if(s->alternate_scan){
144 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
145 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
147 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
148 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
150 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
151 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
156 void 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->pict_type;
240 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
241 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
244 fail: //for the CHECKED_ALLOCZ macro
246 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
251 * deallocates a picture
253 static void free_picture(MpegEncContext *s, Picture *pic){
256 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
257 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
260 av_freep(&pic->mb_var);
261 av_freep(&pic->mc_mb_var);
262 av_freep(&pic->mb_mean);
263 av_freep(&pic->mbskip_table);
264 av_freep(&pic->qscale_table);
265 av_freep(&pic->mb_type_base);
266 av_freep(&pic->dct_coeff);
267 av_freep(&pic->pan_scan);
270 av_freep(&pic->motion_val_base[i]);
271 av_freep(&pic->ref_index[i]);
274 if(pic->type == FF_BUFFER_TYPE_SHARED){
283 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
286 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
287 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
288 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
290 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
291 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
292 s->rd_scratchpad= s->me.scratchpad;
293 s->b_scratchpad= s->me.scratchpad;
294 s->obmc_scratchpad= s->me.scratchpad + 16;
296 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
297 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
298 if(s->avctx->noise_reduction){
299 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
302 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
303 s->block= s->blocks[0];
306 s->pblocks[i] = (short *)(&s->block[i]);
310 return -1; //free() through MPV_common_end()
313 static void free_duplicate_context(MpegEncContext *s){
316 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
317 av_freep(&s->me.scratchpad);
320 s->obmc_scratchpad= NULL;
322 av_freep(&s->dct_error_sum);
323 av_freep(&s->me.map);
324 av_freep(&s->me.score_map);
325 av_freep(&s->blocks);
329 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
330 #define COPY(a) bak->a= src->a
331 COPY(allocated_edge_emu_buffer);
332 COPY(edge_emu_buffer);
336 COPY(obmc_scratchpad);
343 COPY(me.map_generation);
351 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
354 //FIXME copy only needed parts
356 backup_duplicate_context(&bak, dst);
357 memcpy(dst, src, sizeof(MpegEncContext));
358 backup_duplicate_context(dst, &bak);
360 dst->pblocks[i] = (short *)(&dst->block[i]);
362 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
366 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
367 * the changed fields will not depend upon the prior state of the MpegEncContext.
369 void MPV_common_defaults(MpegEncContext *s){
371 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
372 s->chroma_qscale_table= ff_default_chroma_qscale_table;
373 s->progressive_frame= 1;
374 s->progressive_sequence= 1;
375 s->picture_structure= PICT_FRAME;
377 s->coded_picture_number = 0;
378 s->picture_number = 0;
379 s->input_picture_number = 0;
381 s->picture_in_gop_number = 0;
388 * sets the given MpegEncContext to defaults for decoding.
389 * the changed fields will not depend upon the prior state of the MpegEncContext.
391 void MPV_decode_defaults(MpegEncContext *s){
392 MPV_common_defaults(s);
396 * init common structure for both encoder and decoder.
397 * this assumes that some variables like width/height are already set
399 int MPV_common_init(MpegEncContext *s)
401 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
403 s->mb_height = (s->height + 15) / 16;
405 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
406 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
410 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
413 dsputil_init(&s->dsp, s->avctx);
414 ff_dct_common_init(s);
416 s->flags= s->avctx->flags;
417 s->flags2= s->avctx->flags2;
419 s->mb_width = (s->width + 15) / 16;
420 s->mb_stride = s->mb_width + 1;
421 s->b8_stride = s->mb_width*2 + 1;
422 s->b4_stride = s->mb_width*4 + 1;
423 mb_array_size= s->mb_height * s->mb_stride;
424 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
426 /* set chroma shifts */
427 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
428 &(s->chroma_y_shift) );
430 /* set default edge pos, will be overriden in decode_header if needed */
431 s->h_edge_pos= s->mb_width*16;
432 s->v_edge_pos= s->mb_height*16;
434 s->mb_num = s->mb_width * s->mb_height;
439 s->block_wrap[3]= s->b8_stride;
441 s->block_wrap[5]= s->mb_stride;
443 y_size = s->b8_stride * (2 * s->mb_height + 1);
444 c_size = s->mb_stride * (s->mb_height + 1);
445 yc_size = y_size + 2 * c_size;
447 /* convert fourcc to upper case */
448 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
449 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
450 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
451 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
453 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
454 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
455 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
456 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
458 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
460 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
461 for(y=0; y<s->mb_height; y++){
462 for(x=0; x<s->mb_width; x++){
463 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
466 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
469 /* Allocate MV tables */
470 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
471 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
472 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
473 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
474 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
477 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
478 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
479 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
480 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
481 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
483 if(s->msmpeg4_version){
484 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
486 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
488 /* Allocate MB type table */
489 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
491 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
493 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
494 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
495 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
496 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
497 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
498 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
500 if(s->avctx->noise_reduction){
501 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
504 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
506 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
508 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
509 /* interlaced direct mode decoding tables */
514 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
515 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
517 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
518 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
519 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
521 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
524 if (s->out_format == FMT_H263) {
526 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
527 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
528 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
529 s->ac_val[2] = s->ac_val[1] + c_size;
532 CHECKED_ALLOCZ(s->coded_block_base, y_size);
533 s->coded_block= s->coded_block_base + s->b8_stride + 1;
535 /* cbp, ac_pred, pred_dir */
536 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
537 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
540 if (s->h263_pred || s->h263_plus || !s->encoding) {
542 //MN: we need these for error resilience of intra-frames
543 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
544 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
545 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
546 s->dc_val[2] = s->dc_val[1] + c_size;
547 for(i=0;i<yc_size;i++)
548 s->dc_val_base[i] = 1024;
551 /* which mb is a intra block */
552 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
553 memset(s->mbintra_table, 1, mb_array_size);
555 /* init macroblock skip table */
556 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
557 //Note the +1 is for a quicker mpeg4 slice_end detection
558 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
560 s->parse_context.state= -1;
561 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
562 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
563 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
564 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
567 s->context_initialized = 1;
569 s->thread_context[0]= s;
570 threads = s->avctx->thread_count;
572 for(i=1; i<threads; i++){
573 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
574 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
577 for(i=0; i<threads; i++){
578 if(init_duplicate_context(s->thread_context[i], s) < 0)
580 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
581 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
590 /* init common structure for both encoder and decoder */
591 void MPV_common_end(MpegEncContext *s)
595 for(i=0; i<s->avctx->thread_count; i++){
596 free_duplicate_context(s->thread_context[i]);
598 for(i=1; i<s->avctx->thread_count; i++){
599 av_freep(&s->thread_context[i]);
602 av_freep(&s->parse_context.buffer);
603 s->parse_context.buffer_size=0;
605 av_freep(&s->mb_type);
606 av_freep(&s->p_mv_table_base);
607 av_freep(&s->b_forw_mv_table_base);
608 av_freep(&s->b_back_mv_table_base);
609 av_freep(&s->b_bidir_forw_mv_table_base);
610 av_freep(&s->b_bidir_back_mv_table_base);
611 av_freep(&s->b_direct_mv_table_base);
613 s->b_forw_mv_table= NULL;
614 s->b_back_mv_table= NULL;
615 s->b_bidir_forw_mv_table= NULL;
616 s->b_bidir_back_mv_table= NULL;
617 s->b_direct_mv_table= NULL;
621 av_freep(&s->b_field_mv_table_base[i][j][k]);
622 s->b_field_mv_table[i][j][k]=NULL;
624 av_freep(&s->b_field_select_table[i][j]);
625 av_freep(&s->p_field_mv_table_base[i][j]);
626 s->p_field_mv_table[i][j]=NULL;
628 av_freep(&s->p_field_select_table[i]);
631 av_freep(&s->dc_val_base);
632 av_freep(&s->ac_val_base);
633 av_freep(&s->coded_block_base);
634 av_freep(&s->mbintra_table);
635 av_freep(&s->cbp_table);
636 av_freep(&s->pred_dir_table);
638 av_freep(&s->mbskip_table);
639 av_freep(&s->prev_pict_types);
640 av_freep(&s->bitstream_buffer);
641 s->allocated_bitstream_buffer_size=0;
643 av_freep(&s->avctx->stats_out);
644 av_freep(&s->ac_stats);
645 av_freep(&s->error_status_table);
646 av_freep(&s->mb_index2xy);
647 av_freep(&s->lambda_table);
648 av_freep(&s->q_intra_matrix);
649 av_freep(&s->q_inter_matrix);
650 av_freep(&s->q_intra_matrix16);
651 av_freep(&s->q_inter_matrix16);
652 av_freep(&s->input_picture);
653 av_freep(&s->reordered_input_picture);
654 av_freep(&s->dct_offset);
657 for(i=0; i<MAX_PICTURE_COUNT; i++){
658 free_picture(s, &s->picture[i]);
661 av_freep(&s->picture);
662 s->context_initialized = 0;
665 s->current_picture_ptr= NULL;
666 s->linesize= s->uvlinesize= 0;
669 av_freep(&s->visualization_buffer[i]);
671 avcodec_default_free_buffers(s->avctx);
674 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
676 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
677 uint8_t index_run[MAX_RUN+1];
678 int last, run, level, start, end, i;
680 /* If table is static, we can quit if rl->max_level[0] is not NULL */
681 if(static_store && rl->max_level[0])
684 /* compute max_level[], max_run[] and index_run[] */
685 for(last=0;last<2;last++) {
694 memset(max_level, 0, MAX_RUN + 1);
695 memset(max_run, 0, MAX_LEVEL + 1);
696 memset(index_run, rl->n, MAX_RUN + 1);
697 for(i=start;i<end;i++) {
698 run = rl->table_run[i];
699 level = rl->table_level[i];
700 if (index_run[run] == rl->n)
702 if (level > max_level[run])
703 max_level[run] = level;
704 if (run > max_run[level])
705 max_run[level] = run;
708 rl->max_level[last] = static_store[last];
710 rl->max_level[last] = av_malloc(MAX_RUN + 1);
711 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
713 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
715 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
716 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
718 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
720 rl->index_run[last] = av_malloc(MAX_RUN + 1);
721 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
725 void init_vlc_rl(RLTable *rl, int use_static)
729 /* Return if static table is already initialized */
730 if(use_static && rl->rl_vlc[0])
733 init_vlc(&rl->vlc, 9, rl->n + 1,
734 &rl->table_vlc[0][1], 4, 2,
735 &rl->table_vlc[0][0], 4, 2, use_static);
747 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
749 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
750 for(i=0; i<rl->vlc.table_size; i++){
751 int code= rl->vlc.table[i][0];
752 int len = rl->vlc.table[i][1];
755 if(len==0){ // illegal code
758 }else if(len<0){ //more bits needed
762 if(code==rl->n){ //esc
766 run= rl->table_run [code] + 1;
767 level= rl->table_level[code] * qmul + qadd;
768 if(code >= rl->last) run+=192;
771 rl->rl_vlc[q][i].len= len;
772 rl->rl_vlc[q][i].level= level;
773 rl->rl_vlc[q][i].run= run;
778 int ff_find_unused_picture(MpegEncContext *s, int shared){
782 for(i=0; i<MAX_PICTURE_COUNT; i++){
783 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
786 for(i=0; i<MAX_PICTURE_COUNT; i++){
787 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
789 for(i=0; i<MAX_PICTURE_COUNT; i++){
790 if(s->picture[i].data[0]==NULL) return i;
794 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
795 /* We could return -1, but the codec would crash trying to draw into a
796 * non-existing frame anyway. This is safer than waiting for a random crash.
797 * Also the return of this is never useful, an encoder must only allocate
798 * as much as allowed in the specification. This has no relationship to how
799 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
800 * enough for such valid streams).
801 * Plus, a decoder has to check stream validity and remove frames if too
802 * many reference frames are around. Waiting for "OOM" is not correct at
803 * all. Similarly, missing reference frames have to be replaced by
804 * interpolated/MC frames, anything else is a bug in the codec ...
810 static void update_noise_reduction(MpegEncContext *s){
813 for(intra=0; intra<2; intra++){
814 if(s->dct_count[intra] > (1<<16)){
816 s->dct_error_sum[intra][i] >>=1;
818 s->dct_count[intra] >>= 1;
822 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);
828 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
830 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
836 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
838 /* mark&release old frames */
839 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]) {
840 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
841 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
843 /* release forgotten pictures */
844 /* if(mpeg124/h263) */
846 for(i=0; i<MAX_PICTURE_COUNT; i++){
847 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
848 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
849 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
857 /* release non reference frames */
858 for(i=0; i<MAX_PICTURE_COUNT; i++){
859 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
860 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
864 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
865 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
867 i= ff_find_unused_picture(s, 0);
868 pic= (AVFrame*)&s->picture[i];
873 if (s->codec_id == CODEC_ID_H264)
874 pic->reference = s->picture_structure;
875 else if (s->pict_type != FF_B_TYPE)
879 pic->coded_picture_number= s->coded_picture_number++;
881 if( alloc_picture(s, (Picture*)pic, 0) < 0)
884 s->current_picture_ptr= (Picture*)pic;
885 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
886 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
889 s->current_picture_ptr->pict_type= s->pict_type;
890 // if(s->flags && CODEC_FLAG_QSCALE)
891 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
892 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
894 copy_picture(&s->current_picture, s->current_picture_ptr);
896 if (s->pict_type != FF_B_TYPE) {
897 s->last_picture_ptr= s->next_picture_ptr;
899 s->next_picture_ptr= s->current_picture_ptr;
901 /* 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,
902 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
903 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
904 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
905 s->pict_type, s->dropable);*/
907 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
908 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
910 if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
911 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
912 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
916 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
918 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
921 if(s->picture_structure == PICT_BOTTOM_FIELD){
922 s->current_picture.data[i] += s->current_picture.linesize[i];
924 s->current_picture.linesize[i] *= 2;
925 s->last_picture.linesize[i] *=2;
926 s->next_picture.linesize[i] *=2;
930 s->hurry_up= s->avctx->hurry_up;
931 s->error_resilience= avctx->error_resilience;
933 /* set dequantizer, we can't do it during init as it might change for mpeg4
934 and we can't do it in the header decode as init is not called for mpeg4 there yet */
935 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
936 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
937 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
938 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
939 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
940 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
942 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
943 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
946 if(s->dct_error_sum){
947 assert(s->avctx->noise_reduction && s->encoding);
949 update_noise_reduction(s);
953 if(s->avctx->xvmc_acceleration)
954 return XVMC_field_start(s, avctx);
959 /* generic function for encode/decode called after a frame has been coded/decoded */
960 void MPV_frame_end(MpegEncContext *s)
963 /* draw edge for correct motion prediction if outside */
965 //just to make sure that all data is rendered.
966 if(s->avctx->xvmc_acceleration){
970 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
971 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
972 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
973 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
977 s->last_pict_type = s->pict_type;
978 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
979 if(s->pict_type!=FF_B_TYPE){
980 s->last_non_b_pict_type= s->pict_type;
983 /* copy back current_picture variables */
984 for(i=0; i<MAX_PICTURE_COUNT; i++){
985 if(s->picture[i].data[0] == s->current_picture.data[0]){
986 s->picture[i]= s->current_picture;
990 assert(i<MAX_PICTURE_COUNT);
994 /* release non-reference frames */
995 for(i=0; i<MAX_PICTURE_COUNT; i++){
996 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
997 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1001 // clear copies, to avoid confusion
1003 memset(&s->last_picture, 0, sizeof(Picture));
1004 memset(&s->next_picture, 0, sizeof(Picture));
1005 memset(&s->current_picture, 0, sizeof(Picture));
1007 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1011 * draws an line from (ex, ey) -> (sx, sy).
1012 * @param w width of the image
1013 * @param h height of the image
1014 * @param stride stride/linesize of the image
1015 * @param color color of the arrow
1017 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1020 sx= av_clip(sx, 0, w-1);
1021 sy= av_clip(sy, 0, h-1);
1022 ex= av_clip(ex, 0, w-1);
1023 ey= av_clip(ey, 0, h-1);
1025 buf[sy*stride + sx]+= color;
1027 if(FFABS(ex - sx) > FFABS(ey - sy)){
1029 FFSWAP(int, sx, ex);
1030 FFSWAP(int, sy, ey);
1032 buf+= sx + sy*stride;
1034 f= ((ey-sy)<<16)/ex;
1035 for(x= 0; x <= ex; x++){
1038 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1039 buf[(y+1)*stride + x]+= (color* fr )>>16;
1043 FFSWAP(int, sx, ex);
1044 FFSWAP(int, sy, ey);
1046 buf+= sx + sy*stride;
1048 if(ey) f= ((ex-sx)<<16)/ey;
1050 for(y= 0; y <= ey; y++){
1053 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1054 buf[y*stride + x+1]+= (color* fr )>>16;
1060 * draws an arrow from (ex, ey) -> (sx, sy).
1061 * @param w width of the image
1062 * @param h height of the image
1063 * @param stride stride/linesize of the image
1064 * @param color color of the arrow
1066 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1069 sx= av_clip(sx, -100, w+100);
1070 sy= av_clip(sy, -100, h+100);
1071 ex= av_clip(ex, -100, w+100);
1072 ey= av_clip(ey, -100, h+100);
1077 if(dx*dx + dy*dy > 3*3){
1080 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1082 //FIXME subpixel accuracy
1083 rx= ROUNDED_DIV(rx*3<<4, length);
1084 ry= ROUNDED_DIV(ry*3<<4, length);
1086 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1087 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1089 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1093 * prints debuging info for the given picture.
1095 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1097 if(!pict || !pict->mb_type) return;
1099 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1102 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1103 switch (pict->pict_type) {
1104 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1105 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1106 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1107 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1108 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1109 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1111 for(y=0; y<s->mb_height; y++){
1112 for(x=0; x<s->mb_width; x++){
1113 if(s->avctx->debug&FF_DEBUG_SKIP){
1114 int count= s->mbskip_table[x + y*s->mb_stride];
1115 if(count>9) count=9;
1116 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1118 if(s->avctx->debug&FF_DEBUG_QP){
1119 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1121 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1122 int mb_type= pict->mb_type[x + y*s->mb_stride];
1123 //Type & MV direction
1125 av_log(s->avctx, AV_LOG_DEBUG, "P");
1126 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1127 av_log(s->avctx, AV_LOG_DEBUG, "A");
1128 else if(IS_INTRA4x4(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "i");
1130 else if(IS_INTRA16x16(mb_type))
1131 av_log(s->avctx, AV_LOG_DEBUG, "I");
1132 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1133 av_log(s->avctx, AV_LOG_DEBUG, "d");
1134 else if(IS_DIRECT(mb_type))
1135 av_log(s->avctx, AV_LOG_DEBUG, "D");
1136 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1137 av_log(s->avctx, AV_LOG_DEBUG, "g");
1138 else if(IS_GMC(mb_type))
1139 av_log(s->avctx, AV_LOG_DEBUG, "G");
1140 else if(IS_SKIP(mb_type))
1141 av_log(s->avctx, AV_LOG_DEBUG, "S");
1142 else if(!USES_LIST(mb_type, 1))
1143 av_log(s->avctx, AV_LOG_DEBUG, ">");
1144 else if(!USES_LIST(mb_type, 0))
1145 av_log(s->avctx, AV_LOG_DEBUG, "<");
1147 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1148 av_log(s->avctx, AV_LOG_DEBUG, "X");
1153 av_log(s->avctx, AV_LOG_DEBUG, "+");
1154 else if(IS_16X8(mb_type))
1155 av_log(s->avctx, AV_LOG_DEBUG, "-");
1156 else if(IS_8X16(mb_type))
1157 av_log(s->avctx, AV_LOG_DEBUG, "|");
1158 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1159 av_log(s->avctx, AV_LOG_DEBUG, " ");
1161 av_log(s->avctx, AV_LOG_DEBUG, "?");
1164 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1165 av_log(s->avctx, AV_LOG_DEBUG, "=");
1167 av_log(s->avctx, AV_LOG_DEBUG, " ");
1169 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1171 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1175 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1176 const int shift= 1 + s->quarter_sample;
1180 int h_chroma_shift, v_chroma_shift;
1181 const int width = s->avctx->width;
1182 const int height= s->avctx->height;
1183 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1184 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1185 s->low_delay=0; //needed to see the vectors without trashing the buffers
1187 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1189 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1190 pict->data[i]= s->visualization_buffer[i];
1192 pict->type= FF_BUFFER_TYPE_COPY;
1195 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1197 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1198 const int mb_index= mb_x + mb_y*s->mb_stride;
1199 if((s->avctx->debug_mv) && pict->motion_val){
1201 for(type=0; type<3; type++){
1204 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1208 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1212 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1217 if(!USES_LIST(pict->mb_type[mb_index], direction))
1220 if(IS_8X8(pict->mb_type[mb_index])){
1223 int sx= mb_x*16 + 4 + 8*(i&1);
1224 int sy= mb_y*16 + 4 + 8*(i>>1);
1225 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1226 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1227 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1228 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1230 }else if(IS_16X8(pict->mb_type[mb_index])){
1234 int sy=mb_y*16 + 4 + 8*i;
1235 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1236 int mx=(pict->motion_val[direction][xy][0]>>shift);
1237 int my=(pict->motion_val[direction][xy][1]>>shift);
1239 if(IS_INTERLACED(pict->mb_type[mb_index]))
1242 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1244 }else if(IS_8X16(pict->mb_type[mb_index])){
1247 int sx=mb_x*16 + 4 + 8*i;
1249 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1250 int mx=(pict->motion_val[direction][xy][0]>>shift);
1251 int my=(pict->motion_val[direction][xy][1]>>shift);
1253 if(IS_INTERLACED(pict->mb_type[mb_index]))
1256 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1259 int sx= mb_x*16 + 8;
1260 int sy= mb_y*16 + 8;
1261 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1262 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1263 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1264 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1268 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1269 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1272 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1273 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1276 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1277 int mb_type= pict->mb_type[mb_index];
1280 #define COLOR(theta, r)\
1281 u= (int)(128 + r*cos(theta*3.141592/180));\
1282 v= (int)(128 + r*sin(theta*3.141592/180));
1286 if(IS_PCM(mb_type)){
1288 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1290 }else if(IS_INTRA4x4(mb_type)){
1292 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1294 }else if(IS_DIRECT(mb_type)){
1296 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1298 }else if(IS_GMC(mb_type)){
1300 }else if(IS_SKIP(mb_type)){
1302 }else if(!USES_LIST(mb_type, 1)){
1304 }else if(!USES_LIST(mb_type, 0)){
1307 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1311 u*= 0x0101010101010101ULL;
1312 v*= 0x0101010101010101ULL;
1314 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1315 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1319 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1320 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1321 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1323 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1325 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1327 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1328 int dm= 1 << (mv_sample_log2-2);
1330 int sx= mb_x*16 + 8*(i&1);
1331 int sy= mb_y*16 + 8*(i>>1);
1332 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1334 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1335 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1337 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1338 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1339 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1343 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1347 s->mbskip_table[mb_index]=0;
1353 static inline int hpel_motion_lowres(MpegEncContext *s,
1354 uint8_t *dest, uint8_t *src,
1355 int field_based, int field_select,
1356 int src_x, int src_y,
1357 int width, int height, int stride,
1358 int h_edge_pos, int v_edge_pos,
1359 int w, int h, h264_chroma_mc_func *pix_op,
1360 int motion_x, int motion_y)
1362 const int lowres= s->avctx->lowres;
1363 const int s_mask= (2<<lowres)-1;
1367 if(s->quarter_sample){
1372 sx= motion_x & s_mask;
1373 sy= motion_y & s_mask;
1374 src_x += motion_x >> (lowres+1);
1375 src_y += motion_y >> (lowres+1);
1377 src += src_y * stride + src_x;
1379 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1380 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1381 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1382 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1383 src= s->edge_emu_buffer;
1391 pix_op[lowres](dest, src, stride, h, sx, sy);
1395 /* apply one mpeg motion vector to the three components */
1396 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1397 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1398 int field_based, int bottom_field, int field_select,
1399 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1400 int motion_x, int motion_y, int h)
1402 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1403 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1404 const int lowres= s->avctx->lowres;
1405 const int block_s= 8>>lowres;
1406 const int s_mask= (2<<lowres)-1;
1407 const int h_edge_pos = s->h_edge_pos >> lowres;
1408 const int v_edge_pos = s->v_edge_pos >> lowres;
1409 linesize = s->current_picture.linesize[0] << field_based;
1410 uvlinesize = s->current_picture.linesize[1] << field_based;
1412 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1418 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1421 sx= motion_x & s_mask;
1422 sy= motion_y & s_mask;
1423 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1424 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1426 if (s->out_format == FMT_H263) {
1427 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1428 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1431 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1434 uvsx = (2*mx) & s_mask;
1435 uvsy = (2*my) & s_mask;
1436 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1437 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1443 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1444 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1447 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1448 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1449 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1451 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1452 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1453 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1454 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1455 ptr_y = s->edge_emu_buffer;
1456 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1457 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1458 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1459 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1460 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1461 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1467 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1468 dest_y += s->linesize;
1469 dest_cb+= s->uvlinesize;
1470 dest_cr+= s->uvlinesize;
1474 ptr_y += s->linesize;
1475 ptr_cb+= s->uvlinesize;
1476 ptr_cr+= s->uvlinesize;
1481 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1483 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1484 uvsx <<= 2 - lowres;
1485 uvsy <<= 2 - lowres;
1486 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1487 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1489 //FIXME h261 lowres loop filter
1492 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1493 uint8_t *dest_cb, uint8_t *dest_cr,
1494 uint8_t **ref_picture,
1495 h264_chroma_mc_func *pix_op,
1497 const int lowres= s->avctx->lowres;
1498 const int block_s= 8>>lowres;
1499 const int s_mask= (2<<lowres)-1;
1500 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1501 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1502 int emu=0, src_x, src_y, offset, sx, sy;
1505 if(s->quarter_sample){
1510 /* In case of 8X8, we construct a single chroma motion vector
1511 with a special rounding */
1512 mx= ff_h263_round_chroma(mx);
1513 my= ff_h263_round_chroma(my);
1517 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1518 src_y = s->mb_y*block_s + (my >> (lowres+1));
1520 offset = src_y * s->uvlinesize + src_x;
1521 ptr = ref_picture[1] + offset;
1522 if(s->flags&CODEC_FLAG_EMU_EDGE){
1523 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1524 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1525 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1526 ptr= s->edge_emu_buffer;
1532 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1534 ptr = ref_picture[2] + offset;
1536 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1537 ptr= s->edge_emu_buffer;
1539 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1543 * motion compensation of a single macroblock
1545 * @param dest_y luma destination pointer
1546 * @param dest_cb chroma cb/u destination pointer
1547 * @param dest_cr chroma cr/v destination pointer
1548 * @param dir direction (0->forward, 1->backward)
1549 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1550 * @param pic_op halfpel motion compensation function (average or put normally)
1551 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1553 static inline void MPV_motion_lowres(MpegEncContext *s,
1554 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1555 int dir, uint8_t **ref_picture,
1556 h264_chroma_mc_func *pix_op)
1560 const int lowres= s->avctx->lowres;
1561 const int block_s= 8>>lowres;
1566 switch(s->mv_type) {
1568 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1570 ref_picture, pix_op,
1571 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1577 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1578 ref_picture[0], 0, 0,
1579 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1580 s->width, s->height, s->linesize,
1581 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1582 block_s, block_s, pix_op,
1583 s->mv[dir][i][0], s->mv[dir][i][1]);
1585 mx += s->mv[dir][i][0];
1586 my += s->mv[dir][i][1];
1589 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1590 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1593 if (s->picture_structure == PICT_FRAME) {
1595 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1596 1, 0, s->field_select[dir][0],
1597 ref_picture, pix_op,
1598 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1600 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1601 1, 1, s->field_select[dir][1],
1602 ref_picture, pix_op,
1603 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1605 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1606 ref_picture= s->current_picture_ptr->data;
1609 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1610 0, 0, s->field_select[dir][0],
1611 ref_picture, pix_op,
1612 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1617 uint8_t ** ref2picture;
1619 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1620 ref2picture= ref_picture;
1622 ref2picture= s->current_picture_ptr->data;
1625 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1626 0, 0, s->field_select[dir][i],
1627 ref2picture, pix_op,
1628 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1630 dest_y += 2*block_s*s->linesize;
1631 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1632 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1636 if(s->picture_structure == PICT_FRAME){
1640 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1642 ref_picture, pix_op,
1643 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1645 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1649 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1650 0, 0, s->picture_structure != i+1,
1651 ref_picture, pix_op,
1652 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1654 // after put we make avg of the same block
1655 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1657 //opposite parity is always in the same frame if this is second field
1658 if(!s->first_field){
1659 ref_picture = s->current_picture_ptr->data;
1668 /* put block[] to dest[] */
1669 static inline void put_dct(MpegEncContext *s,
1670 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1672 s->dct_unquantize_intra(s, block, i, qscale);
1673 s->dsp.idct_put (dest, line_size, block);
1676 /* add block[] to dest[] */
1677 static inline void add_dct(MpegEncContext *s,
1678 DCTELEM *block, int i, uint8_t *dest, int line_size)
1680 if (s->block_last_index[i] >= 0) {
1681 s->dsp.idct_add (dest, line_size, block);
1685 static inline void add_dequant_dct(MpegEncContext *s,
1686 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1688 if (s->block_last_index[i] >= 0) {
1689 s->dct_unquantize_inter(s, block, i, qscale);
1691 s->dsp.idct_add (dest, line_size, block);
1696 * cleans dc, ac, coded_block for the current non intra MB
1698 void ff_clean_intra_table_entries(MpegEncContext *s)
1700 int wrap = s->b8_stride;
1701 int xy = s->block_index[0];
1704 s->dc_val[0][xy + 1 ] =
1705 s->dc_val[0][xy + wrap] =
1706 s->dc_val[0][xy + 1 + wrap] = 1024;
1708 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1709 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1710 if (s->msmpeg4_version>=3) {
1711 s->coded_block[xy ] =
1712 s->coded_block[xy + 1 ] =
1713 s->coded_block[xy + wrap] =
1714 s->coded_block[xy + 1 + wrap] = 0;
1717 wrap = s->mb_stride;
1718 xy = s->mb_x + s->mb_y * wrap;
1720 s->dc_val[2][xy] = 1024;
1722 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1723 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1725 s->mbintra_table[xy]= 0;
1728 /* generic function called after a macroblock has been parsed by the
1729 decoder or after it has been encoded by the encoder.
1731 Important variables used:
1732 s->mb_intra : true if intra macroblock
1733 s->mv_dir : motion vector direction
1734 s->mv_type : motion vector type
1735 s->mv : motion vector
1736 s->interlaced_dct : true if interlaced dct used (mpeg2)
1738 static av_always_inline
1739 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1743 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1745 if(s->avctx->xvmc_acceleration){
1746 XVMC_decode_mb(s);//xvmc uses pblocks
1754 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1755 /* save DCT coefficients */
1757 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1760 *dct++ = block[i][s->dsp.idct_permutation[j]];
1763 s->current_picture.qscale_table[mb_xy]= s->qscale;
1765 /* update DC predictors for P macroblocks */
1767 if (s->h263_pred || s->h263_aic) {
1768 if(s->mbintra_table[mb_xy])
1769 ff_clean_intra_table_entries(s);
1773 s->last_dc[2] = 128 << s->intra_dc_precision;
1776 else if (s->h263_pred || s->h263_aic)
1777 s->mbintra_table[mb_xy]=1;
1779 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
1780 uint8_t *dest_y, *dest_cb, *dest_cr;
1781 int dct_linesize, dct_offset;
1782 op_pixels_func (*op_pix)[4];
1783 qpel_mc_func (*op_qpix)[16];
1784 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1785 const int uvlinesize= s->current_picture.linesize[1];
1786 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1787 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1789 /* avoid copy if macroblock skipped in last frame too */
1790 /* skip only during decoding as we might trash the buffers during encoding a bit */
1792 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1793 const int age= s->current_picture.age;
1797 if (s->mb_skipped) {
1799 assert(s->pict_type!=FF_I_TYPE);
1801 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1802 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1804 /* if previous was skipped too, then nothing to do ! */
1805 if (*mbskip_ptr >= age && s->current_picture.reference){
1808 } else if(!s->current_picture.reference){
1809 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1810 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1812 *mbskip_ptr = 0; /* not skipped */
1816 dct_linesize = linesize << s->interlaced_dct;
1817 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1821 dest_cb= s->dest[1];
1822 dest_cr= s->dest[2];
1824 dest_y = s->b_scratchpad;
1825 dest_cb= s->b_scratchpad+16*linesize;
1826 dest_cr= s->b_scratchpad+32*linesize;
1830 /* motion handling */
1831 /* decoding or more than one mb_type (MC was already done otherwise) */
1834 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1836 if (s->mv_dir & MV_DIR_FORWARD) {
1837 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1838 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1840 if (s->mv_dir & MV_DIR_BACKWARD) {
1841 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1844 op_qpix= s->me.qpel_put;
1845 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1846 op_pix = s->dsp.put_pixels_tab;
1848 op_pix = s->dsp.put_no_rnd_pixels_tab;
1850 if (s->mv_dir & MV_DIR_FORWARD) {
1851 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1852 op_pix = s->dsp.avg_pixels_tab;
1853 op_qpix= s->me.qpel_avg;
1855 if (s->mv_dir & MV_DIR_BACKWARD) {
1856 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1861 /* skip dequant / idct if we are really late ;) */
1862 if(s->hurry_up>1) goto skip_idct;
1863 if(s->avctx->skip_idct){
1864 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1865 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1866 || s->avctx->skip_idct >= AVDISCARD_ALL)
1870 /* add dct residue */
1871 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1872 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1873 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1874 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1875 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1876 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1878 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1879 if (s->chroma_y_shift){
1880 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1881 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1885 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1886 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1887 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1888 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1891 } else if(s->codec_id != CODEC_ID_WMV2){
1892 add_dct(s, block[0], 0, dest_y , dct_linesize);
1893 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1894 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1895 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1897 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1898 if(s->chroma_y_shift){//Chroma420
1899 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1900 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1903 dct_linesize = uvlinesize << s->interlaced_dct;
1904 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1906 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1907 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1908 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1909 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1910 if(!s->chroma_x_shift){//Chroma444
1911 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1912 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1913 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1914 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1919 else if (ENABLE_WMV2) {
1920 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1923 /* dct only in intra block */
1924 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1925 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1926 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1927 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1928 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1930 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1931 if(s->chroma_y_shift){
1932 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1933 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1937 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1938 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1939 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1940 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1944 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1945 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1946 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1947 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1949 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1950 if(s->chroma_y_shift){
1951 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1952 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1955 dct_linesize = uvlinesize << s->interlaced_dct;
1956 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1958 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1959 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1960 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1961 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1962 if(!s->chroma_x_shift){//Chroma444
1963 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1964 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1965 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1966 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1974 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1975 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1976 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1981 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1982 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
1983 else MPV_decode_mb_internal(s, block, 0);
1988 * @param h is the normal height, this will be reduced automatically if needed for the last row
1990 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1991 if (s->avctx->draw_horiz_band) {
1995 if(s->picture_structure != PICT_FRAME){
1998 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2001 h= FFMIN(h, s->avctx->height - y);
2003 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2004 src= (AVFrame*)s->current_picture_ptr;
2005 else if(s->last_picture_ptr)
2006 src= (AVFrame*)s->last_picture_ptr;
2010 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2016 offset[0]= y * s->linesize;
2018 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2024 s->avctx->draw_horiz_band(s->avctx, src, offset,
2025 y, s->picture_structure, h);
2029 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2030 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2031 const int uvlinesize= s->current_picture.linesize[1];
2032 const int mb_size= 4 - s->avctx->lowres;
2034 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2035 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2036 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2037 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2038 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2039 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;
2040 //block_index is not used by mpeg2, so it is not affected by chroma_format
2042 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2043 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2044 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2046 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2048 s->dest[0] += s->mb_y * linesize << mb_size;
2049 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2050 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2054 void ff_mpeg_flush(AVCodecContext *avctx){
2056 MpegEncContext *s = avctx->priv_data;
2058 if(s==NULL || s->picture==NULL)
2061 for(i=0; i<MAX_PICTURE_COUNT; i++){
2062 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2063 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2064 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2066 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2068 s->mb_x= s->mb_y= 0;
2070 s->parse_context.state= -1;
2071 s->parse_context.frame_start_found= 0;
2072 s->parse_context.overread= 0;
2073 s->parse_context.overread_index= 0;
2074 s->parse_context.index= 0;
2075 s->parse_context.last_index= 0;
2076 s->bitstream_buffer_size=0;
2080 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2081 DCTELEM *block, int n, int qscale)
2083 int i, level, nCoeffs;
2084 const uint16_t *quant_matrix;
2086 nCoeffs= s->block_last_index[n];
2089 block[0] = block[0] * s->y_dc_scale;
2091 block[0] = block[0] * s->c_dc_scale;
2092 /* XXX: only mpeg1 */
2093 quant_matrix = s->intra_matrix;
2094 for(i=1;i<=nCoeffs;i++) {
2095 int j= s->intra_scantable.permutated[i];
2100 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2101 level = (level - 1) | 1;
2104 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2105 level = (level - 1) | 1;
2112 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2113 DCTELEM *block, int n, int qscale)
2115 int i, level, nCoeffs;
2116 const uint16_t *quant_matrix;
2118 nCoeffs= s->block_last_index[n];
2120 quant_matrix = s->inter_matrix;
2121 for(i=0; i<=nCoeffs; i++) {
2122 int j= s->intra_scantable.permutated[i];
2127 level = (((level << 1) + 1) * qscale *
2128 ((int) (quant_matrix[j]))) >> 4;
2129 level = (level - 1) | 1;
2132 level = (((level << 1) + 1) * qscale *
2133 ((int) (quant_matrix[j]))) >> 4;
2134 level = (level - 1) | 1;
2141 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2142 DCTELEM *block, int n, int qscale)
2144 int i, level, nCoeffs;
2145 const uint16_t *quant_matrix;
2147 if(s->alternate_scan) nCoeffs= 63;
2148 else nCoeffs= s->block_last_index[n];
2151 block[0] = block[0] * s->y_dc_scale;
2153 block[0] = block[0] * s->c_dc_scale;
2154 quant_matrix = s->intra_matrix;
2155 for(i=1;i<=nCoeffs;i++) {
2156 int j= s->intra_scantable.permutated[i];
2161 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2164 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2171 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2172 DCTELEM *block, int n, int qscale)
2174 int i, level, nCoeffs;
2175 const uint16_t *quant_matrix;
2178 if(s->alternate_scan) nCoeffs= 63;
2179 else nCoeffs= s->block_last_index[n];
2182 block[0] = block[0] * s->y_dc_scale;
2184 block[0] = block[0] * s->c_dc_scale;
2185 quant_matrix = s->intra_matrix;
2186 for(i=1;i<=nCoeffs;i++) {
2187 int j= s->intra_scantable.permutated[i];
2192 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2195 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2204 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2205 DCTELEM *block, int n, int qscale)
2207 int i, level, nCoeffs;
2208 const uint16_t *quant_matrix;
2211 if(s->alternate_scan) nCoeffs= 63;
2212 else nCoeffs= s->block_last_index[n];
2214 quant_matrix = s->inter_matrix;
2215 for(i=0; i<=nCoeffs; i++) {
2216 int j= s->intra_scantable.permutated[i];
2221 level = (((level << 1) + 1) * qscale *
2222 ((int) (quant_matrix[j]))) >> 4;
2225 level = (((level << 1) + 1) * qscale *
2226 ((int) (quant_matrix[j]))) >> 4;
2235 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2236 DCTELEM *block, int n, int qscale)
2238 int i, level, qmul, qadd;
2241 assert(s->block_last_index[n]>=0);
2247 block[0] = block[0] * s->y_dc_scale;
2249 block[0] = block[0] * s->c_dc_scale;
2250 qadd = (qscale - 1) | 1;
2257 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2259 for(i=1; i<=nCoeffs; i++) {
2263 level = level * qmul - qadd;
2265 level = level * qmul + qadd;
2272 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2273 DCTELEM *block, int n, int qscale)
2275 int i, level, qmul, qadd;
2278 assert(s->block_last_index[n]>=0);
2280 qadd = (qscale - 1) | 1;
2283 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2285 for(i=0; i<=nCoeffs; i++) {
2289 level = level * qmul - qadd;
2291 level = level * qmul + qadd;
2299 * set qscale and update qscale dependent variables.
2301 void ff_set_qscale(MpegEncContext * s, int qscale)
2305 else if (qscale > 31)
2309 s->chroma_qscale= s->chroma_qscale_table[qscale];
2311 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2312 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];