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
26 * @file libavcodec/mpegvideo.c
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
33 #include "mpegvideo_common.h"
37 #include "xvmc_internal.h"
43 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
44 DCTELEM *block, int n, int qscale);
45 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
46 DCTELEM *block, int n, int qscale);
47 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
59 /* enable all paranoid tests for rounding, overflows, etc... */
65 static const uint8_t ff_default_chroma_qscale_table[32]={
66 // 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
67 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
70 const uint8_t ff_mpeg1_dc_scale_table[128]={
71 // 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
72 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
73 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
87 uint32_t tmp= *state << 8;
89 if(tmp == 0x100 || p==end)
94 if (p[-1] > 1 ) p+= 3;
95 else if(p[-2] ) p+= 2;
96 else if(p[-3]|(p[-1]-1)) p++;
109 /* init common dct for both encoder and decoder */
110 int ff_dct_common_init(MpegEncContext *s)
112 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
113 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
114 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
115 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
116 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
117 if(s->flags & CODEC_FLAG_BITEXACT)
118 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
119 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
122 MPV_common_init_mmx(s);
124 MPV_common_init_axp(s);
126 MPV_common_init_mlib(s);
128 MPV_common_init_mmi(s);
130 MPV_common_init_arm(s);
132 MPV_common_init_altivec(s);
134 MPV_common_init_bfin(s);
137 /* load & permutate scantables
138 note: only wmv uses different ones
140 if(s->alternate_scan){
141 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
142 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
144 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
145 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
147 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
148 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
153 void ff_copy_picture(Picture *dst, Picture *src){
155 dst->type= FF_BUFFER_TYPE_COPY;
159 * allocates a Picture
160 * The pixels are allocated/set by calling get_buffer() if shared=0
162 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
163 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
164 const int mb_array_size= s->mb_stride*s->mb_height;
165 const int b8_array_size= s->b8_stride*s->mb_height*2;
166 const int b4_array_size= s->b4_stride*s->mb_height*4;
171 assert(pic->data[0]);
172 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
173 pic->type= FF_BUFFER_TYPE_SHARED;
175 assert(!pic->data[0]);
177 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
179 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
180 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
184 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
185 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
186 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
190 if(pic->linesize[1] != pic->linesize[2]){
191 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
192 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
196 s->linesize = pic->linesize[0];
197 s->uvlinesize= pic->linesize[1];
200 if(pic->qscale_table==NULL){
202 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
203 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
204 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
207 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
208 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
209 CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
210 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
211 if(s->out_format == FMT_H264){
213 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
214 pic->motion_val[i]= pic->motion_val_base[i]+4;
215 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
217 pic->motion_subsample_log2= 2;
218 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
220 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
221 pic->motion_val[i]= pic->motion_val_base[i]+4;
222 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
224 pic->motion_subsample_log2= 3;
226 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
227 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
229 pic->qstride= s->mb_stride;
230 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
233 /* It might be nicer if the application would keep track of these
234 * but it would require an API change. */
235 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
236 s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
237 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
238 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.
241 fail: //for the CHECKED_ALLOCZ macro
243 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
248 * deallocates a picture
250 static void free_picture(MpegEncContext *s, Picture *pic){
253 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
254 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
257 av_freep(&pic->mb_var);
258 av_freep(&pic->mc_mb_var);
259 av_freep(&pic->mb_mean);
260 av_freep(&pic->mbskip_table);
261 av_freep(&pic->qscale_table);
262 av_freep(&pic->mb_type_base);
263 av_freep(&pic->dct_coeff);
264 av_freep(&pic->pan_scan);
267 av_freep(&pic->motion_val_base[i]);
268 av_freep(&pic->ref_index[i]);
271 if(pic->type == FF_BUFFER_TYPE_SHARED){
280 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
283 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
284 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
285 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
287 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
288 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
289 s->me.temp= s->me.scratchpad;
290 s->rd_scratchpad= s->me.scratchpad;
291 s->b_scratchpad= s->me.scratchpad;
292 s->obmc_scratchpad= s->me.scratchpad + 16;
294 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
295 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
296 if(s->avctx->noise_reduction){
297 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
300 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
301 s->block= s->blocks[0];
304 s->pblocks[i] = (short *)(&s->block[i]);
308 return -1; //free() through MPV_common_end()
311 static void free_duplicate_context(MpegEncContext *s){
314 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
315 av_freep(&s->me.scratchpad);
319 s->obmc_scratchpad= NULL;
321 av_freep(&s->dct_error_sum);
322 av_freep(&s->me.map);
323 av_freep(&s->me.score_map);
324 av_freep(&s->blocks);
328 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
329 #define COPY(a) bak->a= src->a
330 COPY(allocated_edge_emu_buffer);
331 COPY(edge_emu_buffer);
336 COPY(obmc_scratchpad);
343 COPY(me.map_generation);
351 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
354 //FIXME copy only needed parts
356 backup_duplicate_context(&bak, dst);
357 memcpy(dst, src, sizeof(MpegEncContext));
358 backup_duplicate_context(dst, &bak);
360 dst->pblocks[i] = (short *)(&dst->block[i]);
362 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
366 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
367 * the changed fields will not depend upon the prior state of the MpegEncContext.
369 void MPV_common_defaults(MpegEncContext *s){
371 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
372 s->chroma_qscale_table= ff_default_chroma_qscale_table;
373 s->progressive_frame= 1;
374 s->progressive_sequence= 1;
375 s->picture_structure= PICT_FRAME;
377 s->coded_picture_number = 0;
378 s->picture_number = 0;
379 s->input_picture_number = 0;
381 s->picture_in_gop_number = 0;
388 * sets the given MpegEncContext to defaults for decoding.
389 * the changed fields will not depend upon the prior state of the MpegEncContext.
391 void MPV_decode_defaults(MpegEncContext *s){
392 MPV_common_defaults(s);
396 * init common structure for both encoder and decoder.
397 * this assumes that some variables like width/height are already set
399 int MPV_common_init(MpegEncContext *s)
401 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
403 s->mb_height = (s->height + 15) / 16;
405 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
406 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
410 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
413 dsputil_init(&s->dsp, s->avctx);
414 ff_dct_common_init(s);
416 s->flags= s->avctx->flags;
417 s->flags2= s->avctx->flags2;
419 s->mb_width = (s->width + 15) / 16;
420 s->mb_stride = s->mb_width + 1;
421 s->b8_stride = s->mb_width*2 + 1;
422 s->b4_stride = s->mb_width*4 + 1;
423 mb_array_size= s->mb_height * s->mb_stride;
424 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
426 /* set chroma shifts */
427 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
428 &(s->chroma_y_shift) );
430 /* set default edge pos, will be overriden in decode_header if needed */
431 s->h_edge_pos= s->mb_width*16;
432 s->v_edge_pos= s->mb_height*16;
434 s->mb_num = s->mb_width * s->mb_height;
439 s->block_wrap[3]= s->b8_stride;
441 s->block_wrap[5]= s->mb_stride;
443 y_size = s->b8_stride * (2 * s->mb_height + 1);
444 c_size = s->mb_stride * (s->mb_height + 1);
445 yc_size = y_size + 2 * c_size;
447 /* convert fourcc to upper case */
448 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
449 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
450 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
451 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
453 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
454 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
455 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
456 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
458 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
460 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
461 for(y=0; y<s->mb_height; y++){
462 for(x=0; x<s->mb_width; x++){
463 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
466 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
469 /* Allocate MV tables */
470 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
471 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
472 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
473 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
474 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
475 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
477 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
478 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
479 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
480 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
481 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
483 if(s->msmpeg4_version){
484 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
486 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
488 /* Allocate MB type table */
489 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
491 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
493 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
494 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
495 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
496 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
497 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
498 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
500 if(s->avctx->noise_reduction){
501 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
504 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
506 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
508 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
509 /* interlaced direct mode decoding tables */
514 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
515 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
517 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
518 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
519 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
521 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
524 if (s->out_format == FMT_H263) {
526 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
527 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
528 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
529 s->ac_val[2] = s->ac_val[1] + c_size;
532 CHECKED_ALLOCZ(s->coded_block_base, y_size);
533 s->coded_block= s->coded_block_base + s->b8_stride + 1;
535 /* cbp, ac_pred, pred_dir */
536 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
537 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
540 if (s->h263_pred || s->h263_plus || !s->encoding) {
542 //MN: we need these for error resilience of intra-frames
543 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
544 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
545 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
546 s->dc_val[2] = s->dc_val[1] + c_size;
547 for(i=0;i<yc_size;i++)
548 s->dc_val_base[i] = 1024;
551 /* which mb is a intra block */
552 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
553 memset(s->mbintra_table, 1, mb_array_size);
555 /* init macroblock skip table */
556 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
557 //Note the +1 is for a quicker mpeg4 slice_end detection
558 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
560 s->parse_context.state= -1;
561 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
562 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
563 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
564 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
567 s->context_initialized = 1;
569 s->thread_context[0]= s;
570 threads = s->avctx->thread_count;
572 for(i=1; i<threads; i++){
573 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
574 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
577 for(i=0; i<threads; i++){
578 if(init_duplicate_context(s->thread_context[i], s) < 0)
580 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
581 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
590 /* init common structure for both encoder and decoder */
591 void MPV_common_end(MpegEncContext *s)
595 for(i=0; i<s->avctx->thread_count; i++){
596 free_duplicate_context(s->thread_context[i]);
598 for(i=1; i<s->avctx->thread_count; i++){
599 av_freep(&s->thread_context[i]);
602 av_freep(&s->parse_context.buffer);
603 s->parse_context.buffer_size=0;
605 av_freep(&s->mb_type);
606 av_freep(&s->p_mv_table_base);
607 av_freep(&s->b_forw_mv_table_base);
608 av_freep(&s->b_back_mv_table_base);
609 av_freep(&s->b_bidir_forw_mv_table_base);
610 av_freep(&s->b_bidir_back_mv_table_base);
611 av_freep(&s->b_direct_mv_table_base);
613 s->b_forw_mv_table= NULL;
614 s->b_back_mv_table= NULL;
615 s->b_bidir_forw_mv_table= NULL;
616 s->b_bidir_back_mv_table= NULL;
617 s->b_direct_mv_table= NULL;
621 av_freep(&s->b_field_mv_table_base[i][j][k]);
622 s->b_field_mv_table[i][j][k]=NULL;
624 av_freep(&s->b_field_select_table[i][j]);
625 av_freep(&s->p_field_mv_table_base[i][j]);
626 s->p_field_mv_table[i][j]=NULL;
628 av_freep(&s->p_field_select_table[i]);
631 av_freep(&s->dc_val_base);
632 av_freep(&s->ac_val_base);
633 av_freep(&s->coded_block_base);
634 av_freep(&s->mbintra_table);
635 av_freep(&s->cbp_table);
636 av_freep(&s->pred_dir_table);
638 av_freep(&s->mbskip_table);
639 av_freep(&s->prev_pict_types);
640 av_freep(&s->bitstream_buffer);
641 s->allocated_bitstream_buffer_size=0;
643 av_freep(&s->avctx->stats_out);
644 av_freep(&s->ac_stats);
645 av_freep(&s->error_status_table);
646 av_freep(&s->mb_index2xy);
647 av_freep(&s->lambda_table);
648 av_freep(&s->q_intra_matrix);
649 av_freep(&s->q_inter_matrix);
650 av_freep(&s->q_intra_matrix16);
651 av_freep(&s->q_inter_matrix16);
652 av_freep(&s->input_picture);
653 av_freep(&s->reordered_input_picture);
654 av_freep(&s->dct_offset);
657 for(i=0; i<MAX_PICTURE_COUNT; i++){
658 free_picture(s, &s->picture[i]);
661 av_freep(&s->picture);
662 s->context_initialized = 0;
665 s->current_picture_ptr= NULL;
666 s->linesize= s->uvlinesize= 0;
669 av_freep(&s->visualization_buffer[i]);
671 avcodec_default_free_buffers(s->avctx);
674 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
676 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
677 uint8_t index_run[MAX_RUN+1];
678 int last, run, level, start, end, i;
680 /* If table is static, we can quit if rl->max_level[0] is not NULL */
681 if(static_store && rl->max_level[0])
684 /* compute max_level[], max_run[] and index_run[] */
685 for(last=0;last<2;last++) {
694 memset(max_level, 0, MAX_RUN + 1);
695 memset(max_run, 0, MAX_LEVEL + 1);
696 memset(index_run, rl->n, MAX_RUN + 1);
697 for(i=start;i<end;i++) {
698 run = rl->table_run[i];
699 level = rl->table_level[i];
700 if (index_run[run] == rl->n)
702 if (level > max_level[run])
703 max_level[run] = level;
704 if (run > max_run[level])
705 max_run[level] = run;
708 rl->max_level[last] = static_store[last];
710 rl->max_level[last] = av_malloc(MAX_RUN + 1);
711 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
713 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
715 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
716 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
718 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
720 rl->index_run[last] = av_malloc(MAX_RUN + 1);
721 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
725 void init_vlc_rl(RLTable *rl)
737 for(i=0; i<rl->vlc.table_size; i++){
738 int code= rl->vlc.table[i][0];
739 int len = rl->vlc.table[i][1];
742 if(len==0){ // illegal code
745 }else if(len<0){ //more bits needed
749 if(code==rl->n){ //esc
753 run= rl->table_run [code] + 1;
754 level= rl->table_level[code] * qmul + qadd;
755 if(code >= rl->last) run+=192;
758 rl->rl_vlc[q][i].len= len;
759 rl->rl_vlc[q][i].level= level;
760 rl->rl_vlc[q][i].run= run;
765 int ff_find_unused_picture(MpegEncContext *s, int shared){
769 for(i=0; i<MAX_PICTURE_COUNT; i++){
770 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
773 for(i=0; i<MAX_PICTURE_COUNT; i++){
774 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
776 for(i=0; i<MAX_PICTURE_COUNT; i++){
777 if(s->picture[i].data[0]==NULL) return i;
781 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
782 /* We could return -1, but the codec would crash trying to draw into a
783 * non-existing frame anyway. This is safer than waiting for a random crash.
784 * Also the return of this is never useful, an encoder must only allocate
785 * as much as allowed in the specification. This has no relationship to how
786 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
787 * enough for such valid streams).
788 * Plus, a decoder has to check stream validity and remove frames if too
789 * many reference frames are around. Waiting for "OOM" is not correct at
790 * all. Similarly, missing reference frames have to be replaced by
791 * interpolated/MC frames, anything else is a bug in the codec ...
797 static void update_noise_reduction(MpegEncContext *s){
800 for(intra=0; intra<2; intra++){
801 if(s->dct_count[intra] > (1<<16)){
803 s->dct_error_sum[intra][i] >>=1;
805 s->dct_count[intra] >>= 1;
809 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);
815 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
817 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
823 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
825 /* mark&release old frames */
826 if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
827 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
828 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
830 /* release forgotten pictures */
831 /* if(mpeg124/h263) */
833 for(i=0; i<MAX_PICTURE_COUNT; i++){
834 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
835 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
836 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
844 /* release non reference frames */
845 for(i=0; i<MAX_PICTURE_COUNT; i++){
846 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
847 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
851 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
852 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
854 i= ff_find_unused_picture(s, 0);
855 pic= (AVFrame*)&s->picture[i];
860 if (s->codec_id == CODEC_ID_H264)
861 pic->reference = s->picture_structure;
862 else if (s->pict_type != FF_B_TYPE)
866 pic->coded_picture_number= s->coded_picture_number++;
868 if( alloc_picture(s, (Picture*)pic, 0) < 0)
871 s->current_picture_ptr= (Picture*)pic;
872 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
873 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
876 s->current_picture_ptr->pict_type= s->pict_type;
877 // if(s->flags && CODEC_FLAG_QSCALE)
878 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
879 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
881 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
883 if (s->pict_type != FF_B_TYPE) {
884 s->last_picture_ptr= s->next_picture_ptr;
886 s->next_picture_ptr= s->current_picture_ptr;
888 /* 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,
889 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
890 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
891 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
892 s->pict_type, s->dropable);*/
894 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
895 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
897 if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable && s->codec_id != CODEC_ID_H264){
898 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
899 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
903 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
905 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
908 if(s->picture_structure == PICT_BOTTOM_FIELD){
909 s->current_picture.data[i] += s->current_picture.linesize[i];
911 s->current_picture.linesize[i] *= 2;
912 s->last_picture.linesize[i] *=2;
913 s->next_picture.linesize[i] *=2;
917 s->hurry_up= s->avctx->hurry_up;
918 s->error_recognition= avctx->error_recognition;
920 /* set dequantizer, we can't do it during init as it might change for mpeg4
921 and we can't do it in the header decode as init is not called for mpeg4 there yet */
922 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
923 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
924 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
925 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
926 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
927 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
929 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
930 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
933 if(s->dct_error_sum){
934 assert(s->avctx->noise_reduction && s->encoding);
936 update_noise_reduction(s);
939 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
940 return ff_xvmc_field_start(s, avctx);
945 /* generic function for encode/decode called after a frame has been coded/decoded */
946 void MPV_frame_end(MpegEncContext *s)
949 /* draw edge for correct motion prediction if outside */
950 //just to make sure that all data is rendered.
951 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
952 ff_xvmc_field_end(s);
954 if(!(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
955 && s->unrestricted_mv
956 && s->current_picture.reference
958 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
959 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
960 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
961 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
965 s->last_pict_type = s->pict_type;
966 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
967 if(s->pict_type!=FF_B_TYPE){
968 s->last_non_b_pict_type= s->pict_type;
971 /* copy back current_picture variables */
972 for(i=0; i<MAX_PICTURE_COUNT; i++){
973 if(s->picture[i].data[0] == s->current_picture.data[0]){
974 s->picture[i]= s->current_picture;
978 assert(i<MAX_PICTURE_COUNT);
982 /* release non-reference frames */
983 for(i=0; i<MAX_PICTURE_COUNT; i++){
984 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
985 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
989 // clear copies, to avoid confusion
991 memset(&s->last_picture, 0, sizeof(Picture));
992 memset(&s->next_picture, 0, sizeof(Picture));
993 memset(&s->current_picture, 0, sizeof(Picture));
995 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
999 * draws an line from (ex, ey) -> (sx, sy).
1000 * @param w width of the image
1001 * @param h height of the image
1002 * @param stride stride/linesize of the image
1003 * @param color color of the arrow
1005 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1008 sx= av_clip(sx, 0, w-1);
1009 sy= av_clip(sy, 0, h-1);
1010 ex= av_clip(ex, 0, w-1);
1011 ey= av_clip(ey, 0, h-1);
1013 buf[sy*stride + sx]+= color;
1015 if(FFABS(ex - sx) > FFABS(ey - sy)){
1017 FFSWAP(int, sx, ex);
1018 FFSWAP(int, sy, ey);
1020 buf+= sx + sy*stride;
1022 f= ((ey-sy)<<16)/ex;
1023 for(x= 0; x <= ex; x++){
1026 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1027 buf[(y+1)*stride + x]+= (color* fr )>>16;
1031 FFSWAP(int, sx, ex);
1032 FFSWAP(int, sy, ey);
1034 buf+= sx + sy*stride;
1036 if(ey) f= ((ex-sx)<<16)/ey;
1038 for(y= 0; y <= ey; y++){
1041 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1042 buf[y*stride + x+1]+= (color* fr )>>16;
1048 * draws an arrow from (ex, ey) -> (sx, sy).
1049 * @param w width of the image
1050 * @param h height of the image
1051 * @param stride stride/linesize of the image
1052 * @param color color of the arrow
1054 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1057 sx= av_clip(sx, -100, w+100);
1058 sy= av_clip(sy, -100, h+100);
1059 ex= av_clip(ex, -100, w+100);
1060 ey= av_clip(ey, -100, h+100);
1065 if(dx*dx + dy*dy > 3*3){
1068 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1070 //FIXME subpixel accuracy
1071 rx= ROUNDED_DIV(rx*3<<4, length);
1072 ry= ROUNDED_DIV(ry*3<<4, length);
1074 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1075 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1077 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1081 * prints debuging info for the given picture.
1083 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1085 if(!pict || !pict->mb_type) return;
1087 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1090 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1091 switch (pict->pict_type) {
1092 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1093 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1094 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1095 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1096 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1097 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1099 for(y=0; y<s->mb_height; y++){
1100 for(x=0; x<s->mb_width; x++){
1101 if(s->avctx->debug&FF_DEBUG_SKIP){
1102 int count= s->mbskip_table[x + y*s->mb_stride];
1103 if(count>9) count=9;
1104 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1106 if(s->avctx->debug&FF_DEBUG_QP){
1107 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1109 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1110 int mb_type= pict->mb_type[x + y*s->mb_stride];
1111 //Type & MV direction
1113 av_log(s->avctx, AV_LOG_DEBUG, "P");
1114 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1115 av_log(s->avctx, AV_LOG_DEBUG, "A");
1116 else if(IS_INTRA4x4(mb_type))
1117 av_log(s->avctx, AV_LOG_DEBUG, "i");
1118 else if(IS_INTRA16x16(mb_type))
1119 av_log(s->avctx, AV_LOG_DEBUG, "I");
1120 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1121 av_log(s->avctx, AV_LOG_DEBUG, "d");
1122 else if(IS_DIRECT(mb_type))
1123 av_log(s->avctx, AV_LOG_DEBUG, "D");
1124 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1125 av_log(s->avctx, AV_LOG_DEBUG, "g");
1126 else if(IS_GMC(mb_type))
1127 av_log(s->avctx, AV_LOG_DEBUG, "G");
1128 else if(IS_SKIP(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "S");
1130 else if(!USES_LIST(mb_type, 1))
1131 av_log(s->avctx, AV_LOG_DEBUG, ">");
1132 else if(!USES_LIST(mb_type, 0))
1133 av_log(s->avctx, AV_LOG_DEBUG, "<");
1135 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1136 av_log(s->avctx, AV_LOG_DEBUG, "X");
1141 av_log(s->avctx, AV_LOG_DEBUG, "+");
1142 else if(IS_16X8(mb_type))
1143 av_log(s->avctx, AV_LOG_DEBUG, "-");
1144 else if(IS_8X16(mb_type))
1145 av_log(s->avctx, AV_LOG_DEBUG, "|");
1146 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1147 av_log(s->avctx, AV_LOG_DEBUG, " ");
1149 av_log(s->avctx, AV_LOG_DEBUG, "?");
1152 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1153 av_log(s->avctx, AV_LOG_DEBUG, "=");
1155 av_log(s->avctx, AV_LOG_DEBUG, " ");
1157 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1159 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1163 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1164 const int shift= 1 + s->quarter_sample;
1168 int h_chroma_shift, v_chroma_shift, block_height;
1169 const int width = s->avctx->width;
1170 const int height= s->avctx->height;
1171 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1172 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1173 s->low_delay=0; //needed to see the vectors without trashing the buffers
1175 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1177 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1178 pict->data[i]= s->visualization_buffer[i];
1180 pict->type= FF_BUFFER_TYPE_COPY;
1182 block_height = 16>>v_chroma_shift;
1184 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1186 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1187 const int mb_index= mb_x + mb_y*s->mb_stride;
1188 if((s->avctx->debug_mv) && pict->motion_val){
1190 for(type=0; type<3; type++){
1193 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1197 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1201 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1206 if(!USES_LIST(pict->mb_type[mb_index], direction))
1209 if(IS_8X8(pict->mb_type[mb_index])){
1212 int sx= mb_x*16 + 4 + 8*(i&1);
1213 int sy= mb_y*16 + 4 + 8*(i>>1);
1214 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1215 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1216 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1217 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1219 }else if(IS_16X8(pict->mb_type[mb_index])){
1223 int sy=mb_y*16 + 4 + 8*i;
1224 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1225 int mx=(pict->motion_val[direction][xy][0]>>shift);
1226 int my=(pict->motion_val[direction][xy][1]>>shift);
1228 if(IS_INTERLACED(pict->mb_type[mb_index]))
1231 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1233 }else if(IS_8X16(pict->mb_type[mb_index])){
1236 int sx=mb_x*16 + 4 + 8*i;
1238 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1239 int mx=(pict->motion_val[direction][xy][0]>>shift);
1240 int my=(pict->motion_val[direction][xy][1]>>shift);
1242 if(IS_INTERLACED(pict->mb_type[mb_index]))
1245 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1248 int sx= mb_x*16 + 8;
1249 int sy= mb_y*16 + 8;
1250 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1251 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1252 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1253 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1257 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1258 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1260 for(y=0; y<block_height; y++){
1261 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1262 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1265 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1266 int mb_type= pict->mb_type[mb_index];
1269 #define COLOR(theta, r)\
1270 u= (int)(128 + r*cos(theta*3.141592/180));\
1271 v= (int)(128 + r*sin(theta*3.141592/180));
1275 if(IS_PCM(mb_type)){
1277 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1279 }else if(IS_INTRA4x4(mb_type)){
1281 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1283 }else if(IS_DIRECT(mb_type)){
1285 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1287 }else if(IS_GMC(mb_type)){
1289 }else if(IS_SKIP(mb_type)){
1291 }else if(!USES_LIST(mb_type, 1)){
1293 }else if(!USES_LIST(mb_type, 0)){
1296 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1300 u*= 0x0101010101010101ULL;
1301 v*= 0x0101010101010101ULL;
1302 for(y=0; y<block_height; y++){
1303 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1304 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1308 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1309 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1310 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1312 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1314 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1316 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1317 int dm= 1 << (mv_sample_log2-2);
1319 int sx= mb_x*16 + 8*(i&1);
1320 int sy= mb_y*16 + 8*(i>>1);
1321 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1323 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1324 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1326 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1327 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1328 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1332 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1336 s->mbskip_table[mb_index]=0;
1342 static inline int hpel_motion_lowres(MpegEncContext *s,
1343 uint8_t *dest, uint8_t *src,
1344 int field_based, int field_select,
1345 int src_x, int src_y,
1346 int width, int height, int stride,
1347 int h_edge_pos, int v_edge_pos,
1348 int w, int h, h264_chroma_mc_func *pix_op,
1349 int motion_x, int motion_y)
1351 const int lowres= s->avctx->lowres;
1352 const int s_mask= (2<<lowres)-1;
1356 if(s->quarter_sample){
1361 sx= motion_x & s_mask;
1362 sy= motion_y & s_mask;
1363 src_x += motion_x >> (lowres+1);
1364 src_y += motion_y >> (lowres+1);
1366 src += src_y * stride + src_x;
1368 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1369 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1370 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1371 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1372 src= s->edge_emu_buffer;
1380 pix_op[lowres](dest, src, stride, h, sx, sy);
1384 /* apply one mpeg motion vector to the three components */
1385 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1386 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1387 int field_based, int bottom_field, int field_select,
1388 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1389 int motion_x, int motion_y, int h)
1391 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1392 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1393 const int lowres= s->avctx->lowres;
1394 const int block_s= 8>>lowres;
1395 const int s_mask= (2<<lowres)-1;
1396 const int h_edge_pos = s->h_edge_pos >> lowres;
1397 const int v_edge_pos = s->v_edge_pos >> lowres;
1398 linesize = s->current_picture.linesize[0] << field_based;
1399 uvlinesize = s->current_picture.linesize[1] << field_based;
1401 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1407 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1410 sx= motion_x & s_mask;
1411 sy= motion_y & s_mask;
1412 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1413 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1415 if (s->out_format == FMT_H263) {
1416 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1417 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1420 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1423 uvsx = (2*mx) & s_mask;
1424 uvsy = (2*my) & s_mask;
1425 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1426 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1432 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1433 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1436 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1437 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1438 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1440 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1441 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1442 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1443 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1444 ptr_y = s->edge_emu_buffer;
1445 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1446 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1447 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1448 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1449 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1450 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1456 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1457 dest_y += s->linesize;
1458 dest_cb+= s->uvlinesize;
1459 dest_cr+= s->uvlinesize;
1463 ptr_y += s->linesize;
1464 ptr_cb+= s->uvlinesize;
1465 ptr_cr+= s->uvlinesize;
1470 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1472 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1473 uvsx <<= 2 - lowres;
1474 uvsy <<= 2 - lowres;
1475 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1476 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1478 //FIXME h261 lowres loop filter
1481 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1482 uint8_t *dest_cb, uint8_t *dest_cr,
1483 uint8_t **ref_picture,
1484 h264_chroma_mc_func *pix_op,
1486 const int lowres= s->avctx->lowres;
1487 const int block_s= 8>>lowres;
1488 const int s_mask= (2<<lowres)-1;
1489 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1490 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1491 int emu=0, src_x, src_y, offset, sx, sy;
1494 if(s->quarter_sample){
1499 /* In case of 8X8, we construct a single chroma motion vector
1500 with a special rounding */
1501 mx= ff_h263_round_chroma(mx);
1502 my= ff_h263_round_chroma(my);
1506 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1507 src_y = s->mb_y*block_s + (my >> (lowres+1));
1509 offset = src_y * s->uvlinesize + src_x;
1510 ptr = ref_picture[1] + offset;
1511 if(s->flags&CODEC_FLAG_EMU_EDGE){
1512 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1513 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1514 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1515 ptr= s->edge_emu_buffer;
1521 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1523 ptr = ref_picture[2] + offset;
1525 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1526 ptr= s->edge_emu_buffer;
1528 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1532 * motion compensation of a single macroblock
1534 * @param dest_y luma destination pointer
1535 * @param dest_cb chroma cb/u destination pointer
1536 * @param dest_cr chroma cr/v destination pointer
1537 * @param dir direction (0->forward, 1->backward)
1538 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1539 * @param pic_op halfpel motion compensation function (average or put normally)
1540 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1542 static inline void MPV_motion_lowres(MpegEncContext *s,
1543 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1544 int dir, uint8_t **ref_picture,
1545 h264_chroma_mc_func *pix_op)
1549 const int lowres= s->avctx->lowres;
1550 const int block_s= 8>>lowres;
1555 switch(s->mv_type) {
1557 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1559 ref_picture, pix_op,
1560 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1566 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1567 ref_picture[0], 0, 0,
1568 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1569 s->width, s->height, s->linesize,
1570 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1571 block_s, block_s, pix_op,
1572 s->mv[dir][i][0], s->mv[dir][i][1]);
1574 mx += s->mv[dir][i][0];
1575 my += s->mv[dir][i][1];
1578 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1579 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1582 if (s->picture_structure == PICT_FRAME) {
1584 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1585 1, 0, s->field_select[dir][0],
1586 ref_picture, pix_op,
1587 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1589 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1590 1, 1, s->field_select[dir][1],
1591 ref_picture, pix_op,
1592 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1594 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1595 ref_picture= s->current_picture_ptr->data;
1598 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1599 0, 0, s->field_select[dir][0],
1600 ref_picture, pix_op,
1601 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1606 uint8_t ** ref2picture;
1608 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1609 ref2picture= ref_picture;
1611 ref2picture= s->current_picture_ptr->data;
1614 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1615 0, 0, s->field_select[dir][i],
1616 ref2picture, pix_op,
1617 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1619 dest_y += 2*block_s*s->linesize;
1620 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1621 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1625 if(s->picture_structure == PICT_FRAME){
1629 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1631 ref_picture, pix_op,
1632 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1634 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1638 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1639 0, 0, s->picture_structure != i+1,
1640 ref_picture, pix_op,
1641 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1643 // after put we make avg of the same block
1644 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1646 //opposite parity is always in the same frame if this is second field
1647 if(!s->first_field){
1648 ref_picture = s->current_picture_ptr->data;
1657 /* put block[] to dest[] */
1658 static inline void put_dct(MpegEncContext *s,
1659 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1661 s->dct_unquantize_intra(s, block, i, qscale);
1662 s->dsp.idct_put (dest, line_size, block);
1665 /* add block[] to dest[] */
1666 static inline void add_dct(MpegEncContext *s,
1667 DCTELEM *block, int i, uint8_t *dest, int line_size)
1669 if (s->block_last_index[i] >= 0) {
1670 s->dsp.idct_add (dest, line_size, block);
1674 static inline void add_dequant_dct(MpegEncContext *s,
1675 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1677 if (s->block_last_index[i] >= 0) {
1678 s->dct_unquantize_inter(s, block, i, qscale);
1680 s->dsp.idct_add (dest, line_size, block);
1685 * cleans dc, ac, coded_block for the current non intra MB
1687 void ff_clean_intra_table_entries(MpegEncContext *s)
1689 int wrap = s->b8_stride;
1690 int xy = s->block_index[0];
1693 s->dc_val[0][xy + 1 ] =
1694 s->dc_val[0][xy + wrap] =
1695 s->dc_val[0][xy + 1 + wrap] = 1024;
1697 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1698 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1699 if (s->msmpeg4_version>=3) {
1700 s->coded_block[xy ] =
1701 s->coded_block[xy + 1 ] =
1702 s->coded_block[xy + wrap] =
1703 s->coded_block[xy + 1 + wrap] = 0;
1706 wrap = s->mb_stride;
1707 xy = s->mb_x + s->mb_y * wrap;
1709 s->dc_val[2][xy] = 1024;
1711 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1712 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1714 s->mbintra_table[xy]= 0;
1717 /* generic function called after a macroblock has been parsed by the
1718 decoder or after it has been encoded by the encoder.
1720 Important variables used:
1721 s->mb_intra : true if intra macroblock
1722 s->mv_dir : motion vector direction
1723 s->mv_type : motion vector type
1724 s->mv : motion vector
1725 s->interlaced_dct : true if interlaced dct used (mpeg2)
1727 static av_always_inline
1728 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1729 int lowres_flag, int is_mpeg12)
1732 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1733 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1734 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1741 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1742 /* save DCT coefficients */
1744 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1747 *dct++ = block[i][s->dsp.idct_permutation[j]];
1750 s->current_picture.qscale_table[mb_xy]= s->qscale;
1752 /* update DC predictors for P macroblocks */
1754 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1755 if(s->mbintra_table[mb_xy])
1756 ff_clean_intra_table_entries(s);
1760 s->last_dc[2] = 128 << s->intra_dc_precision;
1763 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1764 s->mbintra_table[mb_xy]=1;
1766 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1767 uint8_t *dest_y, *dest_cb, *dest_cr;
1768 int dct_linesize, dct_offset;
1769 op_pixels_func (*op_pix)[4];
1770 qpel_mc_func (*op_qpix)[16];
1771 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1772 const int uvlinesize= s->current_picture.linesize[1];
1773 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1774 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1776 /* avoid copy if macroblock skipped in last frame too */
1777 /* skip only during decoding as we might trash the buffers during encoding a bit */
1779 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1780 const int age= s->current_picture.age;
1784 if (s->mb_skipped) {
1786 assert(s->pict_type!=FF_I_TYPE);
1788 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1789 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1791 /* if previous was skipped too, then nothing to do ! */
1792 if (*mbskip_ptr >= age && s->current_picture.reference){
1795 } else if(!s->current_picture.reference){
1796 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1797 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1799 *mbskip_ptr = 0; /* not skipped */
1803 dct_linesize = linesize << s->interlaced_dct;
1804 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1808 dest_cb= s->dest[1];
1809 dest_cr= s->dest[2];
1811 dest_y = s->b_scratchpad;
1812 dest_cb= s->b_scratchpad+16*linesize;
1813 dest_cr= s->b_scratchpad+32*linesize;
1817 /* motion handling */
1818 /* decoding or more than one mb_type (MC was already done otherwise) */
1821 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1823 if (s->mv_dir & MV_DIR_FORWARD) {
1824 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1825 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1827 if (s->mv_dir & MV_DIR_BACKWARD) {
1828 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1831 op_qpix= s->me.qpel_put;
1832 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1833 op_pix = s->dsp.put_pixels_tab;
1835 op_pix = s->dsp.put_no_rnd_pixels_tab;
1837 if (s->mv_dir & MV_DIR_FORWARD) {
1838 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1839 op_pix = s->dsp.avg_pixels_tab;
1840 op_qpix= s->me.qpel_avg;
1842 if (s->mv_dir & MV_DIR_BACKWARD) {
1843 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1848 /* skip dequant / idct if we are really late ;) */
1849 if(s->hurry_up>1) goto skip_idct;
1850 if(s->avctx->skip_idct){
1851 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1852 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1853 || s->avctx->skip_idct >= AVDISCARD_ALL)
1857 /* add dct residue */
1858 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1859 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1860 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1861 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1862 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1863 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1865 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1866 if (s->chroma_y_shift){
1867 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1868 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1872 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1873 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1874 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1875 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1878 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1879 add_dct(s, block[0], 0, dest_y , dct_linesize);
1880 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1881 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1882 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1884 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1885 if(s->chroma_y_shift){//Chroma420
1886 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1887 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1890 dct_linesize = uvlinesize << s->interlaced_dct;
1891 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1893 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1894 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1895 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1896 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1897 if(!s->chroma_x_shift){//Chroma444
1898 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1899 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1900 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1901 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1906 else if (CONFIG_WMV2) {
1907 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1910 /* dct only in intra block */
1911 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1912 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1913 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1914 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1915 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1917 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1918 if(s->chroma_y_shift){
1919 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1920 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1924 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1925 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1926 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1927 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1931 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1932 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1933 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1934 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1936 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1937 if(s->chroma_y_shift){
1938 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1939 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1942 dct_linesize = uvlinesize << s->interlaced_dct;
1943 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1945 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1946 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1947 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1948 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1949 if(!s->chroma_x_shift){//Chroma444
1950 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1951 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1952 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1953 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1961 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1962 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1963 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1968 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1970 if(s->out_format == FMT_MPEG1) {
1971 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1972 else MPV_decode_mb_internal(s, block, 0, 1);
1975 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1976 else MPV_decode_mb_internal(s, block, 0, 0);
1981 * @param h is the normal height, this will be reduced automatically if needed for the last row
1983 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1984 if (s->avctx->draw_horiz_band) {
1988 if(s->picture_structure != PICT_FRAME){
1991 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1994 h= FFMIN(h, s->avctx->height - y);
1996 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
1997 src= (AVFrame*)s->current_picture_ptr;
1998 else if(s->last_picture_ptr)
1999 src= (AVFrame*)s->last_picture_ptr;
2003 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2009 offset[0]= y * s->linesize;
2011 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2017 s->avctx->draw_horiz_band(s->avctx, src, offset,
2018 y, s->picture_structure, h);
2022 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2023 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2024 const int uvlinesize= s->current_picture.linesize[1];
2025 const int mb_size= 4 - s->avctx->lowres;
2027 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2028 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2029 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2030 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2031 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2032 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;
2033 //block_index is not used by mpeg2, so it is not affected by chroma_format
2035 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2036 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2037 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2039 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2041 s->dest[0] += s->mb_y * linesize << mb_size;
2042 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2043 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2047 void ff_mpeg_flush(AVCodecContext *avctx){
2049 MpegEncContext *s = avctx->priv_data;
2051 if(s==NULL || s->picture==NULL)
2054 for(i=0; i<MAX_PICTURE_COUNT; i++){
2055 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2056 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2057 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2059 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2061 s->mb_x= s->mb_y= 0;
2063 s->parse_context.state= -1;
2064 s->parse_context.frame_start_found= 0;
2065 s->parse_context.overread= 0;
2066 s->parse_context.overread_index= 0;
2067 s->parse_context.index= 0;
2068 s->parse_context.last_index= 0;
2069 s->bitstream_buffer_size=0;
2073 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2074 DCTELEM *block, int n, int qscale)
2076 int i, level, nCoeffs;
2077 const uint16_t *quant_matrix;
2079 nCoeffs= s->block_last_index[n];
2082 block[0] = block[0] * s->y_dc_scale;
2084 block[0] = block[0] * s->c_dc_scale;
2085 /* XXX: only mpeg1 */
2086 quant_matrix = s->intra_matrix;
2087 for(i=1;i<=nCoeffs;i++) {
2088 int j= s->intra_scantable.permutated[i];
2093 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2094 level = (level - 1) | 1;
2097 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2098 level = (level - 1) | 1;
2105 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2106 DCTELEM *block, int n, int qscale)
2108 int i, level, nCoeffs;
2109 const uint16_t *quant_matrix;
2111 nCoeffs= s->block_last_index[n];
2113 quant_matrix = s->inter_matrix;
2114 for(i=0; i<=nCoeffs; i++) {
2115 int j= s->intra_scantable.permutated[i];
2120 level = (((level << 1) + 1) * qscale *
2121 ((int) (quant_matrix[j]))) >> 4;
2122 level = (level - 1) | 1;
2125 level = (((level << 1) + 1) * qscale *
2126 ((int) (quant_matrix[j]))) >> 4;
2127 level = (level - 1) | 1;
2134 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2135 DCTELEM *block, int n, int qscale)
2137 int i, level, nCoeffs;
2138 const uint16_t *quant_matrix;
2140 if(s->alternate_scan) nCoeffs= 63;
2141 else nCoeffs= s->block_last_index[n];
2144 block[0] = block[0] * s->y_dc_scale;
2146 block[0] = block[0] * s->c_dc_scale;
2147 quant_matrix = s->intra_matrix;
2148 for(i=1;i<=nCoeffs;i++) {
2149 int j= s->intra_scantable.permutated[i];
2154 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2157 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2164 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2165 DCTELEM *block, int n, int qscale)
2167 int i, level, nCoeffs;
2168 const uint16_t *quant_matrix;
2171 if(s->alternate_scan) nCoeffs= 63;
2172 else nCoeffs= s->block_last_index[n];
2175 block[0] = block[0] * s->y_dc_scale;
2177 block[0] = block[0] * s->c_dc_scale;
2178 quant_matrix = s->intra_matrix;
2179 for(i=1;i<=nCoeffs;i++) {
2180 int j= s->intra_scantable.permutated[i];
2185 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2188 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2197 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2198 DCTELEM *block, int n, int qscale)
2200 int i, level, nCoeffs;
2201 const uint16_t *quant_matrix;
2204 if(s->alternate_scan) nCoeffs= 63;
2205 else nCoeffs= s->block_last_index[n];
2207 quant_matrix = s->inter_matrix;
2208 for(i=0; i<=nCoeffs; i++) {
2209 int j= s->intra_scantable.permutated[i];
2214 level = (((level << 1) + 1) * qscale *
2215 ((int) (quant_matrix[j]))) >> 4;
2218 level = (((level << 1) + 1) * qscale *
2219 ((int) (quant_matrix[j]))) >> 4;
2228 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2229 DCTELEM *block, int n, int qscale)
2231 int i, level, qmul, qadd;
2234 assert(s->block_last_index[n]>=0);
2240 block[0] = block[0] * s->y_dc_scale;
2242 block[0] = block[0] * s->c_dc_scale;
2243 qadd = (qscale - 1) | 1;
2250 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2252 for(i=1; i<=nCoeffs; i++) {
2256 level = level * qmul - qadd;
2258 level = level * qmul + qadd;
2265 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2266 DCTELEM *block, int n, int qscale)
2268 int i, level, qmul, qadd;
2271 assert(s->block_last_index[n]>=0);
2273 qadd = (qscale - 1) | 1;
2276 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2278 for(i=0; i<=nCoeffs; i++) {
2282 level = level * qmul - qadd;
2284 level = level * qmul + qadd;
2292 * set qscale and update qscale dependent variables.
2294 void ff_set_qscale(MpegEncContext * s, int qscale)
2298 else if (qscale > 31)
2302 s->chroma_qscale= s->chroma_qscale_table[qscale];
2304 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2305 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];