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 + s->mb_stride) * sizeof(uint32_t))
233 pic->mb_type= pic->mb_type_base + 2*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;
845 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
846 /* We could return -1, but the codec would crash trying to draw into a
847 * non-existing frame anyway. This is safer than waiting for a random crash.
848 * Also the return of this is never useful, an encoder must only allocate
849 * as much as allowed in the specification. This has no relationship to how
850 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
851 * enough for such valid streams).
852 * Plus, a decoder has to check stream validity and remove frames if too
853 * many reference frames are around. Waiting for "OOM" is not correct at
854 * all. Similarly, missing reference frames have to be replaced by
855 * interpolated/MC frames, anything else is a bug in the codec ...
861 static void update_noise_reduction(MpegEncContext *s){
864 for(intra=0; intra<2; intra++){
865 if(s->dct_count[intra] > (1<<16)){
867 s->dct_error_sum[intra][i] >>=1;
869 s->dct_count[intra] >>= 1;
873 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);
879 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
881 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
887 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
889 /* mark&release old frames */
890 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
891 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
892 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
894 /* release forgotten pictures */
895 /* if(mpeg124/h263) */
897 for(i=0; i<MAX_PICTURE_COUNT; i++){
898 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
899 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
900 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
908 /* release non reference frames */
909 for(i=0; i<MAX_PICTURE_COUNT; i++){
910 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
911 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
915 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
916 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
918 i= ff_find_unused_picture(s, 0);
919 pic= (AVFrame*)&s->picture[i];
924 if (s->codec_id == CODEC_ID_H264)
925 pic->reference = s->picture_structure;
926 else if (s->pict_type != B_TYPE)
930 pic->coded_picture_number= s->coded_picture_number++;
932 if( alloc_picture(s, (Picture*)pic, 0) < 0)
935 s->current_picture_ptr= (Picture*)pic;
936 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
937 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
940 s->current_picture_ptr->pict_type= s->pict_type;
941 // if(s->flags && CODEC_FLAG_QSCALE)
942 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
943 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
945 copy_picture(&s->current_picture, s->current_picture_ptr);
947 if (s->pict_type != B_TYPE) {
948 s->last_picture_ptr= s->next_picture_ptr;
950 s->next_picture_ptr= s->current_picture_ptr;
952 /* 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,
953 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
954 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
955 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
956 s->pict_type, s->dropable);*/
958 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
959 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
961 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
962 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
963 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
967 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
969 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
972 if(s->picture_structure == PICT_BOTTOM_FIELD){
973 s->current_picture.data[i] += s->current_picture.linesize[i];
975 s->current_picture.linesize[i] *= 2;
976 s->last_picture.linesize[i] *=2;
977 s->next_picture.linesize[i] *=2;
981 s->hurry_up= s->avctx->hurry_up;
982 s->error_resilience= avctx->error_resilience;
984 /* set dequantizer, we can't do it during init as it might change for mpeg4
985 and we can't do it in the header decode as init is not called for mpeg4 there yet */
986 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
987 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
988 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
989 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
990 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
991 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
993 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
994 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
997 if(s->dct_error_sum){
998 assert(s->avctx->noise_reduction && s->encoding);
1000 update_noise_reduction(s);
1004 if(s->avctx->xvmc_acceleration)
1005 return XVMC_field_start(s, avctx);
1010 /* generic function for encode/decode called after a frame has been coded/decoded */
1011 void MPV_frame_end(MpegEncContext *s)
1014 /* draw edge for correct motion prediction if outside */
1016 //just to make sure that all data is rendered.
1017 if(s->avctx->xvmc_acceleration){
1021 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1022 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1023 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1024 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1028 s->last_pict_type = s->pict_type;
1029 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1030 if(s->pict_type!=B_TYPE){
1031 s->last_non_b_pict_type= s->pict_type;
1034 /* copy back current_picture variables */
1035 for(i=0; i<MAX_PICTURE_COUNT; i++){
1036 if(s->picture[i].data[0] == s->current_picture.data[0]){
1037 s->picture[i]= s->current_picture;
1041 assert(i<MAX_PICTURE_COUNT);
1045 /* release non-reference frames */
1046 for(i=0; i<MAX_PICTURE_COUNT; i++){
1047 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1048 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1052 // clear copies, to avoid confusion
1054 memset(&s->last_picture, 0, sizeof(Picture));
1055 memset(&s->next_picture, 0, sizeof(Picture));
1056 memset(&s->current_picture, 0, sizeof(Picture));
1058 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1062 * draws an line from (ex, ey) -> (sx, sy).
1063 * @param w width of the image
1064 * @param h height of the image
1065 * @param stride stride/linesize of the image
1066 * @param color color of the arrow
1068 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1071 sx= av_clip(sx, 0, w-1);
1072 sy= av_clip(sy, 0, h-1);
1073 ex= av_clip(ex, 0, w-1);
1074 ey= av_clip(ey, 0, h-1);
1076 buf[sy*stride + sx]+= color;
1078 if(FFABS(ex - sx) > FFABS(ey - sy)){
1080 FFSWAP(int, sx, ex);
1081 FFSWAP(int, sy, ey);
1083 buf+= sx + sy*stride;
1085 f= ((ey-sy)<<16)/ex;
1086 for(x= 0; x <= ex; x++){
1089 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1090 buf[(y+1)*stride + x]+= (color* fr )>>16;
1094 FFSWAP(int, sx, ex);
1095 FFSWAP(int, sy, ey);
1097 buf+= sx + sy*stride;
1099 if(ey) f= ((ex-sx)<<16)/ey;
1101 for(y= 0; y <= ey; y++){
1104 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1105 buf[y*stride + x+1]+= (color* fr )>>16;;
1111 * draws an arrow from (ex, ey) -> (sx, sy).
1112 * @param w width of the image
1113 * @param h height of the image
1114 * @param stride stride/linesize of the image
1115 * @param color color of the arrow
1117 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1120 sx= av_clip(sx, -100, w+100);
1121 sy= av_clip(sy, -100, h+100);
1122 ex= av_clip(ex, -100, w+100);
1123 ey= av_clip(ey, -100, h+100);
1128 if(dx*dx + dy*dy > 3*3){
1131 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1133 //FIXME subpixel accuracy
1134 rx= ROUNDED_DIV(rx*3<<4, length);
1135 ry= ROUNDED_DIV(ry*3<<4, length);
1137 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1138 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1140 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1144 * prints debuging info for the given picture.
1146 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1148 if(!pict || !pict->mb_type) return;
1150 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1153 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1154 switch (pict->pict_type) {
1155 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1156 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1157 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1158 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1159 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1160 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1162 for(y=0; y<s->mb_height; y++){
1163 for(x=0; x<s->mb_width; x++){
1164 if(s->avctx->debug&FF_DEBUG_SKIP){
1165 int count= s->mbskip_table[x + y*s->mb_stride];
1166 if(count>9) count=9;
1167 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1169 if(s->avctx->debug&FF_DEBUG_QP){
1170 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1172 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1173 int mb_type= pict->mb_type[x + y*s->mb_stride];
1174 //Type & MV direction
1176 av_log(s->avctx, AV_LOG_DEBUG, "P");
1177 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1178 av_log(s->avctx, AV_LOG_DEBUG, "A");
1179 else if(IS_INTRA4x4(mb_type))
1180 av_log(s->avctx, AV_LOG_DEBUG, "i");
1181 else if(IS_INTRA16x16(mb_type))
1182 av_log(s->avctx, AV_LOG_DEBUG, "I");
1183 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1184 av_log(s->avctx, AV_LOG_DEBUG, "d");
1185 else if(IS_DIRECT(mb_type))
1186 av_log(s->avctx, AV_LOG_DEBUG, "D");
1187 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1188 av_log(s->avctx, AV_LOG_DEBUG, "g");
1189 else if(IS_GMC(mb_type))
1190 av_log(s->avctx, AV_LOG_DEBUG, "G");
1191 else if(IS_SKIP(mb_type))
1192 av_log(s->avctx, AV_LOG_DEBUG, "S");
1193 else if(!USES_LIST(mb_type, 1))
1194 av_log(s->avctx, AV_LOG_DEBUG, ">");
1195 else if(!USES_LIST(mb_type, 0))
1196 av_log(s->avctx, AV_LOG_DEBUG, "<");
1198 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1199 av_log(s->avctx, AV_LOG_DEBUG, "X");
1204 av_log(s->avctx, AV_LOG_DEBUG, "+");
1205 else if(IS_16X8(mb_type))
1206 av_log(s->avctx, AV_LOG_DEBUG, "-");
1207 else if(IS_8X16(mb_type))
1208 av_log(s->avctx, AV_LOG_DEBUG, "|");
1209 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1210 av_log(s->avctx, AV_LOG_DEBUG, " ");
1212 av_log(s->avctx, AV_LOG_DEBUG, "?");
1215 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1216 av_log(s->avctx, AV_LOG_DEBUG, "=");
1218 av_log(s->avctx, AV_LOG_DEBUG, " ");
1220 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1222 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1226 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1227 const int shift= 1 + s->quarter_sample;
1231 int h_chroma_shift, v_chroma_shift;
1232 const int width = s->avctx->width;
1233 const int height= s->avctx->height;
1234 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1235 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1236 s->low_delay=0; //needed to see the vectors without trashing the buffers
1238 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1240 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1241 pict->data[i]= s->visualization_buffer[i];
1243 pict->type= FF_BUFFER_TYPE_COPY;
1246 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1248 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1249 const int mb_index= mb_x + mb_y*s->mb_stride;
1250 if((s->avctx->debug_mv) && pict->motion_val){
1252 for(type=0; type<3; type++){
1255 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1259 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1263 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1268 if(!USES_LIST(pict->mb_type[mb_index], direction))
1271 if(IS_8X8(pict->mb_type[mb_index])){
1274 int sx= mb_x*16 + 4 + 8*(i&1);
1275 int sy= mb_y*16 + 4 + 8*(i>>1);
1276 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1277 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1278 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1279 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1281 }else if(IS_16X8(pict->mb_type[mb_index])){
1285 int sy=mb_y*16 + 4 + 8*i;
1286 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1287 int mx=(pict->motion_val[direction][xy][0]>>shift);
1288 int my=(pict->motion_val[direction][xy][1]>>shift);
1290 if(IS_INTERLACED(pict->mb_type[mb_index]))
1293 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1295 }else if(IS_8X16(pict->mb_type[mb_index])){
1298 int sx=mb_x*16 + 4 + 8*i;
1300 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1301 int mx=(pict->motion_val[direction][xy][0]>>shift);
1302 int my=(pict->motion_val[direction][xy][1]>>shift);
1304 if(IS_INTERLACED(pict->mb_type[mb_index]))
1307 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1310 int sx= mb_x*16 + 8;
1311 int sy= mb_y*16 + 8;
1312 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1313 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1314 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1315 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1319 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1320 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1323 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1324 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1327 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1328 int mb_type= pict->mb_type[mb_index];
1331 #define COLOR(theta, r)\
1332 u= (int)(128 + r*cos(theta*3.141592/180));\
1333 v= (int)(128 + r*sin(theta*3.141592/180));
1337 if(IS_PCM(mb_type)){
1339 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1341 }else if(IS_INTRA4x4(mb_type)){
1343 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1345 }else if(IS_DIRECT(mb_type)){
1347 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1349 }else if(IS_GMC(mb_type)){
1351 }else if(IS_SKIP(mb_type)){
1353 }else if(!USES_LIST(mb_type, 1)){
1355 }else if(!USES_LIST(mb_type, 0)){
1358 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1362 u*= 0x0101010101010101ULL;
1363 v*= 0x0101010101010101ULL;
1365 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1366 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1370 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1371 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1372 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1374 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1376 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1378 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1379 int dm= 1 << (mv_sample_log2-2);
1381 int sx= mb_x*16 + 8*(i&1);
1382 int sy= mb_y*16 + 8*(i>>1);
1383 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1385 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1386 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1388 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1389 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1390 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1394 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1398 s->mbskip_table[mb_index]=0;
1405 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
1406 * @param buf destination buffer
1407 * @param src source buffer
1408 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
1409 * @param block_w width of block
1410 * @param block_h height of block
1411 * @param src_x x coordinate of the top left sample of the block in the source buffer
1412 * @param src_y y coordinate of the top left sample of the block in the source buffer
1413 * @param w width of the source buffer
1414 * @param h height of the source buffer
1416 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
1417 int src_x, int src_y, int w, int h){
1419 int start_y, start_x, end_y, end_x;
1422 src+= (h-1-src_y)*linesize;
1424 }else if(src_y<=-block_h){
1425 src+= (1-block_h-src_y)*linesize;
1431 }else if(src_x<=-block_w){
1432 src+= (1-block_w-src_x);
1436 start_y= FFMAX(0, -src_y);
1437 start_x= FFMAX(0, -src_x);
1438 end_y= FFMIN(block_h, h-src_y);
1439 end_x= FFMIN(block_w, w-src_x);
1441 // copy existing part
1442 for(y=start_y; y<end_y; y++){
1443 for(x=start_x; x<end_x; x++){
1444 buf[x + y*linesize]= src[x + y*linesize];
1449 for(y=0; y<start_y; y++){
1450 for(x=start_x; x<end_x; x++){
1451 buf[x + y*linesize]= buf[x + start_y*linesize];
1456 for(y=end_y; y<block_h; y++){
1457 for(x=start_x; x<end_x; x++){
1458 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
1462 for(y=0; y<block_h; y++){
1464 for(x=0; x<start_x; x++){
1465 buf[x + y*linesize]= buf[start_x + y*linesize];
1469 for(x=end_x; x<block_w; x++){
1470 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
1475 static inline int hpel_motion_lowres(MpegEncContext *s,
1476 uint8_t *dest, uint8_t *src,
1477 int field_based, int field_select,
1478 int src_x, int src_y,
1479 int width, int height, int stride,
1480 int h_edge_pos, int v_edge_pos,
1481 int w, int h, h264_chroma_mc_func *pix_op,
1482 int motion_x, int motion_y)
1484 const int lowres= s->avctx->lowres;
1485 const int s_mask= (2<<lowres)-1;
1489 if(s->quarter_sample){
1494 sx= motion_x & s_mask;
1495 sy= motion_y & s_mask;
1496 src_x += motion_x >> (lowres+1);
1497 src_y += motion_y >> (lowres+1);
1499 src += src_y * stride + src_x;
1501 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1502 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1503 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1504 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1505 src= s->edge_emu_buffer;
1513 pix_op[lowres](dest, src, stride, h, sx, sy);
1517 /* apply one mpeg motion vector to the three components */
1518 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1519 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1520 int field_based, int bottom_field, int field_select,
1521 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1522 int motion_x, int motion_y, int h)
1524 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1525 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1526 const int lowres= s->avctx->lowres;
1527 const int block_s= 8>>lowres;
1528 const int s_mask= (2<<lowres)-1;
1529 const int h_edge_pos = s->h_edge_pos >> lowres;
1530 const int v_edge_pos = s->v_edge_pos >> lowres;
1531 linesize = s->current_picture.linesize[0] << field_based;
1532 uvlinesize = s->current_picture.linesize[1] << field_based;
1534 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1540 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1543 sx= motion_x & s_mask;
1544 sy= motion_y & s_mask;
1545 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1546 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1548 if (s->out_format == FMT_H263) {
1549 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1550 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1553 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1556 uvsx = (2*mx) & s_mask;
1557 uvsy = (2*my) & s_mask;
1558 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1559 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1565 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1566 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1569 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1570 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1571 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1573 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1574 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1575 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1576 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1577 ptr_y = s->edge_emu_buffer;
1578 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1579 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1580 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1581 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1582 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1583 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1589 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1590 dest_y += s->linesize;
1591 dest_cb+= s->uvlinesize;
1592 dest_cr+= s->uvlinesize;
1596 ptr_y += s->linesize;
1597 ptr_cb+= s->uvlinesize;
1598 ptr_cr+= s->uvlinesize;
1603 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1605 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1606 uvsx <<= 2 - lowres;
1607 uvsy <<= 2 - lowres;
1608 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1609 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1611 //FIXME h261 lowres loop filter
1614 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1615 uint8_t *dest_cb, uint8_t *dest_cr,
1616 uint8_t **ref_picture,
1617 h264_chroma_mc_func *pix_op,
1619 const int lowres= s->avctx->lowres;
1620 const int block_s= 8>>lowres;
1621 const int s_mask= (2<<lowres)-1;
1622 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1623 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1624 int emu=0, src_x, src_y, offset, sx, sy;
1627 if(s->quarter_sample){
1632 /* In case of 8X8, we construct a single chroma motion vector
1633 with a special rounding */
1634 mx= ff_h263_round_chroma(mx);
1635 my= ff_h263_round_chroma(my);
1639 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1640 src_y = s->mb_y*block_s + (my >> (lowres+1));
1642 offset = src_y * s->uvlinesize + src_x;
1643 ptr = ref_picture[1] + offset;
1644 if(s->flags&CODEC_FLAG_EMU_EDGE){
1645 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1646 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1647 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1648 ptr= s->edge_emu_buffer;
1654 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1656 ptr = ref_picture[2] + offset;
1658 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1659 ptr= s->edge_emu_buffer;
1661 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1665 * motion compensation of a single macroblock
1667 * @param dest_y luma destination pointer
1668 * @param dest_cb chroma cb/u destination pointer
1669 * @param dest_cr chroma cr/v destination pointer
1670 * @param dir direction (0->forward, 1->backward)
1671 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1672 * @param pic_op halfpel motion compensation function (average or put normally)
1673 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1675 static inline void MPV_motion_lowres(MpegEncContext *s,
1676 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1677 int dir, uint8_t **ref_picture,
1678 h264_chroma_mc_func *pix_op)
1682 const int lowres= s->avctx->lowres;
1683 const int block_s= 8>>lowres;
1688 switch(s->mv_type) {
1690 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1692 ref_picture, pix_op,
1693 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1699 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1700 ref_picture[0], 0, 0,
1701 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1702 s->width, s->height, s->linesize,
1703 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1704 block_s, block_s, pix_op,
1705 s->mv[dir][i][0], s->mv[dir][i][1]);
1707 mx += s->mv[dir][i][0];
1708 my += s->mv[dir][i][1];
1711 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1712 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1715 if (s->picture_structure == PICT_FRAME) {
1717 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1718 1, 0, s->field_select[dir][0],
1719 ref_picture, pix_op,
1720 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1722 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1723 1, 1, s->field_select[dir][1],
1724 ref_picture, pix_op,
1725 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1727 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
1728 ref_picture= s->current_picture_ptr->data;
1731 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1732 0, 0, s->field_select[dir][0],
1733 ref_picture, pix_op,
1734 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1739 uint8_t ** ref2picture;
1741 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
1742 ref2picture= ref_picture;
1744 ref2picture= s->current_picture_ptr->data;
1747 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1748 0, 0, s->field_select[dir][i],
1749 ref2picture, pix_op,
1750 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1752 dest_y += 2*block_s*s->linesize;
1753 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1754 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1758 if(s->picture_structure == PICT_FRAME){
1762 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1764 ref_picture, pix_op,
1765 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1767 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1771 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1772 0, 0, s->picture_structure != i+1,
1773 ref_picture, pix_op,
1774 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1776 // after put we make avg of the same block
1777 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1779 //opposite parity is always in the same frame if this is second field
1780 if(!s->first_field){
1781 ref_picture = s->current_picture_ptr->data;
1790 /* put block[] to dest[] */
1791 static inline void put_dct(MpegEncContext *s,
1792 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1794 s->dct_unquantize_intra(s, block, i, qscale);
1795 s->dsp.idct_put (dest, line_size, block);
1798 /* add block[] to dest[] */
1799 static inline void add_dct(MpegEncContext *s,
1800 DCTELEM *block, int i, uint8_t *dest, int line_size)
1802 if (s->block_last_index[i] >= 0) {
1803 s->dsp.idct_add (dest, line_size, block);
1807 static inline void add_dequant_dct(MpegEncContext *s,
1808 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1810 if (s->block_last_index[i] >= 0) {
1811 s->dct_unquantize_inter(s, block, i, qscale);
1813 s->dsp.idct_add (dest, line_size, block);
1818 * cleans dc, ac, coded_block for the current non intra MB
1820 void ff_clean_intra_table_entries(MpegEncContext *s)
1822 int wrap = s->b8_stride;
1823 int xy = s->block_index[0];
1826 s->dc_val[0][xy + 1 ] =
1827 s->dc_val[0][xy + wrap] =
1828 s->dc_val[0][xy + 1 + wrap] = 1024;
1830 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1831 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1832 if (s->msmpeg4_version>=3) {
1833 s->coded_block[xy ] =
1834 s->coded_block[xy + 1 ] =
1835 s->coded_block[xy + wrap] =
1836 s->coded_block[xy + 1 + wrap] = 0;
1839 wrap = s->mb_stride;
1840 xy = s->mb_x + s->mb_y * wrap;
1842 s->dc_val[2][xy] = 1024;
1844 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1845 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1847 s->mbintra_table[xy]= 0;
1850 /* generic function called after a macroblock has been parsed by the
1851 decoder or after it has been encoded by the encoder.
1853 Important variables used:
1854 s->mb_intra : true if intra macroblock
1855 s->mv_dir : motion vector direction
1856 s->mv_type : motion vector type
1857 s->mv : motion vector
1858 s->interlaced_dct : true if interlaced dct used (mpeg2)
1860 static av_always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
1863 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1865 if(s->avctx->xvmc_acceleration){
1866 XVMC_decode_mb(s);//xvmc uses pblocks
1874 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1875 /* save DCT coefficients */
1877 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1880 *dct++ = block[i][s->dsp.idct_permutation[j]];
1883 s->current_picture.qscale_table[mb_xy]= s->qscale;
1885 /* update DC predictors for P macroblocks */
1887 if (s->h263_pred || s->h263_aic) {
1888 if(s->mbintra_table[mb_xy])
1889 ff_clean_intra_table_entries(s);
1893 s->last_dc[2] = 128 << s->intra_dc_precision;
1896 else if (s->h263_pred || s->h263_aic)
1897 s->mbintra_table[mb_xy]=1;
1899 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
1900 uint8_t *dest_y, *dest_cb, *dest_cr;
1901 int dct_linesize, dct_offset;
1902 op_pixels_func (*op_pix)[4];
1903 qpel_mc_func (*op_qpix)[16];
1904 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1905 const int uvlinesize= s->current_picture.linesize[1];
1906 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1907 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1909 /* avoid copy if macroblock skipped in last frame too */
1910 /* skip only during decoding as we might trash the buffers during encoding a bit */
1912 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1913 const int age= s->current_picture.age;
1917 if (s->mb_skipped) {
1919 assert(s->pict_type!=I_TYPE);
1921 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1922 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1924 /* if previous was skipped too, then nothing to do ! */
1925 if (*mbskip_ptr >= age && s->current_picture.reference){
1928 } else if(!s->current_picture.reference){
1929 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1930 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1932 *mbskip_ptr = 0; /* not skipped */
1936 dct_linesize = linesize << s->interlaced_dct;
1937 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1941 dest_cb= s->dest[1];
1942 dest_cr= s->dest[2];
1944 dest_y = s->b_scratchpad;
1945 dest_cb= s->b_scratchpad+16*linesize;
1946 dest_cr= s->b_scratchpad+32*linesize;
1950 /* motion handling */
1951 /* decoding or more than one mb_type (MC was already done otherwise) */
1954 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1956 if (s->mv_dir & MV_DIR_FORWARD) {
1957 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1958 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1960 if (s->mv_dir & MV_DIR_BACKWARD) {
1961 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1964 op_qpix= s->me.qpel_put;
1965 if ((!s->no_rounding) || s->pict_type==B_TYPE){
1966 op_pix = s->dsp.put_pixels_tab;
1968 op_pix = s->dsp.put_no_rnd_pixels_tab;
1970 if (s->mv_dir & MV_DIR_FORWARD) {
1971 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1972 op_pix = s->dsp.avg_pixels_tab;
1973 op_qpix= s->me.qpel_avg;
1975 if (s->mv_dir & MV_DIR_BACKWARD) {
1976 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1981 /* skip dequant / idct if we are really late ;) */
1982 if(s->hurry_up>1) goto skip_idct;
1983 if(s->avctx->skip_idct){
1984 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
1985 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
1986 || s->avctx->skip_idct >= AVDISCARD_ALL)
1990 /* add dct residue */
1991 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1992 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1993 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1994 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1995 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1996 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1998 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1999 if (s->chroma_y_shift){
2000 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2001 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2005 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2006 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2007 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2008 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2011 } else if(s->codec_id != CODEC_ID_WMV2){
2012 add_dct(s, block[0], 0, dest_y , dct_linesize);
2013 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2014 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2015 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2017 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2018 if(s->chroma_y_shift){//Chroma420
2019 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2020 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2023 dct_linesize = uvlinesize << s->interlaced_dct;
2024 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2026 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2027 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2028 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2029 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2030 if(!s->chroma_x_shift){//Chroma444
2031 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2032 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2033 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2034 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2039 else if (ENABLE_WMV2) {
2040 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2043 /* dct only in intra block */
2044 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2045 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2046 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2047 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2048 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2050 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2051 if(s->chroma_y_shift){
2052 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2053 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2057 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2058 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2059 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2060 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2064 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2065 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2066 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2067 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2069 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2070 if(s->chroma_y_shift){
2071 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2072 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2075 dct_linesize = uvlinesize << s->interlaced_dct;
2076 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2078 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2079 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2080 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2081 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2082 if(!s->chroma_x_shift){//Chroma444
2083 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2084 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2085 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2086 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2094 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2095 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2096 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2101 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2102 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
2103 else MPV_decode_mb_internal(s, block, 0);
2108 * @param h is the normal height, this will be reduced automatically if needed for the last row
2110 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2111 if (s->avctx->draw_horiz_band) {
2115 if(s->picture_structure != PICT_FRAME){
2118 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2121 h= FFMIN(h, s->avctx->height - y);
2123 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2124 src= (AVFrame*)s->current_picture_ptr;
2125 else if(s->last_picture_ptr)
2126 src= (AVFrame*)s->last_picture_ptr;
2130 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2136 offset[0]= y * s->linesize;;
2138 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2144 s->avctx->draw_horiz_band(s->avctx, src, offset,
2145 y, s->picture_structure, h);
2149 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2150 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2151 const int uvlinesize= s->current_picture.linesize[1];
2152 const int mb_size= 4 - s->avctx->lowres;
2154 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2155 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2156 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2157 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2158 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2159 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;
2160 //block_index is not used by mpeg2, so it is not affected by chroma_format
2162 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2163 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2164 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2166 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2168 s->dest[0] += s->mb_y * linesize << mb_size;
2169 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2170 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2174 void ff_mpeg_flush(AVCodecContext *avctx){
2176 MpegEncContext *s = avctx->priv_data;
2178 if(s==NULL || s->picture==NULL)
2181 for(i=0; i<MAX_PICTURE_COUNT; i++){
2182 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2183 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2184 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2186 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2188 s->mb_x= s->mb_y= 0;
2190 s->parse_context.state= -1;
2191 s->parse_context.frame_start_found= 0;
2192 s->parse_context.overread= 0;
2193 s->parse_context.overread_index= 0;
2194 s->parse_context.index= 0;
2195 s->parse_context.last_index= 0;
2196 s->bitstream_buffer_size=0;
2200 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2201 DCTELEM *block, int n, int qscale)
2203 int i, level, nCoeffs;
2204 const uint16_t *quant_matrix;
2206 nCoeffs= s->block_last_index[n];
2209 block[0] = block[0] * s->y_dc_scale;
2211 block[0] = block[0] * s->c_dc_scale;
2212 /* XXX: only mpeg1 */
2213 quant_matrix = s->intra_matrix;
2214 for(i=1;i<=nCoeffs;i++) {
2215 int j= s->intra_scantable.permutated[i];
2220 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2221 level = (level - 1) | 1;
2224 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2225 level = (level - 1) | 1;
2232 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2233 DCTELEM *block, int n, int qscale)
2235 int i, level, nCoeffs;
2236 const uint16_t *quant_matrix;
2238 nCoeffs= s->block_last_index[n];
2240 quant_matrix = s->inter_matrix;
2241 for(i=0; i<=nCoeffs; i++) {
2242 int j= s->intra_scantable.permutated[i];
2247 level = (((level << 1) + 1) * qscale *
2248 ((int) (quant_matrix[j]))) >> 4;
2249 level = (level - 1) | 1;
2252 level = (((level << 1) + 1) * qscale *
2253 ((int) (quant_matrix[j]))) >> 4;
2254 level = (level - 1) | 1;
2261 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2262 DCTELEM *block, int n, int qscale)
2264 int i, level, nCoeffs;
2265 const uint16_t *quant_matrix;
2267 if(s->alternate_scan) nCoeffs= 63;
2268 else nCoeffs= s->block_last_index[n];
2271 block[0] = block[0] * s->y_dc_scale;
2273 block[0] = block[0] * s->c_dc_scale;
2274 quant_matrix = s->intra_matrix;
2275 for(i=1;i<=nCoeffs;i++) {
2276 int j= s->intra_scantable.permutated[i];
2281 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2284 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2291 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2292 DCTELEM *block, int n, int qscale)
2294 int i, level, nCoeffs;
2295 const uint16_t *quant_matrix;
2298 if(s->alternate_scan) nCoeffs= 63;
2299 else nCoeffs= s->block_last_index[n];
2302 block[0] = block[0] * s->y_dc_scale;
2304 block[0] = block[0] * s->c_dc_scale;
2305 quant_matrix = s->intra_matrix;
2306 for(i=1;i<=nCoeffs;i++) {
2307 int j= s->intra_scantable.permutated[i];
2312 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2315 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2324 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2325 DCTELEM *block, int n, int qscale)
2327 int i, level, nCoeffs;
2328 const uint16_t *quant_matrix;
2331 if(s->alternate_scan) nCoeffs= 63;
2332 else nCoeffs= s->block_last_index[n];
2334 quant_matrix = s->inter_matrix;
2335 for(i=0; i<=nCoeffs; i++) {
2336 int j= s->intra_scantable.permutated[i];
2341 level = (((level << 1) + 1) * qscale *
2342 ((int) (quant_matrix[j]))) >> 4;
2345 level = (((level << 1) + 1) * qscale *
2346 ((int) (quant_matrix[j]))) >> 4;
2355 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2356 DCTELEM *block, int n, int qscale)
2358 int i, level, qmul, qadd;
2361 assert(s->block_last_index[n]>=0);
2367 block[0] = block[0] * s->y_dc_scale;
2369 block[0] = block[0] * s->c_dc_scale;
2370 qadd = (qscale - 1) | 1;
2377 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2379 for(i=1; i<=nCoeffs; i++) {
2383 level = level * qmul - qadd;
2385 level = level * qmul + qadd;
2392 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2393 DCTELEM *block, int n, int qscale)
2395 int i, level, qmul, qadd;
2398 assert(s->block_last_index[n]>=0);
2400 qadd = (qscale - 1) | 1;
2403 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2405 for(i=0; i<=nCoeffs; i++) {
2409 level = level * qmul - qadd;
2411 level = level * qmul + qadd;
2419 * set qscale and update qscale dependent variables.
2421 void ff_set_qscale(MpegEncContext * s, int qscale)
2425 else if (qscale > 31)
2429 s->chroma_qscale= s->chroma_qscale_table[qscale];
2431 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2432 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];