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);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
58 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
59 extern void XVMC_field_end(MpegEncContext *s);
60 extern void XVMC_decode_mb(MpegEncContext *s);
62 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
65 /* enable all paranoid tests for rounding, overflows, etc... */
71 static const uint8_t ff_default_chroma_qscale_table[32]={
72 // 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 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
76 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
80 st->scantable= src_scantable;
85 st->permutated[i] = permutation[j];
94 j = st->permutated[i];
96 st->raster_end[i]= end;
100 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
108 uint32_t tmp= *state << 8;
109 *state= tmp + *(p++);
110 if(tmp == 0x100 || p==end)
115 if (p[-1] > 1 ) p+= 3;
116 else if(p[-2] ) p+= 2;
117 else if(p[-3]|(p[-1]-1)) p++;
130 /* init common dct for both encoder and decoder */
131 int ff_dct_common_init(MpegEncContext *s)
133 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
134 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
135 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
136 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
137 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
138 if(s->flags & CODEC_FLAG_BITEXACT)
139 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
140 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
142 #if defined(HAVE_MMX)
143 MPV_common_init_mmx(s);
144 #elif defined(ARCH_ALPHA)
145 MPV_common_init_axp(s);
146 #elif defined(HAVE_MLIB)
147 MPV_common_init_mlib(s);
148 #elif defined(HAVE_MMI)
149 MPV_common_init_mmi(s);
150 #elif defined(ARCH_ARMV4L)
151 MPV_common_init_armv4l(s);
152 #elif defined(HAVE_ALTIVEC)
153 MPV_common_init_altivec(s);
154 #elif defined(ARCH_BFIN)
155 MPV_common_init_bfin(s);
158 /* load & permutate scantables
159 note: only wmv uses different ones
161 if(s->alternate_scan){
162 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
163 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
165 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
166 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
168 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
169 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
174 void copy_picture(Picture *dst, Picture *src){
176 dst->type= FF_BUFFER_TYPE_COPY;
180 * allocates a Picture
181 * The pixels are allocated/set by calling get_buffer() if shared=0
183 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
184 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
185 const int mb_array_size= s->mb_stride*s->mb_height;
186 const int b8_array_size= s->b8_stride*s->mb_height*2;
187 const int b4_array_size= s->b4_stride*s->mb_height*4;
192 assert(pic->data[0]);
193 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
194 pic->type= FF_BUFFER_TYPE_SHARED;
196 assert(!pic->data[0]);
198 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
200 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
201 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
205 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
206 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
207 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
211 if(pic->linesize[1] != pic->linesize[2]){
212 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
213 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
217 s->linesize = pic->linesize[0];
218 s->uvlinesize= pic->linesize[1];
221 if(pic->qscale_table==NULL){
223 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
224 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
225 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
228 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
229 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
230 CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
231 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
232 if(s->out_format == FMT_H264){
234 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
235 pic->motion_val[i]= pic->motion_val_base[i]+4;
236 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
238 pic->motion_subsample_log2= 2;
239 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
241 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
242 pic->motion_val[i]= pic->motion_val_base[i]+4;
243 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
245 pic->motion_subsample_log2= 3;
247 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
248 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
250 pic->qstride= s->mb_stride;
251 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
254 /* It might be nicer if the application would keep track of these
255 * but it would require an API change. */
256 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
257 s->prev_pict_types[0]= s->pict_type;
258 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
259 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.
262 fail: //for the CHECKED_ALLOCZ macro
264 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
269 * deallocates a picture
271 static void free_picture(MpegEncContext *s, Picture *pic){
274 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
275 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
278 av_freep(&pic->mb_var);
279 av_freep(&pic->mc_mb_var);
280 av_freep(&pic->mb_mean);
281 av_freep(&pic->mbskip_table);
282 av_freep(&pic->qscale_table);
283 av_freep(&pic->mb_type_base);
284 av_freep(&pic->dct_coeff);
285 av_freep(&pic->pan_scan);
288 av_freep(&pic->motion_val_base[i]);
289 av_freep(&pic->ref_index[i]);
292 if(pic->type == FF_BUFFER_TYPE_SHARED){
301 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
304 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
305 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
306 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
308 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
309 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
310 s->rd_scratchpad= s->me.scratchpad;
311 s->b_scratchpad= s->me.scratchpad;
312 s->obmc_scratchpad= s->me.scratchpad + 16;
314 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
315 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
316 if(s->avctx->noise_reduction){
317 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
320 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
321 s->block= s->blocks[0];
324 s->pblocks[i] = (short *)(&s->block[i]);
328 return -1; //free() through MPV_common_end()
331 static void free_duplicate_context(MpegEncContext *s){
334 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
335 av_freep(&s->me.scratchpad);
338 s->obmc_scratchpad= NULL;
340 av_freep(&s->dct_error_sum);
341 av_freep(&s->me.map);
342 av_freep(&s->me.score_map);
343 av_freep(&s->blocks);
347 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
348 #define COPY(a) bak->a= src->a
349 COPY(allocated_edge_emu_buffer);
350 COPY(edge_emu_buffer);
354 COPY(obmc_scratchpad);
361 COPY(me.map_generation);
369 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
372 //FIXME copy only needed parts
374 backup_duplicate_context(&bak, dst);
375 memcpy(dst, src, sizeof(MpegEncContext));
376 backup_duplicate_context(dst, &bak);
378 dst->pblocks[i] = (short *)(&dst->block[i]);
380 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
384 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
385 * the changed fields will not depend upon the prior state of the MpegEncContext.
387 void MPV_common_defaults(MpegEncContext *s){
389 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
390 s->chroma_qscale_table= ff_default_chroma_qscale_table;
391 s->progressive_frame= 1;
392 s->progressive_sequence= 1;
393 s->picture_structure= PICT_FRAME;
395 s->coded_picture_number = 0;
396 s->picture_number = 0;
397 s->input_picture_number = 0;
399 s->picture_in_gop_number = 0;
406 * sets the given MpegEncContext to defaults for decoding.
407 * the changed fields will not depend upon the prior state of the MpegEncContext.
409 void MPV_decode_defaults(MpegEncContext *s){
410 MPV_common_defaults(s);
414 * init common structure for both encoder and decoder.
415 * this assumes that some variables like width/height are already set
417 int MPV_common_init(MpegEncContext *s)
419 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
421 s->mb_height = (s->height + 15) / 16;
423 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
424 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
428 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
431 dsputil_init(&s->dsp, s->avctx);
432 ff_dct_common_init(s);
434 s->flags= s->avctx->flags;
435 s->flags2= s->avctx->flags2;
437 s->mb_width = (s->width + 15) / 16;
438 s->mb_stride = s->mb_width + 1;
439 s->b8_stride = s->mb_width*2 + 1;
440 s->b4_stride = s->mb_width*4 + 1;
441 mb_array_size= s->mb_height * s->mb_stride;
442 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
444 /* set chroma shifts */
445 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
446 &(s->chroma_y_shift) );
448 /* set default edge pos, will be overriden in decode_header if needed */
449 s->h_edge_pos= s->mb_width*16;
450 s->v_edge_pos= s->mb_height*16;
452 s->mb_num = s->mb_width * s->mb_height;
457 s->block_wrap[3]= s->b8_stride;
459 s->block_wrap[5]= s->mb_stride;
461 y_size = s->b8_stride * (2 * s->mb_height + 1);
462 c_size = s->mb_stride * (s->mb_height + 1);
463 yc_size = y_size + 2 * c_size;
465 /* convert fourcc to upper case */
466 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
467 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
468 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
469 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
471 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
472 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
473 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
474 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
476 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
478 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
479 for(y=0; y<s->mb_height; y++){
480 for(x=0; x<s->mb_width; x++){
481 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
484 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
487 /* Allocate MV tables */
488 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
489 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
490 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
491 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
492 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
493 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
494 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
495 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
496 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
497 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
498 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
499 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
501 if(s->msmpeg4_version){
502 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
504 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
506 /* Allocate MB type table */
507 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
509 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
511 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
512 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
513 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
514 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
515 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
516 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
518 if(s->avctx->noise_reduction){
519 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
522 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
524 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
526 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
527 /* interlaced direct mode decoding tables */
532 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
533 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
535 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
536 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
537 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
539 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
542 if (s->out_format == FMT_H263) {
544 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
545 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
546 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
547 s->ac_val[2] = s->ac_val[1] + c_size;
550 CHECKED_ALLOCZ(s->coded_block_base, y_size);
551 s->coded_block= s->coded_block_base + s->b8_stride + 1;
553 /* cbp, ac_pred, pred_dir */
554 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
555 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
558 if (s->h263_pred || s->h263_plus || !s->encoding) {
560 //MN: we need these for error resilience of intra-frames
561 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
562 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
563 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
564 s->dc_val[2] = s->dc_val[1] + c_size;
565 for(i=0;i<yc_size;i++)
566 s->dc_val_base[i] = 1024;
569 /* which mb is a intra block */
570 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
571 memset(s->mbintra_table, 1, mb_array_size);
573 /* init macroblock skip table */
574 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
575 //Note the +1 is for a quicker mpeg4 slice_end detection
576 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
578 s->parse_context.state= -1;
579 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
580 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
581 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
582 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
585 s->context_initialized = 1;
587 s->thread_context[0]= s;
588 threads = s->avctx->thread_count;
590 for(i=1; i<threads; i++){
591 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
592 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
595 for(i=0; i<threads; i++){
596 if(init_duplicate_context(s->thread_context[i], s) < 0)
598 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
599 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
608 /* init common structure for both encoder and decoder */
609 void MPV_common_end(MpegEncContext *s)
613 for(i=0; i<s->avctx->thread_count; i++){
614 free_duplicate_context(s->thread_context[i]);
616 for(i=1; i<s->avctx->thread_count; i++){
617 av_freep(&s->thread_context[i]);
620 av_freep(&s->parse_context.buffer);
621 s->parse_context.buffer_size=0;
623 av_freep(&s->mb_type);
624 av_freep(&s->p_mv_table_base);
625 av_freep(&s->b_forw_mv_table_base);
626 av_freep(&s->b_back_mv_table_base);
627 av_freep(&s->b_bidir_forw_mv_table_base);
628 av_freep(&s->b_bidir_back_mv_table_base);
629 av_freep(&s->b_direct_mv_table_base);
631 s->b_forw_mv_table= NULL;
632 s->b_back_mv_table= NULL;
633 s->b_bidir_forw_mv_table= NULL;
634 s->b_bidir_back_mv_table= NULL;
635 s->b_direct_mv_table= NULL;
639 av_freep(&s->b_field_mv_table_base[i][j][k]);
640 s->b_field_mv_table[i][j][k]=NULL;
642 av_freep(&s->b_field_select_table[i][j]);
643 av_freep(&s->p_field_mv_table_base[i][j]);
644 s->p_field_mv_table[i][j]=NULL;
646 av_freep(&s->p_field_select_table[i]);
649 av_freep(&s->dc_val_base);
650 av_freep(&s->ac_val_base);
651 av_freep(&s->coded_block_base);
652 av_freep(&s->mbintra_table);
653 av_freep(&s->cbp_table);
654 av_freep(&s->pred_dir_table);
656 av_freep(&s->mbskip_table);
657 av_freep(&s->prev_pict_types);
658 av_freep(&s->bitstream_buffer);
659 s->allocated_bitstream_buffer_size=0;
661 av_freep(&s->avctx->stats_out);
662 av_freep(&s->ac_stats);
663 av_freep(&s->error_status_table);
664 av_freep(&s->mb_index2xy);
665 av_freep(&s->lambda_table);
666 av_freep(&s->q_intra_matrix);
667 av_freep(&s->q_inter_matrix);
668 av_freep(&s->q_intra_matrix16);
669 av_freep(&s->q_inter_matrix16);
670 av_freep(&s->input_picture);
671 av_freep(&s->reordered_input_picture);
672 av_freep(&s->dct_offset);
675 for(i=0; i<MAX_PICTURE_COUNT; i++){
676 free_picture(s, &s->picture[i]);
679 av_freep(&s->picture);
680 s->context_initialized = 0;
683 s->current_picture_ptr= NULL;
684 s->linesize= s->uvlinesize= 0;
687 av_freep(&s->visualization_buffer[i]);
689 avcodec_default_free_buffers(s->avctx);
692 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
694 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
695 uint8_t index_run[MAX_RUN+1];
696 int last, run, level, start, end, i;
698 /* If table is static, we can quit if rl->max_level[0] is not NULL */
699 if(static_store && rl->max_level[0])
702 /* compute max_level[], max_run[] and index_run[] */
703 for(last=0;last<2;last++) {
712 memset(max_level, 0, MAX_RUN + 1);
713 memset(max_run, 0, MAX_LEVEL + 1);
714 memset(index_run, rl->n, MAX_RUN + 1);
715 for(i=start;i<end;i++) {
716 run = rl->table_run[i];
717 level = rl->table_level[i];
718 if (index_run[run] == rl->n)
720 if (level > max_level[run])
721 max_level[run] = level;
722 if (run > max_run[level])
723 max_run[level] = run;
726 rl->max_level[last] = static_store[last];
728 rl->max_level[last] = av_malloc(MAX_RUN + 1);
729 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
731 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
733 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
734 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
736 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
738 rl->index_run[last] = av_malloc(MAX_RUN + 1);
739 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
743 void init_vlc_rl(RLTable *rl, int use_static)
747 /* Return if static table is already initialized */
748 if(use_static && rl->rl_vlc[0])
751 init_vlc(&rl->vlc, 9, rl->n + 1,
752 &rl->table_vlc[0][1], 4, 2,
753 &rl->table_vlc[0][0], 4, 2, use_static);
765 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
767 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
768 for(i=0; i<rl->vlc.table_size; i++){
769 int code= rl->vlc.table[i][0];
770 int len = rl->vlc.table[i][1];
773 if(len==0){ // illegal code
776 }else if(len<0){ //more bits needed
780 if(code==rl->n){ //esc
784 run= rl->table_run [code] + 1;
785 level= rl->table_level[code] * qmul + qadd;
786 if(code >= rl->last) run+=192;
789 rl->rl_vlc[q][i].len= len;
790 rl->rl_vlc[q][i].level= level;
791 rl->rl_vlc[q][i].run= run;
796 /* draw the edges of width 'w' of an image of size width, height */
797 //FIXME check that this is ok for mpeg4 interlaced
798 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
800 uint8_t *ptr, *last_line;
803 last_line = buf + (height - 1) * wrap;
806 memcpy(buf - (i + 1) * wrap, buf, width);
807 memcpy(last_line + (i + 1) * wrap, last_line, width);
811 for(i=0;i<height;i++) {
812 memset(ptr - w, ptr[0], w);
813 memset(ptr + width, ptr[width-1], w);
818 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
819 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
820 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
821 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
825 int ff_find_unused_picture(MpegEncContext *s, int shared){
829 for(i=0; i<MAX_PICTURE_COUNT; i++){
830 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
833 for(i=0; i<MAX_PICTURE_COUNT; i++){
834 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
836 for(i=0; i<MAX_PICTURE_COUNT; i++){
837 if(s->picture[i].data[0]==NULL) return i;
841 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
842 /* We could return -1, but the codec would crash trying to draw into a
843 * non-existing frame anyway. This is safer than waiting for a random crash.
844 * Also the return of this is never useful, an encoder must only allocate
845 * as much as allowed in the specification. This has no relationship to how
846 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
847 * enough for such valid streams).
848 * Plus, a decoder has to check stream validity and remove frames if too
849 * many reference frames are around. Waiting for "OOM" is not correct at
850 * all. Similarly, missing reference frames have to be replaced by
851 * interpolated/MC frames, anything else is a bug in the codec ...
857 static void update_noise_reduction(MpegEncContext *s){
860 for(intra=0; intra<2; intra++){
861 if(s->dct_count[intra] > (1<<16)){
863 s->dct_error_sum[intra][i] >>=1;
865 s->dct_count[intra] >>= 1;
869 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);
875 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
877 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
883 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
885 /* mark&release old frames */
886 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
887 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
888 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
890 /* release forgotten pictures */
891 /* if(mpeg124/h263) */
893 for(i=0; i<MAX_PICTURE_COUNT; i++){
894 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
895 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
896 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
904 /* release non reference frames */
905 for(i=0; i<MAX_PICTURE_COUNT; i++){
906 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
907 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
911 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
912 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
914 i= ff_find_unused_picture(s, 0);
915 pic= (AVFrame*)&s->picture[i];
920 if (s->codec_id == CODEC_ID_H264)
921 pic->reference = s->picture_structure;
922 else if (s->pict_type != B_TYPE)
926 pic->coded_picture_number= s->coded_picture_number++;
928 if( alloc_picture(s, (Picture*)pic, 0) < 0)
931 s->current_picture_ptr= (Picture*)pic;
932 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
933 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
936 s->current_picture_ptr->pict_type= s->pict_type;
937 // if(s->flags && CODEC_FLAG_QSCALE)
938 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
939 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
941 copy_picture(&s->current_picture, s->current_picture_ptr);
943 if (s->pict_type != B_TYPE) {
944 s->last_picture_ptr= s->next_picture_ptr;
946 s->next_picture_ptr= s->current_picture_ptr;
948 /* 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,
949 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
950 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
951 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
952 s->pict_type, s->dropable);*/
954 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
955 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
957 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
958 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
959 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
963 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
965 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
968 if(s->picture_structure == PICT_BOTTOM_FIELD){
969 s->current_picture.data[i] += s->current_picture.linesize[i];
971 s->current_picture.linesize[i] *= 2;
972 s->last_picture.linesize[i] *=2;
973 s->next_picture.linesize[i] *=2;
977 s->hurry_up= s->avctx->hurry_up;
978 s->error_resilience= avctx->error_resilience;
980 /* set dequantizer, we can't do it during init as it might change for mpeg4
981 and we can't do it in the header decode as init is not called for mpeg4 there yet */
982 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
983 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
984 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
985 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
986 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
987 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
989 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
990 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
993 if(s->dct_error_sum){
994 assert(s->avctx->noise_reduction && s->encoding);
996 update_noise_reduction(s);
1000 if(s->avctx->xvmc_acceleration)
1001 return XVMC_field_start(s, avctx);
1006 /* generic function for encode/decode called after a frame has been coded/decoded */
1007 void MPV_frame_end(MpegEncContext *s)
1010 /* draw edge for correct motion prediction if outside */
1012 //just to make sure that all data is rendered.
1013 if(s->avctx->xvmc_acceleration){
1017 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1018 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1019 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1020 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1024 s->last_pict_type = s->pict_type;
1025 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1026 if(s->pict_type!=B_TYPE){
1027 s->last_non_b_pict_type= s->pict_type;
1030 /* copy back current_picture variables */
1031 for(i=0; i<MAX_PICTURE_COUNT; i++){
1032 if(s->picture[i].data[0] == s->current_picture.data[0]){
1033 s->picture[i]= s->current_picture;
1037 assert(i<MAX_PICTURE_COUNT);
1041 /* release non-reference frames */
1042 for(i=0; i<MAX_PICTURE_COUNT; i++){
1043 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1044 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1048 // clear copies, to avoid confusion
1050 memset(&s->last_picture, 0, sizeof(Picture));
1051 memset(&s->next_picture, 0, sizeof(Picture));
1052 memset(&s->current_picture, 0, sizeof(Picture));
1054 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1058 * draws an line from (ex, ey) -> (sx, sy).
1059 * @param w width of the image
1060 * @param h height of the image
1061 * @param stride stride/linesize of the image
1062 * @param color color of the arrow
1064 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1067 sx= av_clip(sx, 0, w-1);
1068 sy= av_clip(sy, 0, h-1);
1069 ex= av_clip(ex, 0, w-1);
1070 ey= av_clip(ey, 0, h-1);
1072 buf[sy*stride + sx]+= color;
1074 if(FFABS(ex - sx) > FFABS(ey - sy)){
1076 FFSWAP(int, sx, ex);
1077 FFSWAP(int, sy, ey);
1079 buf+= sx + sy*stride;
1081 f= ((ey-sy)<<16)/ex;
1082 for(x= 0; x <= ex; x++){
1085 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1086 buf[(y+1)*stride + x]+= (color* fr )>>16;
1090 FFSWAP(int, sx, ex);
1091 FFSWAP(int, sy, ey);
1093 buf+= sx + sy*stride;
1095 if(ey) f= ((ex-sx)<<16)/ey;
1097 for(y= 0; y <= ey; y++){
1100 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1101 buf[y*stride + x+1]+= (color* fr )>>16;
1107 * draws an arrow from (ex, ey) -> (sx, sy).
1108 * @param w width of the image
1109 * @param h height of the image
1110 * @param stride stride/linesize of the image
1111 * @param color color of the arrow
1113 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1116 sx= av_clip(sx, -100, w+100);
1117 sy= av_clip(sy, -100, h+100);
1118 ex= av_clip(ex, -100, w+100);
1119 ey= av_clip(ey, -100, h+100);
1124 if(dx*dx + dy*dy > 3*3){
1127 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1129 //FIXME subpixel accuracy
1130 rx= ROUNDED_DIV(rx*3<<4, length);
1131 ry= ROUNDED_DIV(ry*3<<4, length);
1133 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1134 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1136 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1140 * prints debuging info for the given picture.
1142 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1144 if(!pict || !pict->mb_type) return;
1146 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1149 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1150 switch (pict->pict_type) {
1151 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1152 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1153 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1154 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1155 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1156 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1158 for(y=0; y<s->mb_height; y++){
1159 for(x=0; x<s->mb_width; x++){
1160 if(s->avctx->debug&FF_DEBUG_SKIP){
1161 int count= s->mbskip_table[x + y*s->mb_stride];
1162 if(count>9) count=9;
1163 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1165 if(s->avctx->debug&FF_DEBUG_QP){
1166 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1168 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1169 int mb_type= pict->mb_type[x + y*s->mb_stride];
1170 //Type & MV direction
1172 av_log(s->avctx, AV_LOG_DEBUG, "P");
1173 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1174 av_log(s->avctx, AV_LOG_DEBUG, "A");
1175 else if(IS_INTRA4x4(mb_type))
1176 av_log(s->avctx, AV_LOG_DEBUG, "i");
1177 else if(IS_INTRA16x16(mb_type))
1178 av_log(s->avctx, AV_LOG_DEBUG, "I");
1179 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1180 av_log(s->avctx, AV_LOG_DEBUG, "d");
1181 else if(IS_DIRECT(mb_type))
1182 av_log(s->avctx, AV_LOG_DEBUG, "D");
1183 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1184 av_log(s->avctx, AV_LOG_DEBUG, "g");
1185 else if(IS_GMC(mb_type))
1186 av_log(s->avctx, AV_LOG_DEBUG, "G");
1187 else if(IS_SKIP(mb_type))
1188 av_log(s->avctx, AV_LOG_DEBUG, "S");
1189 else if(!USES_LIST(mb_type, 1))
1190 av_log(s->avctx, AV_LOG_DEBUG, ">");
1191 else if(!USES_LIST(mb_type, 0))
1192 av_log(s->avctx, AV_LOG_DEBUG, "<");
1194 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1195 av_log(s->avctx, AV_LOG_DEBUG, "X");
1200 av_log(s->avctx, AV_LOG_DEBUG, "+");
1201 else if(IS_16X8(mb_type))
1202 av_log(s->avctx, AV_LOG_DEBUG, "-");
1203 else if(IS_8X16(mb_type))
1204 av_log(s->avctx, AV_LOG_DEBUG, "|");
1205 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1206 av_log(s->avctx, AV_LOG_DEBUG, " ");
1208 av_log(s->avctx, AV_LOG_DEBUG, "?");
1211 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1212 av_log(s->avctx, AV_LOG_DEBUG, "=");
1214 av_log(s->avctx, AV_LOG_DEBUG, " ");
1216 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1218 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1222 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1223 const int shift= 1 + s->quarter_sample;
1227 int h_chroma_shift, v_chroma_shift;
1228 const int width = s->avctx->width;
1229 const int height= s->avctx->height;
1230 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1231 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1232 s->low_delay=0; //needed to see the vectors without trashing the buffers
1234 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1236 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1237 pict->data[i]= s->visualization_buffer[i];
1239 pict->type= FF_BUFFER_TYPE_COPY;
1242 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1244 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1245 const int mb_index= mb_x + mb_y*s->mb_stride;
1246 if((s->avctx->debug_mv) && pict->motion_val){
1248 for(type=0; type<3; type++){
1251 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1255 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1259 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1264 if(!USES_LIST(pict->mb_type[mb_index], direction))
1267 if(IS_8X8(pict->mb_type[mb_index])){
1270 int sx= mb_x*16 + 4 + 8*(i&1);
1271 int sy= mb_y*16 + 4 + 8*(i>>1);
1272 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1273 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1274 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1275 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1277 }else if(IS_16X8(pict->mb_type[mb_index])){
1281 int sy=mb_y*16 + 4 + 8*i;
1282 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1283 int mx=(pict->motion_val[direction][xy][0]>>shift);
1284 int my=(pict->motion_val[direction][xy][1]>>shift);
1286 if(IS_INTERLACED(pict->mb_type[mb_index]))
1289 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1291 }else if(IS_8X16(pict->mb_type[mb_index])){
1294 int sx=mb_x*16 + 4 + 8*i;
1296 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1297 int mx=(pict->motion_val[direction][xy][0]>>shift);
1298 int my=(pict->motion_val[direction][xy][1]>>shift);
1300 if(IS_INTERLACED(pict->mb_type[mb_index]))
1303 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1306 int sx= mb_x*16 + 8;
1307 int sy= mb_y*16 + 8;
1308 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1309 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1310 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1311 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1315 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1316 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1319 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1320 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1323 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1324 int mb_type= pict->mb_type[mb_index];
1327 #define COLOR(theta, r)\
1328 u= (int)(128 + r*cos(theta*3.141592/180));\
1329 v= (int)(128 + r*sin(theta*3.141592/180));
1333 if(IS_PCM(mb_type)){
1335 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1337 }else if(IS_INTRA4x4(mb_type)){
1339 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1341 }else if(IS_DIRECT(mb_type)){
1343 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1345 }else if(IS_GMC(mb_type)){
1347 }else if(IS_SKIP(mb_type)){
1349 }else if(!USES_LIST(mb_type, 1)){
1351 }else if(!USES_LIST(mb_type, 0)){
1354 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1358 u*= 0x0101010101010101ULL;
1359 v*= 0x0101010101010101ULL;
1361 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1362 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1366 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1367 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1368 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1370 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1372 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1374 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1375 int dm= 1 << (mv_sample_log2-2);
1377 int sx= mb_x*16 + 8*(i&1);
1378 int sy= mb_y*16 + 8*(i>>1);
1379 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1381 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1382 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1384 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1385 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1386 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1390 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1394 s->mbskip_table[mb_index]=0;
1401 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1402 * @param buf destination buffer
1403 * @param src source buffer
1404 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1405 * @param block_w width of block
1406 * @param block_h height of block
1407 * @param src_x x coordinate of the top left sample of the block in the source buffer
1408 * @param src_y y coordinate of the top left sample of the block in the source buffer
1409 * @param w width of the source buffer
1410 * @param h height of the source buffer
1412 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1413 int src_x, int src_y, int w, int h){
1415 int start_y, start_x, end_y, end_x;
1418 src+= (h-1-src_y)*linesize;
1420 }else if(src_y<=-block_h){
1421 src+= (1-block_h-src_y)*linesize;
1427 }else if(src_x<=-block_w){
1428 src+= (1-block_w-src_x);
1432 start_y= FFMAX(0, -src_y);
1433 start_x= FFMAX(0, -src_x);
1434 end_y= FFMIN(block_h, h-src_y);
1435 end_x= FFMIN(block_w, w-src_x);
1437 // copy existing part
1438 for(y=start_y; y<end_y; y++){
1439 for(x=start_x; x<end_x; x++){
1440 buf[x + y*linesize]= src[x + y*linesize];
1445 for(y=0; y<start_y; y++){
1446 for(x=start_x; x<end_x; x++){
1447 buf[x + y*linesize]= buf[x + start_y*linesize];
1452 for(y=end_y; y<block_h; y++){
1453 for(x=start_x; x<end_x; x++){
1454 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1458 for(y=0; y<block_h; y++){
1460 for(x=0; x<start_x; x++){
1461 buf[x + y*linesize]= buf[start_x + y*linesize];
1465 for(x=end_x; x<block_w; x++){
1466 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1471 static inline int hpel_motion_lowres(MpegEncContext *s,
1472 uint8_t *dest, uint8_t *src,
1473 int field_based, int field_select,
1474 int src_x, int src_y,
1475 int width, int height, int stride,
1476 int h_edge_pos, int v_edge_pos,
1477 int w, int h, h264_chroma_mc_func *pix_op,
1478 int motion_x, int motion_y)
1480 const int lowres= s->avctx->lowres;
1481 const int s_mask= (2<<lowres)-1;
1485 if(s->quarter_sample){
1490 sx= motion_x & s_mask;
1491 sy= motion_y & s_mask;
1492 src_x += motion_x >> (lowres+1);
1493 src_y += motion_y >> (lowres+1);
1495 src += src_y * stride + src_x;
1497 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1498 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1499 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1500 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1501 src= s->edge_emu_buffer;
1509 pix_op[lowres](dest, src, stride, h, sx, sy);
1513 /* apply one mpeg motion vector to the three components */
1514 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1515 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1516 int field_based, int bottom_field, int field_select,
1517 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1518 int motion_x, int motion_y, int h)
1520 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1521 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1522 const int lowres= s->avctx->lowres;
1523 const int block_s= 8>>lowres;
1524 const int s_mask= (2<<lowres)-1;
1525 const int h_edge_pos = s->h_edge_pos >> lowres;
1526 const int v_edge_pos = s->v_edge_pos >> lowres;
1527 linesize = s->current_picture.linesize[0] << field_based;
1528 uvlinesize = s->current_picture.linesize[1] << field_based;
1530 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1536 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1539 sx= motion_x & s_mask;
1540 sy= motion_y & s_mask;
1541 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1542 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1544 if (s->out_format == FMT_H263) {
1545 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1546 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1549 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1552 uvsx = (2*mx) & s_mask;
1553 uvsy = (2*my) & s_mask;
1554 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1555 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1561 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1562 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1565 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1566 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1567 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1569 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1570 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1571 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1572 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1573 ptr_y = s->edge_emu_buffer;
1574 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1575 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1576 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1577 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1578 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1579 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1585 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1586 dest_y += s->linesize;
1587 dest_cb+= s->uvlinesize;
1588 dest_cr+= s->uvlinesize;
1592 ptr_y += s->linesize;
1593 ptr_cb+= s->uvlinesize;
1594 ptr_cr+= s->uvlinesize;
1599 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1601 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1602 uvsx <<= 2 - lowres;
1603 uvsy <<= 2 - lowres;
1604 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1605 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1607 //FIXME h261 lowres loop filter
1610 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1611 uint8_t *dest_cb, uint8_t *dest_cr,
1612 uint8_t **ref_picture,
1613 h264_chroma_mc_func *pix_op,
1615 const int lowres= s->avctx->lowres;
1616 const int block_s= 8>>lowres;
1617 const int s_mask= (2<<lowres)-1;
1618 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1619 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1620 int emu=0, src_x, src_y, offset, sx, sy;
1623 if(s->quarter_sample){
1628 /* In case of 8X8, we construct a single chroma motion vector
1629 with a special rounding */
1630 mx= ff_h263_round_chroma(mx);
1631 my= ff_h263_round_chroma(my);
1635 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1636 src_y = s->mb_y*block_s + (my >> (lowres+1));
1638 offset = src_y * s->uvlinesize + src_x;
1639 ptr = ref_picture[1] + offset;
1640 if(s->flags&CODEC_FLAG_EMU_EDGE){
1641 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1642 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1643 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1644 ptr= s->edge_emu_buffer;
1650 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1652 ptr = ref_picture[2] + offset;
1654 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1655 ptr= s->edge_emu_buffer;
1657 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1661 * motion compensation of a single macroblock
1663 * @param dest_y luma destination pointer
1664 * @param dest_cb chroma cb/u destination pointer
1665 * @param dest_cr chroma cr/v destination pointer
1666 * @param dir direction (0->forward, 1->backward)
1667 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1668 * @param pic_op halfpel motion compensation function (average or put normally)
1669 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1671 static inline void MPV_motion_lowres(MpegEncContext *s,
1672 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1673 int dir, uint8_t **ref_picture,
1674 h264_chroma_mc_func *pix_op)
1678 const int lowres= s->avctx->lowres;
1679 const int block_s= 8>>lowres;
1684 switch(s->mv_type) {
1686 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1688 ref_picture, pix_op,
1689 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1695 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1696 ref_picture[0], 0, 0,
1697 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1698 s->width, s->height, s->linesize,
1699 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1700 block_s, block_s, pix_op,
1701 s->mv[dir][i][0], s->mv[dir][i][1]);
1703 mx += s->mv[dir][i][0];
1704 my += s->mv[dir][i][1];
1707 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1708 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1711 if (s->picture_structure == PICT_FRAME) {
1713 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1714 1, 0, s->field_select[dir][0],
1715 ref_picture, pix_op,
1716 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1718 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1719 1, 1, s->field_select[dir][1],
1720 ref_picture, pix_op,
1721 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1723 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
1724 ref_picture= s->current_picture_ptr->data;
1727 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1728 0, 0, s->field_select[dir][0],
1729 ref_picture, pix_op,
1730 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1735 uint8_t ** ref2picture;
1737 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
1738 ref2picture= ref_picture;
1740 ref2picture= s->current_picture_ptr->data;
1743 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1744 0, 0, s->field_select[dir][i],
1745 ref2picture, pix_op,
1746 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1748 dest_y += 2*block_s*s->linesize;
1749 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1750 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1754 if(s->picture_structure == PICT_FRAME){
1758 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1760 ref_picture, pix_op,
1761 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1763 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1767 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1768 0, 0, s->picture_structure != i+1,
1769 ref_picture, pix_op,
1770 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1772 // after put we make avg of the same block
1773 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1775 //opposite parity is always in the same frame if this is second field
1776 if(!s->first_field){
1777 ref_picture = s->current_picture_ptr->data;
1786 /* put block[] to dest[] */
1787 static inline void put_dct(MpegEncContext *s,
1788 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1790 s->dct_unquantize_intra(s, block, i, qscale);
1791 s->dsp.idct_put (dest, line_size, block);
1794 /* add block[] to dest[] */
1795 static inline void add_dct(MpegEncContext *s,
1796 DCTELEM *block, int i, uint8_t *dest, int line_size)
1798 if (s->block_last_index[i] >= 0) {
1799 s->dsp.idct_add (dest, line_size, block);
1803 static inline void add_dequant_dct(MpegEncContext *s,
1804 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1806 if (s->block_last_index[i] >= 0) {
1807 s->dct_unquantize_inter(s, block, i, qscale);
1809 s->dsp.idct_add (dest, line_size, block);
1814 * cleans dc, ac, coded_block for the current non intra MB
1816 void ff_clean_intra_table_entries(MpegEncContext *s)
1818 int wrap = s->b8_stride;
1819 int xy = s->block_index[0];
1822 s->dc_val[0][xy + 1 ] =
1823 s->dc_val[0][xy + wrap] =
1824 s->dc_val[0][xy + 1 + wrap] = 1024;
1826 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1827 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1828 if (s->msmpeg4_version>=3) {
1829 s->coded_block[xy ] =
1830 s->coded_block[xy + 1 ] =
1831 s->coded_block[xy + wrap] =
1832 s->coded_block[xy + 1 + wrap] = 0;
1835 wrap = s->mb_stride;
1836 xy = s->mb_x + s->mb_y * wrap;
1838 s->dc_val[2][xy] = 1024;
1840 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1841 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1843 s->mbintra_table[xy]= 0;
1846 /* generic function called after a macroblock has been parsed by the
1847 decoder or after it has been encoded by the encoder.
1849 Important variables used:
1850 s->mb_intra : true if intra macroblock
1851 s->mv_dir : motion vector direction
1852 s->mv_type : motion vector type
1853 s->mv : motion vector
1854 s->interlaced_dct : true if interlaced dct used (mpeg2)
1856 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
1859 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1861 if(s->avctx->xvmc_acceleration){
1862 XVMC_decode_mb(s);//xvmc uses pblocks
1870 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1871 /* save DCT coefficients */
1873 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1876 *dct++ = block[i][s->dsp.idct_permutation[j]];
1879 s->current_picture.qscale_table[mb_xy]= s->qscale;
1881 /* update DC predictors for P macroblocks */
1883 if (s->h263_pred || s->h263_aic) {
1884 if(s->mbintra_table[mb_xy])
1885 ff_clean_intra_table_entries(s);
1889 s->last_dc[2] = 128 << s->intra_dc_precision;
1892 else if (s->h263_pred || s->h263_aic)
1893 s->mbintra_table[mb_xy]=1;
1895 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1896 uint8_t *dest_y, *dest_cb, *dest_cr;
1897 int dct_linesize, dct_offset;
1898 op_pixels_func (*op_pix)[4];
1899 qpel_mc_func (*op_qpix)[16];
1900 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1901 const int uvlinesize= s->current_picture.linesize[1];
1902 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1903 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1905 /* avoid copy if macroblock skipped in last frame too */
1906 /* skip only during decoding as we might trash the buffers during encoding a bit */
1908 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1909 const int age= s->current_picture.age;
1913 if (s->mb_skipped) {
1915 assert(s->pict_type!=I_TYPE);
1917 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1918 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1920 /* if previous was skipped too, then nothing to do ! */
1921 if (*mbskip_ptr >= age && s->current_picture.reference){
1924 } else if(!s->current_picture.reference){
1925 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1926 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1928 *mbskip_ptr = 0; /* not skipped */
1932 dct_linesize = linesize << s->interlaced_dct;
1933 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1937 dest_cb= s->dest[1];
1938 dest_cr= s->dest[2];
1940 dest_y = s->b_scratchpad;
1941 dest_cb= s->b_scratchpad+16*linesize;
1942 dest_cr= s->b_scratchpad+32*linesize;
1946 /* motion handling */
1947 /* decoding or more than one mb_type (MC was already done otherwise) */
1950 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1952 if (s->mv_dir & MV_DIR_FORWARD) {
1953 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1954 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1956 if (s->mv_dir & MV_DIR_BACKWARD) {
1957 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1960 op_qpix= s->me.qpel_put;
1961 if ((!s->no_rounding) || s->pict_type==B_TYPE){
1962 op_pix = s->dsp.put_pixels_tab;
1964 op_pix = s->dsp.put_no_rnd_pixels_tab;
1966 if (s->mv_dir & MV_DIR_FORWARD) {
1967 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1968 op_pix = s->dsp.avg_pixels_tab;
1969 op_qpix= s->me.qpel_avg;
1971 if (s->mv_dir & MV_DIR_BACKWARD) {
1972 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1977 /* skip dequant / idct if we are really late ;) */
1978 if(s->hurry_up>1) goto skip_idct;
1979 if(s->avctx->skip_idct){
1980 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
1981 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
1982 || s->avctx->skip_idct >= AVDISCARD_ALL)
1986 /* add dct residue */
1987 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1988 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1989 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1990 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1991 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1992 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1994 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1995 if (s->chroma_y_shift){
1996 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1997 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2001 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2002 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2003 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2004 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2007 } else if(s->codec_id != CODEC_ID_WMV2){
2008 add_dct(s, block[0], 0, dest_y , dct_linesize);
2009 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2010 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2011 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2013 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2014 if(s->chroma_y_shift){//Chroma420
2015 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2016 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2019 dct_linesize = uvlinesize << s->interlaced_dct;
2020 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2022 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2023 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2024 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2025 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2026 if(!s->chroma_x_shift){//Chroma444
2027 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2028 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2029 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2030 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2035 else if (ENABLE_WMV2) {
2036 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2039 /* dct only in intra block */
2040 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2041 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2042 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2043 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2044 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2046 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2047 if(s->chroma_y_shift){
2048 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2049 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2053 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2054 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2055 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2056 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2060 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2061 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2062 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2063 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2065 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2066 if(s->chroma_y_shift){
2067 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2068 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2071 dct_linesize = uvlinesize << s->interlaced_dct;
2072 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2074 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2075 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2076 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2077 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2078 if(!s->chroma_x_shift){//Chroma444
2079 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2080 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2081 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2082 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2090 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2091 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2092 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2097 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2098 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
2099 else MPV_decode_mb_internal(s, block, 0);
2104 * @param h is the normal height, this will be reduced automatically if needed for the last row
2106 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2107 if (s->avctx->draw_horiz_band) {
2111 if(s->picture_structure != PICT_FRAME){
2114 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2117 h= FFMIN(h, s->avctx->height - y);
2119 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2120 src= (AVFrame*)s->current_picture_ptr;
2121 else if(s->last_picture_ptr)
2122 src= (AVFrame*)s->last_picture_ptr;
2126 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2132 offset[0]= y * s->linesize;
2134 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2140 s->avctx->draw_horiz_band(s->avctx, src, offset,
2141 y, s->picture_structure, h);
2145 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2146 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2147 const int uvlinesize= s->current_picture.linesize[1];
2148 const int mb_size= 4 - s->avctx->lowres;
2150 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2151 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2152 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2153 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2154 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2155 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;
2156 //block_index is not used by mpeg2, so it is not affected by chroma_format
2158 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2159 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2160 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2162 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2164 s->dest[0] += s->mb_y * linesize << mb_size;
2165 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2166 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2170 void ff_mpeg_flush(AVCodecContext *avctx){
2172 MpegEncContext *s = avctx->priv_data;
2174 if(s==NULL || s->picture==NULL)
2177 for(i=0; i<MAX_PICTURE_COUNT; i++){
2178 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2179 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2180 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2182 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2184 s->mb_x= s->mb_y= 0;
2186 s->parse_context.state= -1;
2187 s->parse_context.frame_start_found= 0;
2188 s->parse_context.overread= 0;
2189 s->parse_context.overread_index= 0;
2190 s->parse_context.index= 0;
2191 s->parse_context.last_index= 0;
2192 s->bitstream_buffer_size=0;
2196 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2197 DCTELEM *block, int n, int qscale)
2199 int i, level, nCoeffs;
2200 const uint16_t *quant_matrix;
2202 nCoeffs= s->block_last_index[n];
2205 block[0] = block[0] * s->y_dc_scale;
2207 block[0] = block[0] * s->c_dc_scale;
2208 /* XXX: only mpeg1 */
2209 quant_matrix = s->intra_matrix;
2210 for(i=1;i<=nCoeffs;i++) {
2211 int j= s->intra_scantable.permutated[i];
2216 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2217 level = (level - 1) | 1;
2220 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2221 level = (level - 1) | 1;
2228 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2229 DCTELEM *block, int n, int qscale)
2231 int i, level, nCoeffs;
2232 const uint16_t *quant_matrix;
2234 nCoeffs= s->block_last_index[n];
2236 quant_matrix = s->inter_matrix;
2237 for(i=0; i<=nCoeffs; i++) {
2238 int j= s->intra_scantable.permutated[i];
2243 level = (((level << 1) + 1) * qscale *
2244 ((int) (quant_matrix[j]))) >> 4;
2245 level = (level - 1) | 1;
2248 level = (((level << 1) + 1) * qscale *
2249 ((int) (quant_matrix[j]))) >> 4;
2250 level = (level - 1) | 1;
2257 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2258 DCTELEM *block, int n, int qscale)
2260 int i, level, nCoeffs;
2261 const uint16_t *quant_matrix;
2263 if(s->alternate_scan) nCoeffs= 63;
2264 else nCoeffs= s->block_last_index[n];
2267 block[0] = block[0] * s->y_dc_scale;
2269 block[0] = block[0] * s->c_dc_scale;
2270 quant_matrix = s->intra_matrix;
2271 for(i=1;i<=nCoeffs;i++) {
2272 int j= s->intra_scantable.permutated[i];
2277 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2280 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2287 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2288 DCTELEM *block, int n, int qscale)
2290 int i, level, nCoeffs;
2291 const uint16_t *quant_matrix;
2294 if(s->alternate_scan) nCoeffs= 63;
2295 else nCoeffs= s->block_last_index[n];
2298 block[0] = block[0] * s->y_dc_scale;
2300 block[0] = block[0] * s->c_dc_scale;
2301 quant_matrix = s->intra_matrix;
2302 for(i=1;i<=nCoeffs;i++) {
2303 int j= s->intra_scantable.permutated[i];
2308 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2311 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2320 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2321 DCTELEM *block, int n, int qscale)
2323 int i, level, nCoeffs;
2324 const uint16_t *quant_matrix;
2327 if(s->alternate_scan) nCoeffs= 63;
2328 else nCoeffs= s->block_last_index[n];
2330 quant_matrix = s->inter_matrix;
2331 for(i=0; i<=nCoeffs; i++) {
2332 int j= s->intra_scantable.permutated[i];
2337 level = (((level << 1) + 1) * qscale *
2338 ((int) (quant_matrix[j]))) >> 4;
2341 level = (((level << 1) + 1) * qscale *
2342 ((int) (quant_matrix[j]))) >> 4;
2351 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2352 DCTELEM *block, int n, int qscale)
2354 int i, level, qmul, qadd;
2357 assert(s->block_last_index[n]>=0);
2363 block[0] = block[0] * s->y_dc_scale;
2365 block[0] = block[0] * s->c_dc_scale;
2366 qadd = (qscale - 1) | 1;
2373 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2375 for(i=1; i<=nCoeffs; i++) {
2379 level = level * qmul - qadd;
2381 level = level * qmul + qadd;
2388 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2389 DCTELEM *block, int n, int qscale)
2391 int i, level, qmul, qadd;
2394 assert(s->block_last_index[n]>=0);
2396 qadd = (qscale - 1) | 1;
2399 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2401 for(i=0; i<=nCoeffs; i++) {
2405 level = level * qmul - qadd;
2407 level = level * qmul + qadd;
2415 * set qscale and update qscale dependent variables.
2417 void ff_set_qscale(MpegEncContext * s, int qscale)
2421 else if (qscale > 31)
2425 s->chroma_qscale= s->chroma_qscale_table[qscale];
2427 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2428 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];