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);
59 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
60 extern void XVMC_field_end(MpegEncContext *s);
61 extern void XVMC_decode_mb(MpegEncContext *s);
64 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
67 /* enable all paranoid tests for rounding, overflows, etc... */
73 static const uint8_t ff_default_chroma_qscale_table[32]={
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 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
78 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
82 st->scantable= src_scantable;
87 st->permutated[i] = permutation[j];
96 j = st->permutated[i];
98 st->raster_end[i]= end;
102 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
110 uint32_t tmp= *state << 8;
111 *state= tmp + *(p++);
112 if(tmp == 0x100 || p==end)
117 if (p[-1] > 1 ) p+= 3;
118 else if(p[-2] ) p+= 2;
119 else if(p[-3]|(p[-1]-1)) p++;
132 /* init common dct for both encoder and decoder */
133 int ff_dct_common_init(MpegEncContext *s)
135 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
136 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
137 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
138 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
139 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
140 if(s->flags & CODEC_FLAG_BITEXACT)
141 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
142 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
144 #if defined(HAVE_MMX)
145 MPV_common_init_mmx(s);
146 #elif defined(ARCH_ALPHA)
147 MPV_common_init_axp(s);
148 #elif defined(HAVE_MLIB)
149 MPV_common_init_mlib(s);
150 #elif defined(HAVE_MMI)
151 MPV_common_init_mmi(s);
152 #elif defined(ARCH_ARMV4L)
153 MPV_common_init_armv4l(s);
154 #elif defined(HAVE_ALTIVEC)
155 MPV_common_init_altivec(s);
156 #elif defined(ARCH_BFIN)
157 MPV_common_init_bfin(s);
160 /* load & permutate scantables
161 note: only wmv uses different ones
163 if(s->alternate_scan){
164 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
165 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
167 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
168 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
170 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
171 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
176 void copy_picture(Picture *dst, Picture *src){
178 dst->type= FF_BUFFER_TYPE_COPY;
182 * allocates a Picture
183 * The pixels are allocated/set by calling get_buffer() if shared=0
185 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
186 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
187 const int mb_array_size= s->mb_stride*s->mb_height;
188 const int b8_array_size= s->b8_stride*s->mb_height*2;
189 const int b4_array_size= s->b4_stride*s->mb_height*4;
194 assert(pic->data[0]);
195 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
196 pic->type= FF_BUFFER_TYPE_SHARED;
198 assert(!pic->data[0]);
200 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
202 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
203 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
207 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
208 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
209 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
213 if(pic->linesize[1] != pic->linesize[2]){
214 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
215 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
219 s->linesize = pic->linesize[0];
220 s->uvlinesize= pic->linesize[1];
223 if(pic->qscale_table==NULL){
225 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
226 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
227 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
230 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
231 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
232 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
233 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
234 if(s->out_format == FMT_H264){
236 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
237 pic->motion_val[i]= pic->motion_val_base[i]+4;
238 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
240 pic->motion_subsample_log2= 2;
241 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
243 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
244 pic->motion_val[i]= pic->motion_val_base[i]+4;
245 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
247 pic->motion_subsample_log2= 3;
249 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
250 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
252 pic->qstride= s->mb_stride;
253 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
256 /* It might be nicer if the application would keep track of these
257 * but it would require an API change. */
258 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
259 s->prev_pict_types[0]= s->pict_type;
260 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
261 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.
264 fail: //for the CHECKED_ALLOCZ macro
266 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
271 * deallocates a picture
273 static void free_picture(MpegEncContext *s, Picture *pic){
276 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
277 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
280 av_freep(&pic->mb_var);
281 av_freep(&pic->mc_mb_var);
282 av_freep(&pic->mb_mean);
283 av_freep(&pic->mbskip_table);
284 av_freep(&pic->qscale_table);
285 av_freep(&pic->mb_type_base);
286 av_freep(&pic->dct_coeff);
287 av_freep(&pic->pan_scan);
290 av_freep(&pic->motion_val_base[i]);
291 av_freep(&pic->ref_index[i]);
294 if(pic->type == FF_BUFFER_TYPE_SHARED){
303 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
306 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
307 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
308 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
310 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
311 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
312 s->rd_scratchpad= s->me.scratchpad;
313 s->b_scratchpad= s->me.scratchpad;
314 s->obmc_scratchpad= s->me.scratchpad + 16;
316 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
317 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
318 if(s->avctx->noise_reduction){
319 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
322 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
323 s->block= s->blocks[0];
326 s->pblocks[i] = (short *)(&s->block[i]);
330 return -1; //free() through MPV_common_end()
333 static void free_duplicate_context(MpegEncContext *s){
336 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
337 av_freep(&s->me.scratchpad);
340 s->obmc_scratchpad= NULL;
342 av_freep(&s->dct_error_sum);
343 av_freep(&s->me.map);
344 av_freep(&s->me.score_map);
345 av_freep(&s->blocks);
349 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
350 #define COPY(a) bak->a= src->a
351 COPY(allocated_edge_emu_buffer);
352 COPY(edge_emu_buffer);
356 COPY(obmc_scratchpad);
363 COPY(me.map_generation);
371 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
374 //FIXME copy only needed parts
376 backup_duplicate_context(&bak, dst);
377 memcpy(dst, src, sizeof(MpegEncContext));
378 backup_duplicate_context(dst, &bak);
380 dst->pblocks[i] = (short *)(&dst->block[i]);
382 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
386 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
387 * the changed fields will not depend upon the prior state of the MpegEncContext.
389 void MPV_common_defaults(MpegEncContext *s){
391 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
392 s->chroma_qscale_table= ff_default_chroma_qscale_table;
393 s->progressive_frame= 1;
394 s->progressive_sequence= 1;
395 s->picture_structure= PICT_FRAME;
397 s->coded_picture_number = 0;
398 s->picture_number = 0;
399 s->input_picture_number = 0;
401 s->picture_in_gop_number = 0;
408 * sets the given MpegEncContext to defaults for decoding.
409 * the changed fields will not depend upon the prior state of the MpegEncContext.
411 void MPV_decode_defaults(MpegEncContext *s){
412 MPV_common_defaults(s);
416 * init common structure for both encoder and decoder.
417 * this assumes that some variables like width/height are already set
419 int MPV_common_init(MpegEncContext *s)
421 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
423 s->mb_height = (s->height + 15) / 16;
425 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
426 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
430 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
433 dsputil_init(&s->dsp, s->avctx);
434 ff_dct_common_init(s);
436 s->flags= s->avctx->flags;
437 s->flags2= s->avctx->flags2;
439 s->mb_width = (s->width + 15) / 16;
440 s->mb_stride = s->mb_width + 1;
441 s->b8_stride = s->mb_width*2 + 1;
442 s->b4_stride = s->mb_width*4 + 1;
443 mb_array_size= s->mb_height * s->mb_stride;
444 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
446 /* set chroma shifts */
447 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
448 &(s->chroma_y_shift) );
450 /* set default edge pos, will be overriden in decode_header if needed */
451 s->h_edge_pos= s->mb_width*16;
452 s->v_edge_pos= s->mb_height*16;
454 s->mb_num = s->mb_width * s->mb_height;
459 s->block_wrap[3]= s->b8_stride;
461 s->block_wrap[5]= s->mb_stride;
463 y_size = s->b8_stride * (2 * s->mb_height + 1);
464 c_size = s->mb_stride * (s->mb_height + 1);
465 yc_size = y_size + 2 * c_size;
467 /* convert fourcc to upper case */
468 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
469 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
470 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
471 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
473 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
474 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
475 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
476 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
478 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
480 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
481 for(y=0; y<s->mb_height; y++){
482 for(x=0; x<s->mb_width; x++){
483 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
486 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
489 /* Allocate MV tables */
490 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
491 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
492 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
493 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
494 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
495 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
496 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
497 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
498 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
499 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
500 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
501 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
503 if(s->msmpeg4_version){
504 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
506 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
508 /* Allocate MB type table */
509 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
511 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
513 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
514 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
515 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
516 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
517 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
518 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
520 if(s->avctx->noise_reduction){
521 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
524 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
526 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
528 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
529 /* interlaced direct mode decoding tables */
534 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
535 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
537 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
538 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
539 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
541 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
544 if (s->out_format == FMT_H263) {
546 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
547 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
548 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
549 s->ac_val[2] = s->ac_val[1] + c_size;
552 CHECKED_ALLOCZ(s->coded_block_base, y_size);
553 s->coded_block= s->coded_block_base + s->b8_stride + 1;
555 /* cbp, ac_pred, pred_dir */
556 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
557 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
560 if (s->h263_pred || s->h263_plus || !s->encoding) {
562 //MN: we need these for error resilience of intra-frames
563 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
564 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
565 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
566 s->dc_val[2] = s->dc_val[1] + c_size;
567 for(i=0;i<yc_size;i++)
568 s->dc_val_base[i] = 1024;
571 /* which mb is a intra block */
572 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
573 memset(s->mbintra_table, 1, mb_array_size);
575 /* init macroblock skip table */
576 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
577 //Note the +1 is for a quicker mpeg4 slice_end detection
578 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
580 s->parse_context.state= -1;
581 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
582 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
583 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
584 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
587 s->context_initialized = 1;
589 s->thread_context[0]= s;
590 /* h264 does thread context setup itself, but it needs context[0]
591 * to be fully initialized for the error resilience code */
592 threads = s->codec_id == CODEC_ID_H264 ? 1 : s->avctx->thread_count;
594 for(i=1; i<threads; i++){
595 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
596 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
599 for(i=0; i<threads; i++){
600 if(init_duplicate_context(s->thread_context[i], s) < 0)
602 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
603 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
612 /* init common structure for both encoder and decoder */
613 void MPV_common_end(MpegEncContext *s)
617 for(i=0; i<s->avctx->thread_count; i++){
618 free_duplicate_context(s->thread_context[i]);
620 for(i=1; i<s->avctx->thread_count; i++){
621 av_freep(&s->thread_context[i]);
624 av_freep(&s->parse_context.buffer);
625 s->parse_context.buffer_size=0;
627 av_freep(&s->mb_type);
628 av_freep(&s->p_mv_table_base);
629 av_freep(&s->b_forw_mv_table_base);
630 av_freep(&s->b_back_mv_table_base);
631 av_freep(&s->b_bidir_forw_mv_table_base);
632 av_freep(&s->b_bidir_back_mv_table_base);
633 av_freep(&s->b_direct_mv_table_base);
635 s->b_forw_mv_table= NULL;
636 s->b_back_mv_table= NULL;
637 s->b_bidir_forw_mv_table= NULL;
638 s->b_bidir_back_mv_table= NULL;
639 s->b_direct_mv_table= NULL;
643 av_freep(&s->b_field_mv_table_base[i][j][k]);
644 s->b_field_mv_table[i][j][k]=NULL;
646 av_freep(&s->b_field_select_table[i][j]);
647 av_freep(&s->p_field_mv_table_base[i][j]);
648 s->p_field_mv_table[i][j]=NULL;
650 av_freep(&s->p_field_select_table[i]);
653 av_freep(&s->dc_val_base);
654 av_freep(&s->ac_val_base);
655 av_freep(&s->coded_block_base);
656 av_freep(&s->mbintra_table);
657 av_freep(&s->cbp_table);
658 av_freep(&s->pred_dir_table);
660 av_freep(&s->mbskip_table);
661 av_freep(&s->prev_pict_types);
662 av_freep(&s->bitstream_buffer);
663 s->allocated_bitstream_buffer_size=0;
665 av_freep(&s->avctx->stats_out);
666 av_freep(&s->ac_stats);
667 av_freep(&s->error_status_table);
668 av_freep(&s->mb_index2xy);
669 av_freep(&s->lambda_table);
670 av_freep(&s->q_intra_matrix);
671 av_freep(&s->q_inter_matrix);
672 av_freep(&s->q_intra_matrix16);
673 av_freep(&s->q_inter_matrix16);
674 av_freep(&s->input_picture);
675 av_freep(&s->reordered_input_picture);
676 av_freep(&s->dct_offset);
679 for(i=0; i<MAX_PICTURE_COUNT; i++){
680 free_picture(s, &s->picture[i]);
683 av_freep(&s->picture);
684 s->context_initialized = 0;
687 s->current_picture_ptr= NULL;
688 s->linesize= s->uvlinesize= 0;
691 av_freep(&s->visualization_buffer[i]);
693 avcodec_default_free_buffers(s->avctx);
696 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
698 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
699 uint8_t index_run[MAX_RUN+1];
700 int last, run, level, start, end, i;
702 /* If table is static, we can quit if rl->max_level[0] is not NULL */
703 if(static_store && rl->max_level[0])
706 /* compute max_level[], max_run[] and index_run[] */
707 for(last=0;last<2;last++) {
716 memset(max_level, 0, MAX_RUN + 1);
717 memset(max_run, 0, MAX_LEVEL + 1);
718 memset(index_run, rl->n, MAX_RUN + 1);
719 for(i=start;i<end;i++) {
720 run = rl->table_run[i];
721 level = rl->table_level[i];
722 if (index_run[run] == rl->n)
724 if (level > max_level[run])
725 max_level[run] = level;
726 if (run > max_run[level])
727 max_run[level] = run;
730 rl->max_level[last] = static_store[last];
732 rl->max_level[last] = av_malloc(MAX_RUN + 1);
733 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
735 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
737 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
738 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
740 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
742 rl->index_run[last] = av_malloc(MAX_RUN + 1);
743 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
747 void init_vlc_rl(RLTable *rl, int use_static)
751 /* Return if static table is already initialized */
752 if(use_static && rl->rl_vlc[0])
755 init_vlc(&rl->vlc, 9, rl->n + 1,
756 &rl->table_vlc[0][1], 4, 2,
757 &rl->table_vlc[0][0], 4, 2, use_static);
769 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
771 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
772 for(i=0; i<rl->vlc.table_size; i++){
773 int code= rl->vlc.table[i][0];
774 int len = rl->vlc.table[i][1];
777 if(len==0){ // illegal code
780 }else if(len<0){ //more bits needed
784 if(code==rl->n){ //esc
788 run= rl->table_run [code] + 1;
789 level= rl->table_level[code] * qmul + qadd;
790 if(code >= rl->last) run+=192;
793 rl->rl_vlc[q][i].len= len;
794 rl->rl_vlc[q][i].level= level;
795 rl->rl_vlc[q][i].run= run;
800 /* draw the edges of width 'w' of an image of size width, height */
801 //FIXME check that this is ok for mpeg4 interlaced
802 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
804 uint8_t *ptr, *last_line;
807 last_line = buf + (height - 1) * wrap;
810 memcpy(buf - (i + 1) * wrap, buf, width);
811 memcpy(last_line + (i + 1) * wrap, last_line, width);
815 for(i=0;i<height;i++) {
816 memset(ptr - w, ptr[0], w);
817 memset(ptr + width, ptr[width-1], w);
822 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
823 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
824 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
825 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
829 int ff_find_unused_picture(MpegEncContext *s, int shared){
833 for(i=0; i<MAX_PICTURE_COUNT; i++){
834 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
837 for(i=0; i<MAX_PICTURE_COUNT; i++){
838 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
840 for(i=0; i<MAX_PICTURE_COUNT; i++){
841 if(s->picture[i].data[0]==NULL) return i;
849 static void update_noise_reduction(MpegEncContext *s){
852 for(intra=0; intra<2; intra++){
853 if(s->dct_count[intra] > (1<<16)){
855 s->dct_error_sum[intra][i] >>=1;
857 s->dct_count[intra] >>= 1;
861 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);
867 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
869 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
875 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
877 /* mark&release old frames */
878 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
879 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
880 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
882 /* release forgotten pictures */
883 /* if(mpeg124/h263) */
885 for(i=0; i<MAX_PICTURE_COUNT; i++){
886 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
887 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
888 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
896 /* release non reference frames */
897 for(i=0; i<MAX_PICTURE_COUNT; i++){
898 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
899 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
903 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
904 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
906 i= ff_find_unused_picture(s, 0);
907 pic= (AVFrame*)&s->picture[i];
912 if (s->codec_id == CODEC_ID_H264)
913 pic->reference = s->picture_structure;
914 else if (s->pict_type != B_TYPE)
918 pic->coded_picture_number= s->coded_picture_number++;
920 if( alloc_picture(s, (Picture*)pic, 0) < 0)
923 s->current_picture_ptr= (Picture*)pic;
924 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
925 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
928 s->current_picture_ptr->pict_type= s->pict_type;
929 // if(s->flags && CODEC_FLAG_QSCALE)
930 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
931 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
933 copy_picture(&s->current_picture, s->current_picture_ptr);
935 if (s->pict_type != B_TYPE) {
936 s->last_picture_ptr= s->next_picture_ptr;
938 s->next_picture_ptr= s->current_picture_ptr;
940 /* 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,
941 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
942 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
943 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
944 s->pict_type, s->dropable);*/
946 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
947 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
949 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
950 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
951 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
955 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
957 if(s->picture_structure!=PICT_FRAME){
960 if(s->picture_structure == PICT_BOTTOM_FIELD){
961 s->current_picture.data[i] += s->current_picture.linesize[i];
963 s->current_picture.linesize[i] *= 2;
964 s->last_picture.linesize[i] *=2;
965 s->next_picture.linesize[i] *=2;
969 s->hurry_up= s->avctx->hurry_up;
970 s->error_resilience= avctx->error_resilience;
972 /* set dequantizer, we can't do it during init as it might change for mpeg4
973 and we can't do it in the header decode as init is not called for mpeg4 there yet */
974 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
975 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
976 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
977 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
978 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
979 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
981 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
982 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
985 if(s->dct_error_sum){
986 assert(s->avctx->noise_reduction && s->encoding);
988 update_noise_reduction(s);
992 if(s->avctx->xvmc_acceleration)
993 return XVMC_field_start(s, avctx);
998 /* generic function for encode/decode called after a frame has been coded/decoded */
999 void MPV_frame_end(MpegEncContext *s)
1002 /* draw edge for correct motion prediction if outside */
1004 //just to make sure that all data is rendered.
1005 if(s->avctx->xvmc_acceleration){
1009 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1010 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1011 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1012 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1016 s->last_pict_type = s->pict_type;
1017 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1018 if(s->pict_type!=B_TYPE){
1019 s->last_non_b_pict_type= s->pict_type;
1022 /* copy back current_picture variables */
1023 for(i=0; i<MAX_PICTURE_COUNT; i++){
1024 if(s->picture[i].data[0] == s->current_picture.data[0]){
1025 s->picture[i]= s->current_picture;
1029 assert(i<MAX_PICTURE_COUNT);
1033 /* release non-reference frames */
1034 for(i=0; i<MAX_PICTURE_COUNT; i++){
1035 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1036 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1040 // clear copies, to avoid confusion
1042 memset(&s->last_picture, 0, sizeof(Picture));
1043 memset(&s->next_picture, 0, sizeof(Picture));
1044 memset(&s->current_picture, 0, sizeof(Picture));
1046 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1050 * draws an line from (ex, ey) -> (sx, sy).
1051 * @param w width of the image
1052 * @param h height of the image
1053 * @param stride stride/linesize of the image
1054 * @param color color of the arrow
1056 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1059 sx= av_clip(sx, 0, w-1);
1060 sy= av_clip(sy, 0, h-1);
1061 ex= av_clip(ex, 0, w-1);
1062 ey= av_clip(ey, 0, h-1);
1064 buf[sy*stride + sx]+= color;
1066 if(FFABS(ex - sx) > FFABS(ey - sy)){
1068 FFSWAP(int, sx, ex);
1069 FFSWAP(int, sy, ey);
1071 buf+= sx + sy*stride;
1073 f= ((ey-sy)<<16)/ex;
1074 for(x= 0; x <= ex; x++){
1077 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1078 buf[(y+1)*stride + x]+= (color* fr )>>16;
1082 FFSWAP(int, sx, ex);
1083 FFSWAP(int, sy, ey);
1085 buf+= sx + sy*stride;
1087 if(ey) f= ((ex-sx)<<16)/ey;
1089 for(y= 0; y <= ey; y++){
1092 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1093 buf[y*stride + x+1]+= (color* fr )>>16;;
1099 * draws an arrow from (ex, ey) -> (sx, sy).
1100 * @param w width of the image
1101 * @param h height of the image
1102 * @param stride stride/linesize of the image
1103 * @param color color of the arrow
1105 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1108 sx= av_clip(sx, -100, w+100);
1109 sy= av_clip(sy, -100, h+100);
1110 ex= av_clip(ex, -100, w+100);
1111 ey= av_clip(ey, -100, h+100);
1116 if(dx*dx + dy*dy > 3*3){
1119 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1121 //FIXME subpixel accuracy
1122 rx= ROUNDED_DIV(rx*3<<4, length);
1123 ry= ROUNDED_DIV(ry*3<<4, length);
1125 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1126 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1128 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1132 * prints debuging info for the given picture.
1134 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1136 if(!pict || !pict->mb_type) return;
1138 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1141 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1142 switch (pict->pict_type) {
1143 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1144 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1145 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1146 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1147 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1148 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1150 for(y=0; y<s->mb_height; y++){
1151 for(x=0; x<s->mb_width; x++){
1152 if(s->avctx->debug&FF_DEBUG_SKIP){
1153 int count= s->mbskip_table[x + y*s->mb_stride];
1154 if(count>9) count=9;
1155 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1157 if(s->avctx->debug&FF_DEBUG_QP){
1158 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1160 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1161 int mb_type= pict->mb_type[x + y*s->mb_stride];
1162 //Type & MV direction
1164 av_log(s->avctx, AV_LOG_DEBUG, "P");
1165 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1166 av_log(s->avctx, AV_LOG_DEBUG, "A");
1167 else if(IS_INTRA4x4(mb_type))
1168 av_log(s->avctx, AV_LOG_DEBUG, "i");
1169 else if(IS_INTRA16x16(mb_type))
1170 av_log(s->avctx, AV_LOG_DEBUG, "I");
1171 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1172 av_log(s->avctx, AV_LOG_DEBUG, "d");
1173 else if(IS_DIRECT(mb_type))
1174 av_log(s->avctx, AV_LOG_DEBUG, "D");
1175 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1176 av_log(s->avctx, AV_LOG_DEBUG, "g");
1177 else if(IS_GMC(mb_type))
1178 av_log(s->avctx, AV_LOG_DEBUG, "G");
1179 else if(IS_SKIP(mb_type))
1180 av_log(s->avctx, AV_LOG_DEBUG, "S");
1181 else if(!USES_LIST(mb_type, 1))
1182 av_log(s->avctx, AV_LOG_DEBUG, ">");
1183 else if(!USES_LIST(mb_type, 0))
1184 av_log(s->avctx, AV_LOG_DEBUG, "<");
1186 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1187 av_log(s->avctx, AV_LOG_DEBUG, "X");
1192 av_log(s->avctx, AV_LOG_DEBUG, "+");
1193 else if(IS_16X8(mb_type))
1194 av_log(s->avctx, AV_LOG_DEBUG, "-");
1195 else if(IS_8X16(mb_type))
1196 av_log(s->avctx, AV_LOG_DEBUG, "|");
1197 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1198 av_log(s->avctx, AV_LOG_DEBUG, " ");
1200 av_log(s->avctx, AV_LOG_DEBUG, "?");
1203 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1204 av_log(s->avctx, AV_LOG_DEBUG, "=");
1206 av_log(s->avctx, AV_LOG_DEBUG, " ");
1208 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1210 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1214 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1215 const int shift= 1 + s->quarter_sample;
1219 int h_chroma_shift, v_chroma_shift;
1220 const int width = s->avctx->width;
1221 const int height= s->avctx->height;
1222 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1223 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1224 s->low_delay=0; //needed to see the vectors without trashing the buffers
1226 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1228 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1229 pict->data[i]= s->visualization_buffer[i];
1231 pict->type= FF_BUFFER_TYPE_COPY;
1234 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1236 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1237 const int mb_index= mb_x + mb_y*s->mb_stride;
1238 if((s->avctx->debug_mv) && pict->motion_val){
1240 for(type=0; type<3; type++){
1243 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1247 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1251 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1256 if(!USES_LIST(pict->mb_type[mb_index], direction))
1259 if(IS_8X8(pict->mb_type[mb_index])){
1262 int sx= mb_x*16 + 4 + 8*(i&1);
1263 int sy= mb_y*16 + 4 + 8*(i>>1);
1264 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1265 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1266 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1267 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1269 }else if(IS_16X8(pict->mb_type[mb_index])){
1273 int sy=mb_y*16 + 4 + 8*i;
1274 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1275 int mx=(pict->motion_val[direction][xy][0]>>shift);
1276 int my=(pict->motion_val[direction][xy][1]>>shift);
1278 if(IS_INTERLACED(pict->mb_type[mb_index]))
1281 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1283 }else if(IS_8X16(pict->mb_type[mb_index])){
1286 int sx=mb_x*16 + 4 + 8*i;
1288 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1289 int mx=(pict->motion_val[direction][xy][0]>>shift);
1290 int my=(pict->motion_val[direction][xy][1]>>shift);
1292 if(IS_INTERLACED(pict->mb_type[mb_index]))
1295 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1298 int sx= mb_x*16 + 8;
1299 int sy= mb_y*16 + 8;
1300 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1301 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1302 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1303 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1307 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1308 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1311 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1312 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1315 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1316 int mb_type= pict->mb_type[mb_index];
1319 #define COLOR(theta, r)\
1320 u= (int)(128 + r*cos(theta*3.141592/180));\
1321 v= (int)(128 + r*sin(theta*3.141592/180));
1325 if(IS_PCM(mb_type)){
1327 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1329 }else if(IS_INTRA4x4(mb_type)){
1331 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1333 }else if(IS_DIRECT(mb_type)){
1335 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1337 }else if(IS_GMC(mb_type)){
1339 }else if(IS_SKIP(mb_type)){
1341 }else if(!USES_LIST(mb_type, 1)){
1343 }else if(!USES_LIST(mb_type, 0)){
1346 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1350 u*= 0x0101010101010101ULL;
1351 v*= 0x0101010101010101ULL;
1353 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1354 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1358 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1359 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1360 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1362 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1364 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1366 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1367 int dm= 1 << (mv_sample_log2-2);
1369 int sx= mb_x*16 + 8*(i&1);
1370 int sy= mb_y*16 + 8*(i>>1);
1371 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1373 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1374 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1376 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1377 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1378 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1382 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1386 s->mbskip_table[mb_index]=0;
1393 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1394 * @param buf destination buffer
1395 * @param src source buffer
1396 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1397 * @param block_w width of block
1398 * @param block_h height of block
1399 * @param src_x x coordinate of the top left sample of the block in the source buffer
1400 * @param src_y y coordinate of the top left sample of the block in the source buffer
1401 * @param w width of the source buffer
1402 * @param h height of the source buffer
1404 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1405 int src_x, int src_y, int w, int h){
1407 int start_y, start_x, end_y, end_x;
1410 src+= (h-1-src_y)*linesize;
1412 }else if(src_y<=-block_h){
1413 src+= (1-block_h-src_y)*linesize;
1419 }else if(src_x<=-block_w){
1420 src+= (1-block_w-src_x);
1424 start_y= FFMAX(0, -src_y);
1425 start_x= FFMAX(0, -src_x);
1426 end_y= FFMIN(block_h, h-src_y);
1427 end_x= FFMIN(block_w, w-src_x);
1429 // copy existing part
1430 for(y=start_y; y<end_y; y++){
1431 for(x=start_x; x<end_x; x++){
1432 buf[x + y*linesize]= src[x + y*linesize];
1437 for(y=0; y<start_y; y++){
1438 for(x=start_x; x<end_x; x++){
1439 buf[x + y*linesize]= buf[x + start_y*linesize];
1444 for(y=end_y; y<block_h; y++){
1445 for(x=start_x; x<end_x; x++){
1446 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1450 for(y=0; y<block_h; y++){
1452 for(x=0; x<start_x; x++){
1453 buf[x + y*linesize]= buf[start_x + y*linesize];
1457 for(x=end_x; x<block_w; x++){
1458 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1463 static inline int hpel_motion_lowres(MpegEncContext *s,
1464 uint8_t *dest, uint8_t *src,
1465 int field_based, int field_select,
1466 int src_x, int src_y,
1467 int width, int height, int stride,
1468 int h_edge_pos, int v_edge_pos,
1469 int w, int h, h264_chroma_mc_func *pix_op,
1470 int motion_x, int motion_y)
1472 const int lowres= s->avctx->lowres;
1473 const int s_mask= (2<<lowres)-1;
1477 if(s->quarter_sample){
1482 sx= motion_x & s_mask;
1483 sy= motion_y & s_mask;
1484 src_x += motion_x >> (lowres+1);
1485 src_y += motion_y >> (lowres+1);
1487 src += src_y * stride + src_x;
1489 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1490 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1491 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1492 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1493 src= s->edge_emu_buffer;
1501 pix_op[lowres](dest, src, stride, h, sx, sy);
1505 /* apply one mpeg motion vector to the three components */
1506 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1507 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1508 int field_based, int bottom_field, int field_select,
1509 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1510 int motion_x, int motion_y, int h)
1512 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1513 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1514 const int lowres= s->avctx->lowres;
1515 const int block_s= 8>>lowres;
1516 const int s_mask= (2<<lowres)-1;
1517 const int h_edge_pos = s->h_edge_pos >> lowres;
1518 const int v_edge_pos = s->v_edge_pos >> lowres;
1519 linesize = s->current_picture.linesize[0] << field_based;
1520 uvlinesize = s->current_picture.linesize[1] << field_based;
1522 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1528 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1531 sx= motion_x & s_mask;
1532 sy= motion_y & s_mask;
1533 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1534 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1536 if (s->out_format == FMT_H263) {
1537 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1538 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1541 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1544 uvsx = (2*mx) & s_mask;
1545 uvsy = (2*my) & s_mask;
1546 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1547 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1553 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1554 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1557 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1558 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1559 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1561 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1562 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1563 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1564 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1565 ptr_y = s->edge_emu_buffer;
1566 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1567 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1568 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1569 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1570 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1571 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1577 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1578 dest_y += s->linesize;
1579 dest_cb+= s->uvlinesize;
1580 dest_cr+= s->uvlinesize;
1584 ptr_y += s->linesize;
1585 ptr_cb+= s->uvlinesize;
1586 ptr_cr+= s->uvlinesize;
1591 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1593 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1594 uvsx <<= 2 - lowres;
1595 uvsy <<= 2 - lowres;
1596 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1597 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1599 //FIXME h261 lowres loop filter
1602 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1603 uint8_t *dest_cb, uint8_t *dest_cr,
1604 uint8_t **ref_picture,
1605 h264_chroma_mc_func *pix_op,
1607 const int lowres= s->avctx->lowres;
1608 const int block_s= 8>>lowres;
1609 const int s_mask= (2<<lowres)-1;
1610 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1611 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1612 int emu=0, src_x, src_y, offset, sx, sy;
1615 if(s->quarter_sample){
1620 /* In case of 8X8, we construct a single chroma motion vector
1621 with a special rounding */
1622 mx= ff_h263_round_chroma(mx);
1623 my= ff_h263_round_chroma(my);
1627 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1628 src_y = s->mb_y*block_s + (my >> (lowres+1));
1630 offset = src_y * s->uvlinesize + src_x;
1631 ptr = ref_picture[1] + offset;
1632 if(s->flags&CODEC_FLAG_EMU_EDGE){
1633 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1634 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1635 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1636 ptr= s->edge_emu_buffer;
1642 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1644 ptr = ref_picture[2] + offset;
1646 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1647 ptr= s->edge_emu_buffer;
1649 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1653 * motion compensation of a single macroblock
1655 * @param dest_y luma destination pointer
1656 * @param dest_cb chroma cb/u destination pointer
1657 * @param dest_cr chroma cr/v destination pointer
1658 * @param dir direction (0->forward, 1->backward)
1659 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1660 * @param pic_op halfpel motion compensation function (average or put normally)
1661 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1663 static inline void MPV_motion_lowres(MpegEncContext *s,
1664 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1665 int dir, uint8_t **ref_picture,
1666 h264_chroma_mc_func *pix_op)
1670 const int lowres= s->avctx->lowres;
1671 const int block_s= 8>>lowres;
1676 switch(s->mv_type) {
1678 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1680 ref_picture, pix_op,
1681 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1687 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1688 ref_picture[0], 0, 0,
1689 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1690 s->width, s->height, s->linesize,
1691 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1692 block_s, block_s, pix_op,
1693 s->mv[dir][i][0], s->mv[dir][i][1]);
1695 mx += s->mv[dir][i][0];
1696 my += s->mv[dir][i][1];
1699 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1700 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1703 if (s->picture_structure == PICT_FRAME) {
1705 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1706 1, 0, s->field_select[dir][0],
1707 ref_picture, pix_op,
1708 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1710 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1711 1, 1, s->field_select[dir][1],
1712 ref_picture, pix_op,
1713 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1715 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
1716 ref_picture= s->current_picture_ptr->data;
1719 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1720 0, 0, s->field_select[dir][0],
1721 ref_picture, pix_op,
1722 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1727 uint8_t ** ref2picture;
1729 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
1730 ref2picture= ref_picture;
1732 ref2picture= s->current_picture_ptr->data;
1735 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1736 0, 0, s->field_select[dir][i],
1737 ref2picture, pix_op,
1738 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1740 dest_y += 2*block_s*s->linesize;
1741 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1742 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1746 if(s->picture_structure == PICT_FRAME){
1750 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1752 ref_picture, pix_op,
1753 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1755 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1759 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1760 0, 0, s->picture_structure != i+1,
1761 ref_picture, pix_op,
1762 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1764 // after put we make avg of the same block
1765 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1767 //opposite parity is always in the same frame if this is second field
1768 if(!s->first_field){
1769 ref_picture = s->current_picture_ptr->data;
1778 /* put block[] to dest[] */
1779 static inline void put_dct(MpegEncContext *s,
1780 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1782 s->dct_unquantize_intra(s, block, i, qscale);
1783 s->dsp.idct_put (dest, line_size, block);
1786 /* add block[] to dest[] */
1787 static inline void add_dct(MpegEncContext *s,
1788 DCTELEM *block, int i, uint8_t *dest, int line_size)
1790 if (s->block_last_index[i] >= 0) {
1791 s->dsp.idct_add (dest, line_size, block);
1795 static inline void add_dequant_dct(MpegEncContext *s,
1796 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1798 if (s->block_last_index[i] >= 0) {
1799 s->dct_unquantize_inter(s, block, i, qscale);
1801 s->dsp.idct_add (dest, line_size, block);
1806 * cleans dc, ac, coded_block for the current non intra MB
1808 void ff_clean_intra_table_entries(MpegEncContext *s)
1810 int wrap = s->b8_stride;
1811 int xy = s->block_index[0];
1814 s->dc_val[0][xy + 1 ] =
1815 s->dc_val[0][xy + wrap] =
1816 s->dc_val[0][xy + 1 + wrap] = 1024;
1818 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1819 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1820 if (s->msmpeg4_version>=3) {
1821 s->coded_block[xy ] =
1822 s->coded_block[xy + 1 ] =
1823 s->coded_block[xy + wrap] =
1824 s->coded_block[xy + 1 + wrap] = 0;
1827 wrap = s->mb_stride;
1828 xy = s->mb_x + s->mb_y * wrap;
1830 s->dc_val[2][xy] = 1024;
1832 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1833 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1835 s->mbintra_table[xy]= 0;
1838 /* generic function called after a macroblock has been parsed by the
1839 decoder or after it has been encoded by the encoder.
1841 Important variables used:
1842 s->mb_intra : true if intra macroblock
1843 s->mv_dir : motion vector direction
1844 s->mv_type : motion vector type
1845 s->mv : motion vector
1846 s->interlaced_dct : true if interlaced dct used (mpeg2)
1848 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
1851 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1853 if(s->avctx->xvmc_acceleration){
1854 XVMC_decode_mb(s);//xvmc uses pblocks
1862 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1863 /* save DCT coefficients */
1865 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1868 *dct++ = block[i][s->dsp.idct_permutation[j]];
1871 s->current_picture.qscale_table[mb_xy]= s->qscale;
1873 /* update DC predictors for P macroblocks */
1875 if (s->h263_pred || s->h263_aic) {
1876 if(s->mbintra_table[mb_xy])
1877 ff_clean_intra_table_entries(s);
1881 s->last_dc[2] = 128 << s->intra_dc_precision;
1884 else if (s->h263_pred || s->h263_aic)
1885 s->mbintra_table[mb_xy]=1;
1887 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
1888 uint8_t *dest_y, *dest_cb, *dest_cr;
1889 int dct_linesize, dct_offset;
1890 op_pixels_func (*op_pix)[4];
1891 qpel_mc_func (*op_qpix)[16];
1892 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1893 const int uvlinesize= s->current_picture.linesize[1];
1894 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1895 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1897 /* avoid copy if macroblock skipped in last frame too */
1898 /* skip only during decoding as we might trash the buffers during encoding a bit */
1900 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1901 const int age= s->current_picture.age;
1905 if (s->mb_skipped) {
1907 assert(s->pict_type!=I_TYPE);
1909 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1910 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1912 /* if previous was skipped too, then nothing to do ! */
1913 if (*mbskip_ptr >= age && s->current_picture.reference){
1916 } else if(!s->current_picture.reference){
1917 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1918 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1920 *mbskip_ptr = 0; /* not skipped */
1924 dct_linesize = linesize << s->interlaced_dct;
1925 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1929 dest_cb= s->dest[1];
1930 dest_cr= s->dest[2];
1932 dest_y = s->b_scratchpad;
1933 dest_cb= s->b_scratchpad+16*linesize;
1934 dest_cr= s->b_scratchpad+32*linesize;
1938 /* motion handling */
1939 /* decoding or more than one mb_type (MC was already done otherwise) */
1942 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1944 if (s->mv_dir & MV_DIR_FORWARD) {
1945 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1946 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1948 if (s->mv_dir & MV_DIR_BACKWARD) {
1949 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1952 op_qpix= s->me.qpel_put;
1953 if ((!s->no_rounding) || s->pict_type==B_TYPE){
1954 op_pix = s->dsp.put_pixels_tab;
1956 op_pix = s->dsp.put_no_rnd_pixels_tab;
1958 if (s->mv_dir & MV_DIR_FORWARD) {
1959 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1960 op_pix = s->dsp.avg_pixels_tab;
1961 op_qpix= s->me.qpel_avg;
1963 if (s->mv_dir & MV_DIR_BACKWARD) {
1964 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1969 /* skip dequant / idct if we are really late ;) */
1970 if(s->hurry_up>1) goto skip_idct;
1971 if(s->avctx->skip_idct){
1972 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
1973 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
1974 || s->avctx->skip_idct >= AVDISCARD_ALL)
1978 /* add dct residue */
1979 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1980 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1981 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1982 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1983 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1984 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1986 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1987 if (s->chroma_y_shift){
1988 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1989 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1993 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1994 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1995 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1996 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1999 } else if(s->codec_id != CODEC_ID_WMV2){
2000 add_dct(s, block[0], 0, dest_y , dct_linesize);
2001 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2002 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2003 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2005 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2006 if(s->chroma_y_shift){//Chroma420
2007 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2008 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2011 dct_linesize = uvlinesize << s->interlaced_dct;
2012 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2014 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2015 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2016 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2017 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2018 if(!s->chroma_x_shift){//Chroma444
2019 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2020 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2021 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2022 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2027 else if (ENABLE_WMV2) {
2028 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2031 /* dct only in intra block */
2032 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2033 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2034 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2035 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2036 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2038 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2039 if(s->chroma_y_shift){
2040 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2041 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2045 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2046 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2047 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2048 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2052 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2053 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2054 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2055 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2057 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2058 if(s->chroma_y_shift){
2059 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2060 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2063 dct_linesize = uvlinesize << s->interlaced_dct;
2064 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2066 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2067 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2068 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2069 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2070 if(!s->chroma_x_shift){//Chroma444
2071 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2072 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2073 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2074 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2082 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2083 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2084 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2089 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2090 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
2091 else MPV_decode_mb_internal(s, block, 0);
2096 * @param h is the normal height, this will be reduced automatically if needed for the last row
2098 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2099 if (s->avctx->draw_horiz_band) {
2103 if(s->picture_structure != PICT_FRAME){
2106 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2109 h= FFMIN(h, s->avctx->height - y);
2111 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2112 src= (AVFrame*)s->current_picture_ptr;
2113 else if(s->last_picture_ptr)
2114 src= (AVFrame*)s->last_picture_ptr;
2118 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2124 offset[0]= y * s->linesize;;
2126 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2132 s->avctx->draw_horiz_band(s->avctx, src, offset,
2133 y, s->picture_structure, h);
2137 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2138 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2139 const int uvlinesize= s->current_picture.linesize[1];
2140 const int mb_size= 4 - s->avctx->lowres;
2142 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2143 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2144 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2145 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2146 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2147 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;
2148 //block_index is not used by mpeg2, so it is not affected by chroma_format
2150 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2151 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2152 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2154 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2156 s->dest[0] += s->mb_y * linesize << mb_size;
2157 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2158 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2162 void ff_mpeg_flush(AVCodecContext *avctx){
2164 MpegEncContext *s = avctx->priv_data;
2166 if(s==NULL || s->picture==NULL)
2169 for(i=0; i<MAX_PICTURE_COUNT; i++){
2170 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2171 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2172 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2174 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2176 s->mb_x= s->mb_y= 0;
2178 s->parse_context.state= -1;
2179 s->parse_context.frame_start_found= 0;
2180 s->parse_context.overread= 0;
2181 s->parse_context.overread_index= 0;
2182 s->parse_context.index= 0;
2183 s->parse_context.last_index= 0;
2184 s->bitstream_buffer_size=0;
2188 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2189 DCTELEM *block, int n, int qscale)
2191 int i, level, nCoeffs;
2192 const uint16_t *quant_matrix;
2194 nCoeffs= s->block_last_index[n];
2197 block[0] = block[0] * s->y_dc_scale;
2199 block[0] = block[0] * s->c_dc_scale;
2200 /* XXX: only mpeg1 */
2201 quant_matrix = s->intra_matrix;
2202 for(i=1;i<=nCoeffs;i++) {
2203 int j= s->intra_scantable.permutated[i];
2208 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2209 level = (level - 1) | 1;
2212 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2213 level = (level - 1) | 1;
2220 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2221 DCTELEM *block, int n, int qscale)
2223 int i, level, nCoeffs;
2224 const uint16_t *quant_matrix;
2226 nCoeffs= s->block_last_index[n];
2228 quant_matrix = s->inter_matrix;
2229 for(i=0; i<=nCoeffs; i++) {
2230 int j= s->intra_scantable.permutated[i];
2235 level = (((level << 1) + 1) * qscale *
2236 ((int) (quant_matrix[j]))) >> 4;
2237 level = (level - 1) | 1;
2240 level = (((level << 1) + 1) * qscale *
2241 ((int) (quant_matrix[j]))) >> 4;
2242 level = (level - 1) | 1;
2249 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2250 DCTELEM *block, int n, int qscale)
2252 int i, level, nCoeffs;
2253 const uint16_t *quant_matrix;
2255 if(s->alternate_scan) nCoeffs= 63;
2256 else nCoeffs= s->block_last_index[n];
2259 block[0] = block[0] * s->y_dc_scale;
2261 block[0] = block[0] * s->c_dc_scale;
2262 quant_matrix = s->intra_matrix;
2263 for(i=1;i<=nCoeffs;i++) {
2264 int j= s->intra_scantable.permutated[i];
2269 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2272 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2279 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2280 DCTELEM *block, int n, int qscale)
2282 int i, level, nCoeffs;
2283 const uint16_t *quant_matrix;
2286 if(s->alternate_scan) nCoeffs= 63;
2287 else nCoeffs= s->block_last_index[n];
2290 block[0] = block[0] * s->y_dc_scale;
2292 block[0] = block[0] * s->c_dc_scale;
2293 quant_matrix = s->intra_matrix;
2294 for(i=1;i<=nCoeffs;i++) {
2295 int j= s->intra_scantable.permutated[i];
2300 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2303 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2312 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2313 DCTELEM *block, int n, int qscale)
2315 int i, level, nCoeffs;
2316 const uint16_t *quant_matrix;
2319 if(s->alternate_scan) nCoeffs= 63;
2320 else nCoeffs= s->block_last_index[n];
2322 quant_matrix = s->inter_matrix;
2323 for(i=0; i<=nCoeffs; i++) {
2324 int j= s->intra_scantable.permutated[i];
2329 level = (((level << 1) + 1) * qscale *
2330 ((int) (quant_matrix[j]))) >> 4;
2333 level = (((level << 1) + 1) * qscale *
2334 ((int) (quant_matrix[j]))) >> 4;
2343 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2344 DCTELEM *block, int n, int qscale)
2346 int i, level, qmul, qadd;
2349 assert(s->block_last_index[n]>=0);
2355 block[0] = block[0] * s->y_dc_scale;
2357 block[0] = block[0] * s->c_dc_scale;
2358 qadd = (qscale - 1) | 1;
2365 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2367 for(i=1; i<=nCoeffs; i++) {
2371 level = level * qmul - qadd;
2373 level = level * qmul + qadd;
2380 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2381 DCTELEM *block, int n, int qscale)
2383 int i, level, qmul, qadd;
2386 assert(s->block_last_index[n]>=0);
2388 qadd = (qscale - 1) | 1;
2391 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2393 for(i=0; i<=nCoeffs; i++) {
2397 level = level * qmul - qadd;
2399 level = level * qmul + qadd;
2407 * set qscale and update qscale dependent variables.
2409 void ff_set_qscale(MpegEncContext * s, int qscale)
2413 else if (qscale > 31)
2417 s->chroma_qscale= s->chroma_qscale_table[qscale];
2419 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2420 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];