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->pix_fmt == PIX_FMT_NONE){
406 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
410 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
411 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
415 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
418 dsputil_init(&s->dsp, s->avctx);
419 ff_dct_common_init(s);
421 s->flags= s->avctx->flags;
422 s->flags2= s->avctx->flags2;
424 s->mb_width = (s->width + 15) / 16;
425 s->mb_stride = s->mb_width + 1;
426 s->b8_stride = s->mb_width*2 + 1;
427 s->b4_stride = s->mb_width*4 + 1;
428 mb_array_size= s->mb_height * s->mb_stride;
429 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
431 /* set chroma shifts */
432 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
433 &(s->chroma_y_shift) );
435 /* set default edge pos, will be overriden in decode_header if needed */
436 s->h_edge_pos= s->mb_width*16;
437 s->v_edge_pos= s->mb_height*16;
439 s->mb_num = s->mb_width * s->mb_height;
444 s->block_wrap[3]= s->b8_stride;
446 s->block_wrap[5]= s->mb_stride;
448 y_size = s->b8_stride * (2 * s->mb_height + 1);
449 c_size = s->mb_stride * (s->mb_height + 1);
450 yc_size = y_size + 2 * c_size;
452 /* convert fourcc to upper case */
453 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
454 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
455 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
456 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
458 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
459 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
460 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
461 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
463 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
465 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
466 for(y=0; y<s->mb_height; y++){
467 for(x=0; x<s->mb_width; x++){
468 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
471 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
474 /* Allocate MV tables */
475 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
476 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
477 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
478 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
479 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
480 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
481 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
482 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
483 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
484 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
485 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
486 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
488 if(s->msmpeg4_version){
489 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
491 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
493 /* Allocate MB type table */
494 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
496 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
498 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
499 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
500 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
501 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
502 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
503 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
505 if(s->avctx->noise_reduction){
506 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
509 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
511 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
513 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
514 /* interlaced direct mode decoding tables */
519 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
520 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
522 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
523 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
524 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
526 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
529 if (s->out_format == FMT_H263) {
531 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
532 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
533 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
534 s->ac_val[2] = s->ac_val[1] + c_size;
537 CHECKED_ALLOCZ(s->coded_block_base, y_size);
538 s->coded_block= s->coded_block_base + s->b8_stride + 1;
540 /* cbp, ac_pred, pred_dir */
541 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
542 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
545 if (s->h263_pred || s->h263_plus || !s->encoding) {
547 //MN: we need these for error resilience of intra-frames
548 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
549 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
550 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
551 s->dc_val[2] = s->dc_val[1] + c_size;
552 for(i=0;i<yc_size;i++)
553 s->dc_val_base[i] = 1024;
556 /* which mb is a intra block */
557 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
558 memset(s->mbintra_table, 1, mb_array_size);
560 /* init macroblock skip table */
561 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
562 //Note the +1 is for a quicker mpeg4 slice_end detection
563 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
565 s->parse_context.state= -1;
566 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
567 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
568 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
569 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
572 s->context_initialized = 1;
574 s->thread_context[0]= s;
575 threads = s->avctx->thread_count;
577 for(i=1; i<threads; i++){
578 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
579 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
582 for(i=0; i<threads; i++){
583 if(init_duplicate_context(s->thread_context[i], s) < 0)
585 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
586 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
595 /* init common structure for both encoder and decoder */
596 void MPV_common_end(MpegEncContext *s)
600 for(i=0; i<s->avctx->thread_count; i++){
601 free_duplicate_context(s->thread_context[i]);
603 for(i=1; i<s->avctx->thread_count; i++){
604 av_freep(&s->thread_context[i]);
607 av_freep(&s->parse_context.buffer);
608 s->parse_context.buffer_size=0;
610 av_freep(&s->mb_type);
611 av_freep(&s->p_mv_table_base);
612 av_freep(&s->b_forw_mv_table_base);
613 av_freep(&s->b_back_mv_table_base);
614 av_freep(&s->b_bidir_forw_mv_table_base);
615 av_freep(&s->b_bidir_back_mv_table_base);
616 av_freep(&s->b_direct_mv_table_base);
618 s->b_forw_mv_table= NULL;
619 s->b_back_mv_table= NULL;
620 s->b_bidir_forw_mv_table= NULL;
621 s->b_bidir_back_mv_table= NULL;
622 s->b_direct_mv_table= NULL;
626 av_freep(&s->b_field_mv_table_base[i][j][k]);
627 s->b_field_mv_table[i][j][k]=NULL;
629 av_freep(&s->b_field_select_table[i][j]);
630 av_freep(&s->p_field_mv_table_base[i][j]);
631 s->p_field_mv_table[i][j]=NULL;
633 av_freep(&s->p_field_select_table[i]);
636 av_freep(&s->dc_val_base);
637 av_freep(&s->ac_val_base);
638 av_freep(&s->coded_block_base);
639 av_freep(&s->mbintra_table);
640 av_freep(&s->cbp_table);
641 av_freep(&s->pred_dir_table);
643 av_freep(&s->mbskip_table);
644 av_freep(&s->prev_pict_types);
645 av_freep(&s->bitstream_buffer);
646 s->allocated_bitstream_buffer_size=0;
648 av_freep(&s->avctx->stats_out);
649 av_freep(&s->ac_stats);
650 av_freep(&s->error_status_table);
651 av_freep(&s->mb_index2xy);
652 av_freep(&s->lambda_table);
653 av_freep(&s->q_intra_matrix);
654 av_freep(&s->q_inter_matrix);
655 av_freep(&s->q_intra_matrix16);
656 av_freep(&s->q_inter_matrix16);
657 av_freep(&s->input_picture);
658 av_freep(&s->reordered_input_picture);
659 av_freep(&s->dct_offset);
662 for(i=0; i<MAX_PICTURE_COUNT; i++){
663 free_picture(s, &s->picture[i]);
666 av_freep(&s->picture);
667 s->context_initialized = 0;
670 s->current_picture_ptr= NULL;
671 s->linesize= s->uvlinesize= 0;
674 av_freep(&s->visualization_buffer[i]);
676 avcodec_default_free_buffers(s->avctx);
679 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
681 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
682 uint8_t index_run[MAX_RUN+1];
683 int last, run, level, start, end, i;
685 /* If table is static, we can quit if rl->max_level[0] is not NULL */
686 if(static_store && rl->max_level[0])
689 /* compute max_level[], max_run[] and index_run[] */
690 for(last=0;last<2;last++) {
699 memset(max_level, 0, MAX_RUN + 1);
700 memset(max_run, 0, MAX_LEVEL + 1);
701 memset(index_run, rl->n, MAX_RUN + 1);
702 for(i=start;i<end;i++) {
703 run = rl->table_run[i];
704 level = rl->table_level[i];
705 if (index_run[run] == rl->n)
707 if (level > max_level[run])
708 max_level[run] = level;
709 if (run > max_run[level])
710 max_run[level] = run;
713 rl->max_level[last] = static_store[last];
715 rl->max_level[last] = av_malloc(MAX_RUN + 1);
716 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
718 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
720 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
721 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
723 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
725 rl->index_run[last] = av_malloc(MAX_RUN + 1);
726 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
730 void init_vlc_rl(RLTable *rl)
742 for(i=0; i<rl->vlc.table_size; i++){
743 int code= rl->vlc.table[i][0];
744 int len = rl->vlc.table[i][1];
747 if(len==0){ // illegal code
750 }else if(len<0){ //more bits needed
754 if(code==rl->n){ //esc
758 run= rl->table_run [code] + 1;
759 level= rl->table_level[code] * qmul + qadd;
760 if(code >= rl->last) run+=192;
763 rl->rl_vlc[q][i].len= len;
764 rl->rl_vlc[q][i].level= level;
765 rl->rl_vlc[q][i].run= run;
770 int ff_find_unused_picture(MpegEncContext *s, int shared){
774 for(i=0; i<MAX_PICTURE_COUNT; i++){
775 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
778 for(i=0; i<MAX_PICTURE_COUNT; i++){
779 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
781 for(i=0; i<MAX_PICTURE_COUNT; i++){
782 if(s->picture[i].data[0]==NULL) return i;
786 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
787 /* We could return -1, but the codec would crash trying to draw into a
788 * non-existing frame anyway. This is safer than waiting for a random crash.
789 * Also the return of this is never useful, an encoder must only allocate
790 * as much as allowed in the specification. This has no relationship to how
791 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
792 * enough for such valid streams).
793 * Plus, a decoder has to check stream validity and remove frames if too
794 * many reference frames are around. Waiting for "OOM" is not correct at
795 * all. Similarly, missing reference frames have to be replaced by
796 * interpolated/MC frames, anything else is a bug in the codec ...
802 static void update_noise_reduction(MpegEncContext *s){
805 for(intra=0; intra<2; intra++){
806 if(s->dct_count[intra] > (1<<16)){
808 s->dct_error_sum[intra][i] >>=1;
810 s->dct_count[intra] >>= 1;
814 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);
820 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
822 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
828 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
830 /* mark&release old frames */
831 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]) {
832 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
833 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
835 /* release forgotten pictures */
836 /* if(mpeg124/h263) */
838 for(i=0; i<MAX_PICTURE_COUNT; i++){
839 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
840 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
841 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
849 /* release non reference frames */
850 for(i=0; i<MAX_PICTURE_COUNT; i++){
851 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
852 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
856 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
857 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
859 i= ff_find_unused_picture(s, 0);
860 pic= (AVFrame*)&s->picture[i];
865 if (s->codec_id == CODEC_ID_H264)
866 pic->reference = s->picture_structure;
867 else if (s->pict_type != FF_B_TYPE)
871 pic->coded_picture_number= s->coded_picture_number++;
873 if( alloc_picture(s, (Picture*)pic, 0) < 0)
876 s->current_picture_ptr= (Picture*)pic;
877 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
878 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
881 s->current_picture_ptr->pict_type= s->pict_type;
882 // if(s->flags && CODEC_FLAG_QSCALE)
883 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
884 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
886 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
888 if (s->pict_type != FF_B_TYPE) {
889 s->last_picture_ptr= s->next_picture_ptr;
891 s->next_picture_ptr= s->current_picture_ptr;
893 /* 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,
894 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
895 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
896 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
897 s->pict_type, s->dropable);*/
899 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
900 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
902 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){
903 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
904 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
908 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
910 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
913 if(s->picture_structure == PICT_BOTTOM_FIELD){
914 s->current_picture.data[i] += s->current_picture.linesize[i];
916 s->current_picture.linesize[i] *= 2;
917 s->last_picture.linesize[i] *=2;
918 s->next_picture.linesize[i] *=2;
922 s->hurry_up= s->avctx->hurry_up;
923 s->error_recognition= avctx->error_recognition;
925 /* set dequantizer, we can't do it during init as it might change for mpeg4
926 and we can't do it in the header decode as init is not called for mpeg4 there yet */
927 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
928 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
929 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
930 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
931 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
932 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
934 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
935 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
938 if(s->dct_error_sum){
939 assert(s->avctx->noise_reduction && s->encoding);
941 update_noise_reduction(s);
944 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
945 return ff_xvmc_field_start(s, avctx);
950 /* generic function for encode/decode called after a frame has been coded/decoded */
951 void MPV_frame_end(MpegEncContext *s)
954 /* draw edge for correct motion prediction if outside */
955 //just to make sure that all data is rendered.
956 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
957 ff_xvmc_field_end(s);
958 }else if(!(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
959 && s->unrestricted_mv
960 && s->current_picture.reference
962 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
963 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
964 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
965 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
969 s->last_pict_type = s->pict_type;
970 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
971 if(s->pict_type!=FF_B_TYPE){
972 s->last_non_b_pict_type= s->pict_type;
975 /* copy back current_picture variables */
976 for(i=0; i<MAX_PICTURE_COUNT; i++){
977 if(s->picture[i].data[0] == s->current_picture.data[0]){
978 s->picture[i]= s->current_picture;
982 assert(i<MAX_PICTURE_COUNT);
986 /* release non-reference frames */
987 for(i=0; i<MAX_PICTURE_COUNT; i++){
988 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
989 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
993 // clear copies, to avoid confusion
995 memset(&s->last_picture, 0, sizeof(Picture));
996 memset(&s->next_picture, 0, sizeof(Picture));
997 memset(&s->current_picture, 0, sizeof(Picture));
999 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1003 * draws an line from (ex, ey) -> (sx, sy).
1004 * @param w width of the image
1005 * @param h height of the image
1006 * @param stride stride/linesize of the image
1007 * @param color color of the arrow
1009 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1012 sx= av_clip(sx, 0, w-1);
1013 sy= av_clip(sy, 0, h-1);
1014 ex= av_clip(ex, 0, w-1);
1015 ey= av_clip(ey, 0, h-1);
1017 buf[sy*stride + sx]+= color;
1019 if(FFABS(ex - sx) > FFABS(ey - sy)){
1021 FFSWAP(int, sx, ex);
1022 FFSWAP(int, sy, ey);
1024 buf+= sx + sy*stride;
1026 f= ((ey-sy)<<16)/ex;
1027 for(x= 0; x <= ex; x++){
1030 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1031 buf[(y+1)*stride + x]+= (color* fr )>>16;
1035 FFSWAP(int, sx, ex);
1036 FFSWAP(int, sy, ey);
1038 buf+= sx + sy*stride;
1040 if(ey) f= ((ex-sx)<<16)/ey;
1042 for(y= 0; y <= ey; y++){
1045 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1046 buf[y*stride + x+1]+= (color* fr )>>16;
1052 * draws an arrow from (ex, ey) -> (sx, sy).
1053 * @param w width of the image
1054 * @param h height of the image
1055 * @param stride stride/linesize of the image
1056 * @param color color of the arrow
1058 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1061 sx= av_clip(sx, -100, w+100);
1062 sy= av_clip(sy, -100, h+100);
1063 ex= av_clip(ex, -100, w+100);
1064 ey= av_clip(ey, -100, h+100);
1069 if(dx*dx + dy*dy > 3*3){
1072 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1074 //FIXME subpixel accuracy
1075 rx= ROUNDED_DIV(rx*3<<4, length);
1076 ry= ROUNDED_DIV(ry*3<<4, length);
1078 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1079 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1081 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1085 * prints debuging info for the given picture.
1087 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1089 if(!pict || !pict->mb_type) return;
1091 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1094 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1095 switch (pict->pict_type) {
1096 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1097 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1098 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1099 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1100 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1101 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1103 for(y=0; y<s->mb_height; y++){
1104 for(x=0; x<s->mb_width; x++){
1105 if(s->avctx->debug&FF_DEBUG_SKIP){
1106 int count= s->mbskip_table[x + y*s->mb_stride];
1107 if(count>9) count=9;
1108 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1110 if(s->avctx->debug&FF_DEBUG_QP){
1111 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1113 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1114 int mb_type= pict->mb_type[x + y*s->mb_stride];
1115 //Type & MV direction
1117 av_log(s->avctx, AV_LOG_DEBUG, "P");
1118 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1119 av_log(s->avctx, AV_LOG_DEBUG, "A");
1120 else if(IS_INTRA4x4(mb_type))
1121 av_log(s->avctx, AV_LOG_DEBUG, "i");
1122 else if(IS_INTRA16x16(mb_type))
1123 av_log(s->avctx, AV_LOG_DEBUG, "I");
1124 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1125 av_log(s->avctx, AV_LOG_DEBUG, "d");
1126 else if(IS_DIRECT(mb_type))
1127 av_log(s->avctx, AV_LOG_DEBUG, "D");
1128 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "g");
1130 else if(IS_GMC(mb_type))
1131 av_log(s->avctx, AV_LOG_DEBUG, "G");
1132 else if(IS_SKIP(mb_type))
1133 av_log(s->avctx, AV_LOG_DEBUG, "S");
1134 else if(!USES_LIST(mb_type, 1))
1135 av_log(s->avctx, AV_LOG_DEBUG, ">");
1136 else if(!USES_LIST(mb_type, 0))
1137 av_log(s->avctx, AV_LOG_DEBUG, "<");
1139 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1140 av_log(s->avctx, AV_LOG_DEBUG, "X");
1145 av_log(s->avctx, AV_LOG_DEBUG, "+");
1146 else if(IS_16X8(mb_type))
1147 av_log(s->avctx, AV_LOG_DEBUG, "-");
1148 else if(IS_8X16(mb_type))
1149 av_log(s->avctx, AV_LOG_DEBUG, "|");
1150 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1151 av_log(s->avctx, AV_LOG_DEBUG, " ");
1153 av_log(s->avctx, AV_LOG_DEBUG, "?");
1156 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1157 av_log(s->avctx, AV_LOG_DEBUG, "=");
1159 av_log(s->avctx, AV_LOG_DEBUG, " ");
1161 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1163 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1167 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1168 const int shift= 1 + s->quarter_sample;
1172 int h_chroma_shift, v_chroma_shift, block_height;
1173 const int width = s->avctx->width;
1174 const int height= s->avctx->height;
1175 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1176 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1177 s->low_delay=0; //needed to see the vectors without trashing the buffers
1179 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1181 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1182 pict->data[i]= s->visualization_buffer[i];
1184 pict->type= FF_BUFFER_TYPE_COPY;
1186 block_height = 16>>v_chroma_shift;
1188 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1190 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1191 const int mb_index= mb_x + mb_y*s->mb_stride;
1192 if((s->avctx->debug_mv) && pict->motion_val){
1194 for(type=0; type<3; type++){
1197 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1201 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1205 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1210 if(!USES_LIST(pict->mb_type[mb_index], direction))
1213 if(IS_8X8(pict->mb_type[mb_index])){
1216 int sx= mb_x*16 + 4 + 8*(i&1);
1217 int sy= mb_y*16 + 4 + 8*(i>>1);
1218 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1219 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1220 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1221 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1223 }else if(IS_16X8(pict->mb_type[mb_index])){
1227 int sy=mb_y*16 + 4 + 8*i;
1228 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1229 int mx=(pict->motion_val[direction][xy][0]>>shift);
1230 int my=(pict->motion_val[direction][xy][1]>>shift);
1232 if(IS_INTERLACED(pict->mb_type[mb_index]))
1235 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1237 }else if(IS_8X16(pict->mb_type[mb_index])){
1240 int sx=mb_x*16 + 4 + 8*i;
1242 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1243 int mx=(pict->motion_val[direction][xy][0]>>shift);
1244 int my=(pict->motion_val[direction][xy][1]>>shift);
1246 if(IS_INTERLACED(pict->mb_type[mb_index]))
1249 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1252 int sx= mb_x*16 + 8;
1253 int sy= mb_y*16 + 8;
1254 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1255 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1256 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1257 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1261 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1262 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1264 for(y=0; y<block_height; y++){
1265 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1266 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1269 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1270 int mb_type= pict->mb_type[mb_index];
1273 #define COLOR(theta, r)\
1274 u= (int)(128 + r*cos(theta*3.141592/180));\
1275 v= (int)(128 + r*sin(theta*3.141592/180));
1279 if(IS_PCM(mb_type)){
1281 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1283 }else if(IS_INTRA4x4(mb_type)){
1285 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1287 }else if(IS_DIRECT(mb_type)){
1289 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1291 }else if(IS_GMC(mb_type)){
1293 }else if(IS_SKIP(mb_type)){
1295 }else if(!USES_LIST(mb_type, 1)){
1297 }else if(!USES_LIST(mb_type, 0)){
1300 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1304 u*= 0x0101010101010101ULL;
1305 v*= 0x0101010101010101ULL;
1306 for(y=0; y<block_height; y++){
1307 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1308 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1312 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1313 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1314 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1316 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1318 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1320 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1321 int dm= 1 << (mv_sample_log2-2);
1323 int sx= mb_x*16 + 8*(i&1);
1324 int sy= mb_y*16 + 8*(i>>1);
1325 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1327 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1328 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1330 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1331 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1332 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1336 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1340 s->mbskip_table[mb_index]=0;
1346 static inline int hpel_motion_lowres(MpegEncContext *s,
1347 uint8_t *dest, uint8_t *src,
1348 int field_based, int field_select,
1349 int src_x, int src_y,
1350 int width, int height, int stride,
1351 int h_edge_pos, int v_edge_pos,
1352 int w, int h, h264_chroma_mc_func *pix_op,
1353 int motion_x, int motion_y)
1355 const int lowres= s->avctx->lowres;
1356 const int s_mask= (2<<lowres)-1;
1360 if(s->quarter_sample){
1365 sx= motion_x & s_mask;
1366 sy= motion_y & s_mask;
1367 src_x += motion_x >> (lowres+1);
1368 src_y += motion_y >> (lowres+1);
1370 src += src_y * stride + src_x;
1372 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1373 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1374 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1375 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1376 src= s->edge_emu_buffer;
1384 pix_op[lowres](dest, src, stride, h, sx, sy);
1388 /* apply one mpeg motion vector to the three components */
1389 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1390 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1391 int field_based, int bottom_field, int field_select,
1392 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1393 int motion_x, int motion_y, int h)
1395 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1396 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1397 const int lowres= s->avctx->lowres;
1398 const int block_s= 8>>lowres;
1399 const int s_mask= (2<<lowres)-1;
1400 const int h_edge_pos = s->h_edge_pos >> lowres;
1401 const int v_edge_pos = s->v_edge_pos >> lowres;
1402 linesize = s->current_picture.linesize[0] << field_based;
1403 uvlinesize = s->current_picture.linesize[1] << field_based;
1405 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1411 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1414 sx= motion_x & s_mask;
1415 sy= motion_y & s_mask;
1416 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1417 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1419 if (s->out_format == FMT_H263) {
1420 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1421 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1424 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1427 uvsx = (2*mx) & s_mask;
1428 uvsy = (2*my) & s_mask;
1429 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1430 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1436 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1437 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1440 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1441 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1442 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1444 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1445 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1446 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1447 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1448 ptr_y = s->edge_emu_buffer;
1449 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1450 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1451 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1452 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1453 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1454 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1460 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1461 dest_y += s->linesize;
1462 dest_cb+= s->uvlinesize;
1463 dest_cr+= s->uvlinesize;
1467 ptr_y += s->linesize;
1468 ptr_cb+= s->uvlinesize;
1469 ptr_cr+= s->uvlinesize;
1474 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1476 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1477 uvsx <<= 2 - lowres;
1478 uvsy <<= 2 - lowres;
1479 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1480 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1482 //FIXME h261 lowres loop filter
1485 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1486 uint8_t *dest_cb, uint8_t *dest_cr,
1487 uint8_t **ref_picture,
1488 h264_chroma_mc_func *pix_op,
1490 const int lowres= s->avctx->lowres;
1491 const int block_s= 8>>lowres;
1492 const int s_mask= (2<<lowres)-1;
1493 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1494 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1495 int emu=0, src_x, src_y, offset, sx, sy;
1498 if(s->quarter_sample){
1503 /* In case of 8X8, we construct a single chroma motion vector
1504 with a special rounding */
1505 mx= ff_h263_round_chroma(mx);
1506 my= ff_h263_round_chroma(my);
1510 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1511 src_y = s->mb_y*block_s + (my >> (lowres+1));
1513 offset = src_y * s->uvlinesize + src_x;
1514 ptr = ref_picture[1] + offset;
1515 if(s->flags&CODEC_FLAG_EMU_EDGE){
1516 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1517 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1518 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1519 ptr= s->edge_emu_buffer;
1525 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1527 ptr = ref_picture[2] + offset;
1529 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1530 ptr= s->edge_emu_buffer;
1532 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1536 * motion compensation of a single macroblock
1538 * @param dest_y luma destination pointer
1539 * @param dest_cb chroma cb/u destination pointer
1540 * @param dest_cr chroma cr/v destination pointer
1541 * @param dir direction (0->forward, 1->backward)
1542 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1543 * @param pic_op halfpel motion compensation function (average or put normally)
1544 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1546 static inline void MPV_motion_lowres(MpegEncContext *s,
1547 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1548 int dir, uint8_t **ref_picture,
1549 h264_chroma_mc_func *pix_op)
1553 const int lowres= s->avctx->lowres;
1554 const int block_s= 8>>lowres;
1559 switch(s->mv_type) {
1561 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1563 ref_picture, pix_op,
1564 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1570 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1571 ref_picture[0], 0, 0,
1572 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1573 s->width, s->height, s->linesize,
1574 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1575 block_s, block_s, pix_op,
1576 s->mv[dir][i][0], s->mv[dir][i][1]);
1578 mx += s->mv[dir][i][0];
1579 my += s->mv[dir][i][1];
1582 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1583 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1586 if (s->picture_structure == PICT_FRAME) {
1588 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1589 1, 0, s->field_select[dir][0],
1590 ref_picture, pix_op,
1591 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1593 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1594 1, 1, s->field_select[dir][1],
1595 ref_picture, pix_op,
1596 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1598 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1599 ref_picture= s->current_picture_ptr->data;
1602 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1603 0, 0, s->field_select[dir][0],
1604 ref_picture, pix_op,
1605 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1610 uint8_t ** ref2picture;
1612 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1613 ref2picture= ref_picture;
1615 ref2picture= s->current_picture_ptr->data;
1618 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1619 0, 0, s->field_select[dir][i],
1620 ref2picture, pix_op,
1621 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1623 dest_y += 2*block_s*s->linesize;
1624 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1625 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1629 if(s->picture_structure == PICT_FRAME){
1633 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1635 ref_picture, pix_op,
1636 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1638 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1642 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1643 0, 0, s->picture_structure != i+1,
1644 ref_picture, pix_op,
1645 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1647 // after put we make avg of the same block
1648 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1650 //opposite parity is always in the same frame if this is second field
1651 if(!s->first_field){
1652 ref_picture = s->current_picture_ptr->data;
1661 /* put block[] to dest[] */
1662 static inline void put_dct(MpegEncContext *s,
1663 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1665 s->dct_unquantize_intra(s, block, i, qscale);
1666 s->dsp.idct_put (dest, line_size, block);
1669 /* add block[] to dest[] */
1670 static inline void add_dct(MpegEncContext *s,
1671 DCTELEM *block, int i, uint8_t *dest, int line_size)
1673 if (s->block_last_index[i] >= 0) {
1674 s->dsp.idct_add (dest, line_size, block);
1678 static inline void add_dequant_dct(MpegEncContext *s,
1679 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1681 if (s->block_last_index[i] >= 0) {
1682 s->dct_unquantize_inter(s, block, i, qscale);
1684 s->dsp.idct_add (dest, line_size, block);
1689 * cleans dc, ac, coded_block for the current non intra MB
1691 void ff_clean_intra_table_entries(MpegEncContext *s)
1693 int wrap = s->b8_stride;
1694 int xy = s->block_index[0];
1697 s->dc_val[0][xy + 1 ] =
1698 s->dc_val[0][xy + wrap] =
1699 s->dc_val[0][xy + 1 + wrap] = 1024;
1701 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1702 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1703 if (s->msmpeg4_version>=3) {
1704 s->coded_block[xy ] =
1705 s->coded_block[xy + 1 ] =
1706 s->coded_block[xy + wrap] =
1707 s->coded_block[xy + 1 + wrap] = 0;
1710 wrap = s->mb_stride;
1711 xy = s->mb_x + s->mb_y * wrap;
1713 s->dc_val[2][xy] = 1024;
1715 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1716 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1718 s->mbintra_table[xy]= 0;
1721 /* generic function called after a macroblock has been parsed by the
1722 decoder or after it has been encoded by the encoder.
1724 Important variables used:
1725 s->mb_intra : true if intra macroblock
1726 s->mv_dir : motion vector direction
1727 s->mv_type : motion vector type
1728 s->mv : motion vector
1729 s->interlaced_dct : true if interlaced dct used (mpeg2)
1731 static av_always_inline
1732 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1733 int lowres_flag, int is_mpeg12)
1736 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1737 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1738 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1745 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1746 /* save DCT coefficients */
1748 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1751 *dct++ = block[i][s->dsp.idct_permutation[j]];
1754 s->current_picture.qscale_table[mb_xy]= s->qscale;
1756 /* update DC predictors for P macroblocks */
1758 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1759 if(s->mbintra_table[mb_xy])
1760 ff_clean_intra_table_entries(s);
1764 s->last_dc[2] = 128 << s->intra_dc_precision;
1767 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1768 s->mbintra_table[mb_xy]=1;
1770 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
1771 uint8_t *dest_y, *dest_cb, *dest_cr;
1772 int dct_linesize, dct_offset;
1773 op_pixels_func (*op_pix)[4];
1774 qpel_mc_func (*op_qpix)[16];
1775 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1776 const int uvlinesize= s->current_picture.linesize[1];
1777 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1778 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1780 /* avoid copy if macroblock skipped in last frame too */
1781 /* skip only during decoding as we might trash the buffers during encoding a bit */
1783 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1784 const int age= s->current_picture.age;
1788 if (s->mb_skipped) {
1790 assert(s->pict_type!=FF_I_TYPE);
1792 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1793 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1795 /* if previous was skipped too, then nothing to do ! */
1796 if (*mbskip_ptr >= age && s->current_picture.reference){
1799 } else if(!s->current_picture.reference){
1800 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1801 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1803 *mbskip_ptr = 0; /* not skipped */
1807 dct_linesize = linesize << s->interlaced_dct;
1808 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1812 dest_cb= s->dest[1];
1813 dest_cr= s->dest[2];
1815 dest_y = s->b_scratchpad;
1816 dest_cb= s->b_scratchpad+16*linesize;
1817 dest_cr= s->b_scratchpad+32*linesize;
1821 /* motion handling */
1822 /* decoding or more than one mb_type (MC was already done otherwise) */
1825 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1827 if (s->mv_dir & MV_DIR_FORWARD) {
1828 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1829 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1831 if (s->mv_dir & MV_DIR_BACKWARD) {
1832 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1835 op_qpix= s->me.qpel_put;
1836 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1837 op_pix = s->dsp.put_pixels_tab;
1839 op_pix = s->dsp.put_no_rnd_pixels_tab;
1841 if (s->mv_dir & MV_DIR_FORWARD) {
1842 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1843 op_pix = s->dsp.avg_pixels_tab;
1844 op_qpix= s->me.qpel_avg;
1846 if (s->mv_dir & MV_DIR_BACKWARD) {
1847 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1852 /* skip dequant / idct if we are really late ;) */
1853 if(s->hurry_up>1) goto skip_idct;
1854 if(s->avctx->skip_idct){
1855 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1856 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1857 || s->avctx->skip_idct >= AVDISCARD_ALL)
1861 /* add dct residue */
1862 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1863 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1864 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1865 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1866 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1867 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1869 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1870 if (s->chroma_y_shift){
1871 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1872 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1876 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1877 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1878 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1879 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1882 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1883 add_dct(s, block[0], 0, dest_y , dct_linesize);
1884 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1885 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1886 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1888 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1889 if(s->chroma_y_shift){//Chroma420
1890 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1891 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1894 dct_linesize = uvlinesize << s->interlaced_dct;
1895 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1897 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1898 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1899 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1900 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1901 if(!s->chroma_x_shift){//Chroma444
1902 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1903 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1904 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1905 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1910 else if (CONFIG_WMV2) {
1911 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1914 /* dct only in intra block */
1915 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1916 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1917 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1918 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1919 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1921 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1922 if(s->chroma_y_shift){
1923 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1924 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1928 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1929 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1930 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1931 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1935 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1936 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1937 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1938 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1940 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1941 if(s->chroma_y_shift){
1942 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1943 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1946 dct_linesize = uvlinesize << s->interlaced_dct;
1947 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1949 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1950 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1951 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1952 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1953 if(!s->chroma_x_shift){//Chroma444
1954 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1955 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1956 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1957 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1965 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1966 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1967 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1972 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1974 if(s->out_format == FMT_MPEG1) {
1975 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1976 else MPV_decode_mb_internal(s, block, 0, 1);
1979 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1980 else MPV_decode_mb_internal(s, block, 0, 0);
1985 * @param h is the normal height, this will be reduced automatically if needed for the last row
1987 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1988 if (s->avctx->draw_horiz_band) {
1992 if(s->picture_structure != PICT_FRAME){
1995 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
1998 h= FFMIN(h, s->avctx->height - y);
2000 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2001 src= (AVFrame*)s->current_picture_ptr;
2002 else if(s->last_picture_ptr)
2003 src= (AVFrame*)s->last_picture_ptr;
2007 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2013 offset[0]= y * s->linesize;
2015 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2021 s->avctx->draw_horiz_band(s->avctx, src, offset,
2022 y, s->picture_structure, h);
2026 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2027 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2028 const int uvlinesize= s->current_picture.linesize[1];
2029 const int mb_size= 4 - s->avctx->lowres;
2031 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2032 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2033 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2034 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2035 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2036 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;
2037 //block_index is not used by mpeg2, so it is not affected by chroma_format
2039 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2040 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2041 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2043 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2045 s->dest[0] += s->mb_y * linesize << mb_size;
2046 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2047 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2051 void ff_mpeg_flush(AVCodecContext *avctx){
2053 MpegEncContext *s = avctx->priv_data;
2055 if(s==NULL || s->picture==NULL)
2058 for(i=0; i<MAX_PICTURE_COUNT; i++){
2059 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2060 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2061 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2063 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2065 s->mb_x= s->mb_y= 0;
2067 s->parse_context.state= -1;
2068 s->parse_context.frame_start_found= 0;
2069 s->parse_context.overread= 0;
2070 s->parse_context.overread_index= 0;
2071 s->parse_context.index= 0;
2072 s->parse_context.last_index= 0;
2073 s->bitstream_buffer_size=0;
2077 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2078 DCTELEM *block, int n, int qscale)
2080 int i, level, nCoeffs;
2081 const uint16_t *quant_matrix;
2083 nCoeffs= s->block_last_index[n];
2086 block[0] = block[0] * s->y_dc_scale;
2088 block[0] = block[0] * s->c_dc_scale;
2089 /* XXX: only mpeg1 */
2090 quant_matrix = s->intra_matrix;
2091 for(i=1;i<=nCoeffs;i++) {
2092 int j= s->intra_scantable.permutated[i];
2097 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2098 level = (level - 1) | 1;
2101 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2102 level = (level - 1) | 1;
2109 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2110 DCTELEM *block, int n, int qscale)
2112 int i, level, nCoeffs;
2113 const uint16_t *quant_matrix;
2115 nCoeffs= s->block_last_index[n];
2117 quant_matrix = s->inter_matrix;
2118 for(i=0; i<=nCoeffs; i++) {
2119 int j= s->intra_scantable.permutated[i];
2124 level = (((level << 1) + 1) * qscale *
2125 ((int) (quant_matrix[j]))) >> 4;
2126 level = (level - 1) | 1;
2129 level = (((level << 1) + 1) * qscale *
2130 ((int) (quant_matrix[j]))) >> 4;
2131 level = (level - 1) | 1;
2138 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2139 DCTELEM *block, int n, int qscale)
2141 int i, level, nCoeffs;
2142 const uint16_t *quant_matrix;
2144 if(s->alternate_scan) nCoeffs= 63;
2145 else nCoeffs= s->block_last_index[n];
2148 block[0] = block[0] * s->y_dc_scale;
2150 block[0] = block[0] * s->c_dc_scale;
2151 quant_matrix = s->intra_matrix;
2152 for(i=1;i<=nCoeffs;i++) {
2153 int j= s->intra_scantable.permutated[i];
2158 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2161 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2168 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2169 DCTELEM *block, int n, int qscale)
2171 int i, level, nCoeffs;
2172 const uint16_t *quant_matrix;
2175 if(s->alternate_scan) nCoeffs= 63;
2176 else nCoeffs= s->block_last_index[n];
2179 block[0] = block[0] * s->y_dc_scale;
2181 block[0] = block[0] * s->c_dc_scale;
2182 quant_matrix = s->intra_matrix;
2183 for(i=1;i<=nCoeffs;i++) {
2184 int j= s->intra_scantable.permutated[i];
2189 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2192 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2201 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2202 DCTELEM *block, int n, int qscale)
2204 int i, level, nCoeffs;
2205 const uint16_t *quant_matrix;
2208 if(s->alternate_scan) nCoeffs= 63;
2209 else nCoeffs= s->block_last_index[n];
2211 quant_matrix = s->inter_matrix;
2212 for(i=0; i<=nCoeffs; i++) {
2213 int j= s->intra_scantable.permutated[i];
2218 level = (((level << 1) + 1) * qscale *
2219 ((int) (quant_matrix[j]))) >> 4;
2222 level = (((level << 1) + 1) * qscale *
2223 ((int) (quant_matrix[j]))) >> 4;
2232 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2233 DCTELEM *block, int n, int qscale)
2235 int i, level, qmul, qadd;
2238 assert(s->block_last_index[n]>=0);
2244 block[0] = block[0] * s->y_dc_scale;
2246 block[0] = block[0] * s->c_dc_scale;
2247 qadd = (qscale - 1) | 1;
2254 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2256 for(i=1; i<=nCoeffs; i++) {
2260 level = level * qmul - qadd;
2262 level = level * qmul + qadd;
2269 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2270 DCTELEM *block, int n, int qscale)
2272 int i, level, qmul, qadd;
2275 assert(s->block_last_index[n]>=0);
2277 qadd = (qscale - 1) | 1;
2280 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2282 for(i=0; i<=nCoeffs; i++) {
2286 level = level * qmul - qadd;
2288 level = level * qmul + qadd;
2296 * set qscale and update qscale dependent variables.
2298 void ff_set_qscale(MpegEncContext * s, int qscale)
2302 else if (qscale > 31)
2306 s->chroma_qscale= s->chroma_qscale_table[qscale];
2308 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2309 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];