1/* 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> 5 * 6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> 7 * 8 * This file is part of FFmpeg. 9 * 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. 14 * 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. 19 * 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 23 */ 24 25/** 26 * @file libavcodec/mpegvideo.c 27 * The simplest mpeg encoder (well, it was the simplest!). 28 */ 29 30#include "avcodec.h" 31#include "dsputil.h" 32#include "mpegvideo.h" 33#include "mpegvideo_common.h" 34#include "mjpegenc.h" 35#include "msmpeg4.h" 36#include "faandct.h" 37#include "xvmc_internal.h" 38#include <limits.h> 39 40//#undef NDEBUG 41//#include <assert.h> 42 43static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 44 DCTELEM *block, int n, int qscale); 45static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 46 DCTELEM *block, int n, int qscale); 47static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, 48 DCTELEM *block, int n, int qscale); 49static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, 50 DCTELEM *block, int n, int qscale); 51static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, 52 DCTELEM *block, int n, int qscale); 53static void dct_unquantize_h263_intra_c(MpegEncContext *s, 54 DCTELEM *block, int n, int qscale); 55static void dct_unquantize_h263_inter_c(MpegEncContext *s, 56 DCTELEM *block, int n, int qscale); 57 58 59/* enable all paranoid tests for rounding, overflows, etc... */ 60//#define PARANOID 61 62//#define DEBUG 63 64 65static 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 68}; 69 70const 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, 76}; 77 78const enum PixelFormat ff_pixfmt_list_420[] = { 79 PIX_FMT_YUV420P, 80 PIX_FMT_NONE 81}; 82 83const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = { 84 PIX_FMT_YUV420P, 85 PIX_FMT_NONE 86}; 87 88const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){ 89 int i; 90 91 assert(p<=end); 92 if(p>=end) 93 return end; 94 95 for(i=0; i<3; i++){ 96 uint32_t tmp= *state << 8; 97 *state= tmp + *(p++); 98 if(tmp == 0x100 || p==end) 99 return p; 100 } 101 102 while(p<end){ 103 if (p[-1] > 1 ) p+= 3; 104 else if(p[-2] ) p+= 2; 105 else if(p[-3]|(p[-1]-1)) p++; 106 else{ 107 p++; 108 break; 109 } 110 } 111 112 p= FFMIN(p, end)-4; 113 *state= AV_RB32(p); 114 115 return p+4; 116} 117 118/* init common dct for both encoder and decoder */ 119av_cold int ff_dct_common_init(MpegEncContext *s) 120{ 121 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; 122 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; 123 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; 124 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; 125 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; 126 if(s->flags & CODEC_FLAG_BITEXACT) 127 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; 128 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; 129 130#if HAVE_MMX 131 MPV_common_init_mmx(s); 132#elif ARCH_ALPHA 133 MPV_common_init_axp(s); 134#elif CONFIG_MLIB 135 MPV_common_init_mlib(s); 136#elif HAVE_MMI 137 MPV_common_init_mmi(s); 138#elif ARCH_ARM 139 MPV_common_init_arm(s); 140#elif HAVE_ALTIVEC 141 MPV_common_init_altivec(s); 142#elif ARCH_BFIN 143 MPV_common_init_bfin(s); 144#endif 145 146 /* load & permutate scantables 147 note: only wmv uses different ones 148 */ 149 if(s->alternate_scan){ 150 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan); 151 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan); 152 }else{ 153 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct); 154 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct); 155 } 156 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); 157 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); 158 159 return 0; 160} 161 162void ff_copy_picture(Picture *dst, Picture *src){ 163 *dst = *src; 164 dst->type= FF_BUFFER_TYPE_COPY; 165} 166 167/** 168 * allocates a Picture 169 * The pixels are allocated/set by calling get_buffer() if shared=0 170 */ 171int alloc_picture(MpegEncContext *s, Picture *pic, int shared){ 172 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11 173 const int mb_array_size= s->mb_stride*s->mb_height; 174 const int b8_array_size= s->b8_stride*s->mb_height*2; 175 const int b4_array_size= s->b4_stride*s->mb_height*4; 176 int i; 177 int r= -1; 178 179 if(shared){ 180 assert(pic->data[0]); 181 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED); 182 pic->type= FF_BUFFER_TYPE_SHARED; 183 }else{ 184 assert(!pic->data[0]); 185 186 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic); 187 188 if(r<0 || !pic->age || !pic->type || !pic->data[0]){ 189 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]); 190 return -1; 191 } 192 193 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){ 194 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n"); 195 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); 196 return -1; 197 } 198 199 if(pic->linesize[1] != pic->linesize[2]){ 200 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n"); 201 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); 202 return -1; 203 } 204 205 s->linesize = pic->linesize[0]; 206 s->uvlinesize= pic->linesize[1]; 207 } 208 209 if(pic->qscale_table==NULL){ 210 if (s->encoding) { 211 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t)) 212 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t)) 213 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t)) 214 } 215 216 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check 217 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t)) 218 CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t)) 219 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1; 220 if(s->out_format == FMT_H264){ 221 for(i=0; i<2; i++){ 222 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t)) 223 pic->motion_val[i]= pic->motion_val_base[i]+4; 224 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) 225 } 226 pic->motion_subsample_log2= 2; 227 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){ 228 for(i=0; i<2; i++){ 229 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t)) 230 pic->motion_val[i]= pic->motion_val_base[i]+4; 231 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t)) 232 } 233 pic->motion_subsample_log2= 3; 234 } 235 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) { 236 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6) 237 } 238 pic->qstride= s->mb_stride; 239 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan)) 240 } 241 242 /* It might be nicer if the application would keep track of these 243 * but it would require an API change. */ 244 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1); 245 s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type; 246 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE) 247 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. 248 249 return 0; 250fail: //for the CHECKED_ALLOCZ macro 251 if(r>=0) 252 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); 253 return -1; 254} 255 256/** 257 * deallocates a picture 258 */ 259static void free_picture(MpegEncContext *s, Picture *pic){ 260 int i; 261 262 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){ 263 s->avctx->release_buffer(s->avctx, (AVFrame*)pic); 264 } 265 266 av_freep(&pic->mb_var); 267 av_freep(&pic->mc_mb_var); 268 av_freep(&pic->mb_mean); 269 av_freep(&pic->mbskip_table); 270 av_freep(&pic->qscale_table); 271 av_freep(&pic->mb_type_base); 272 av_freep(&pic->dct_coeff); 273 av_freep(&pic->pan_scan); 274 pic->mb_type= NULL; 275 for(i=0; i<2; i++){ 276 av_freep(&pic->motion_val_base[i]); 277 av_freep(&pic->ref_index[i]); 278 } 279 280 if(pic->type == FF_BUFFER_TYPE_SHARED){ 281 for(i=0; i<4; i++){ 282 pic->base[i]= 283 pic->data[i]= NULL; 284 } 285 pic->type= 0; 286 } 287} 288 289static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){ 290 int i; 291 292 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264) 293 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance 294 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21; 295 296 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer() 297 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t)) 298 s->me.temp= s->me.scratchpad; 299 s->rd_scratchpad= s->me.scratchpad; 300 s->b_scratchpad= s->me.scratchpad; 301 s->obmc_scratchpad= s->me.scratchpad + 16; 302 if (s->encoding) { 303 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t)) 304 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t)) 305 if(s->avctx->noise_reduction){ 306 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int)) 307 } 308 } 309 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM)) 310 s->block= s->blocks[0]; 311 312 for(i=0;i<12;i++){ 313 s->pblocks[i] = &s->block[i]; 314 } 315 return 0; 316fail: 317 return -1; //free() through MPV_common_end() 318} 319 320static void free_duplicate_context(MpegEncContext *s){ 321 if(s==NULL) return; 322 323 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL; 324 av_freep(&s->me.scratchpad); 325 s->me.temp= 326 s->rd_scratchpad= 327 s->b_scratchpad= 328 s->obmc_scratchpad= NULL; 329 330 av_freep(&s->dct_error_sum); 331 av_freep(&s->me.map); 332 av_freep(&s->me.score_map); 333 av_freep(&s->blocks); 334 s->block= NULL; 335} 336 337static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){ 338#define COPY(a) bak->a= src->a 339 COPY(allocated_edge_emu_buffer); 340 COPY(edge_emu_buffer); 341 COPY(me.scratchpad); 342 COPY(me.temp); 343 COPY(rd_scratchpad); 344 COPY(b_scratchpad); 345 COPY(obmc_scratchpad); 346 COPY(me.map); 347 COPY(me.score_map); 348 COPY(blocks); 349 COPY(block); 350 COPY(start_mb_y); 351 COPY(end_mb_y); 352 COPY(me.map_generation); 353 COPY(pb); 354 COPY(dct_error_sum); 355 COPY(dct_count[0]); 356 COPY(dct_count[1]); 357#undef COPY 358} 359 360void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){ 361 MpegEncContext bak; 362 int i; 363 //FIXME copy only needed parts 364//START_TIMER 365 backup_duplicate_context(&bak, dst); 366 memcpy(dst, src, sizeof(MpegEncContext)); 367 backup_duplicate_context(dst, &bak); 368 for(i=0;i<12;i++){ 369 dst->pblocks[i] = &dst->block[i]; 370 } 371//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads 372} 373 374/** 375 * sets the given MpegEncContext to common defaults (same for encoding and decoding). 376 * the changed fields will not depend upon the prior state of the MpegEncContext. 377 */ 378void MPV_common_defaults(MpegEncContext *s){ 379 s->y_dc_scale_table= 380 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 381 s->chroma_qscale_table= ff_default_chroma_qscale_table; 382 s->progressive_frame= 1; 383 s->progressive_sequence= 1; 384 s->picture_structure= PICT_FRAME; 385 386 s->coded_picture_number = 0; 387 s->picture_number = 0; 388 s->input_picture_number = 0; 389 390 s->picture_in_gop_number = 0; 391 392 s->f_code = 1; 393 s->b_code = 1; 394} 395 396/** 397 * sets the given MpegEncContext to defaults for decoding. 398 * the changed fields will not depend upon the prior state of the MpegEncContext. 399 */ 400void MPV_decode_defaults(MpegEncContext *s){ 401 MPV_common_defaults(s); 402} 403 404/** 405 * init common structure for both encoder and decoder. 406 * this assumes that some variables like width/height are already set 407 */ 408av_cold int MPV_common_init(MpegEncContext *s) 409{ 410 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads; 411 412 s->mb_height = (s->height + 15) / 16; 413 414 if(s->avctx->pix_fmt == PIX_FMT_NONE){ 415 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n"); 416 return -1; 417 } 418 419 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){ 420 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n"); 421 return -1; 422 } 423 424 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height)) 425 return -1; 426 427 dsputil_init(&s->dsp, s->avctx); 428 ff_dct_common_init(s); 429 430 s->flags= s->avctx->flags; 431 s->flags2= s->avctx->flags2; 432 433 s->mb_width = (s->width + 15) / 16; 434 s->mb_stride = s->mb_width + 1; 435 s->b8_stride = s->mb_width*2 + 1; 436 s->b4_stride = s->mb_width*4 + 1; 437 mb_array_size= s->mb_height * s->mb_stride; 438 mv_table_size= (s->mb_height+2) * s->mb_stride + 1; 439 440 /* set chroma shifts */ 441 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift), 442 &(s->chroma_y_shift) ); 443 444 /* set default edge pos, will be overriden in decode_header if needed */ 445 s->h_edge_pos= s->mb_width*16; 446 s->v_edge_pos= s->mb_height*16; 447 448 s->mb_num = s->mb_width * s->mb_height; 449 450 s->block_wrap[0]= 451 s->block_wrap[1]= 452 s->block_wrap[2]= 453 s->block_wrap[3]= s->b8_stride; 454 s->block_wrap[4]= 455 s->block_wrap[5]= s->mb_stride; 456 457 y_size = s->b8_stride * (2 * s->mb_height + 1); 458 c_size = s->mb_stride * (s->mb_height + 1); 459 yc_size = y_size + 2 * c_size; 460 461 /* convert fourcc to upper case */ 462 s->codec_tag= toupper( s->avctx->codec_tag &0xFF) 463 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 ) 464 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16) 465 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24); 466 467 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF) 468 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 ) 469 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16) 470 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24); 471 472 s->avctx->coded_frame= (AVFrame*)&s->current_picture; 473 474 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this 475 for(y=0; y<s->mb_height; y++){ 476 for(x=0; x<s->mb_width; x++){ 477 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride; 478 } 479 } 480 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed? 481 482 if (s->encoding) { 483 /* Allocate MV tables */ 484 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 485 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 486 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 487 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 488 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 489 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t)) 490 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; 491 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; 492 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; 493 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1; 494 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1; 495 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; 496 497 if(s->msmpeg4_version){ 498 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int)); 499 } 500 CHECKED_ALLOCZ(s->avctx->stats_out, 256); 501 502 /* Allocate MB type table */ 503 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding 504 505 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int)) 506 507 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int)) 508 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int)) 509 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t)) 510 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t)) 511 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) 512 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*)) 513 514 if(s->avctx->noise_reduction){ 515 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t)) 516 } 517 } 518 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture)) 519 520 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t)) 521 522 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){ 523 /* interlaced direct mode decoding tables */ 524 for(i=0; i<2; i++){ 525 int j, k; 526 for(j=0; j<2; j++){ 527 for(k=0; k<2; k++){ 528 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t)) 529 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1; 530 } 531 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t)) 532 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t)) 533 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1; 534 } 535 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t)) 536 } 537 } 538 if (s->out_format == FMT_H263) { 539 /* ac values */ 540 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16); 541 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; 542 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; 543 s->ac_val[2] = s->ac_val[1] + c_size; 544 545 /* cbp values */ 546 CHECKED_ALLOCZ(s->coded_block_base, y_size); 547 s->coded_block= s->coded_block_base + s->b8_stride + 1; 548 549 /* cbp, ac_pred, pred_dir */ 550 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t)) 551 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t)) 552 } 553 554 if (s->h263_pred || s->h263_plus || !s->encoding) { 555 /* dc values */ 556 //MN: we need these for error resilience of intra-frames 557 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t)); 558 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; 559 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; 560 s->dc_val[2] = s->dc_val[1] + c_size; 561 for(i=0;i<yc_size;i++) 562 s->dc_val_base[i] = 1024; 563 } 564 565 /* which mb is a intra block */ 566 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size); 567 memset(s->mbintra_table, 1, mb_array_size); 568 569 /* init macroblock skip table */ 570 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2); 571 //Note the +1 is for a quicker mpeg4 slice_end detection 572 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE); 573 574 s->parse_context.state= -1; 575 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ 576 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH); 577 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH); 578 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH); 579 } 580 581 s->context_initialized = 1; 582 583 s->thread_context[0]= s; 584 threads = s->avctx->thread_count; 585 586 for(i=1; i<threads; i++){ 587 s->thread_context[i]= av_malloc(sizeof(MpegEncContext)); 588 memcpy(s->thread_context[i], s, sizeof(MpegEncContext)); 589 } 590 591 for(i=0; i<threads; i++){ 592 if(init_duplicate_context(s->thread_context[i], s) < 0) 593 goto fail; 594 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count; 595 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count; 596 } 597 598 return 0; 599 fail: 600 MPV_common_end(s); 601 return -1; 602} 603 604/* init common structure for both encoder and decoder */ 605void MPV_common_end(MpegEncContext *s) 606{ 607 int i, j, k; 608 609 for(i=0; i<s->avctx->thread_count; i++){ 610 free_duplicate_context(s->thread_context[i]); 611 } 612 for(i=1; i<s->avctx->thread_count; i++){ 613 av_freep(&s->thread_context[i]); 614 } 615 616 av_freep(&s->parse_context.buffer); 617 s->parse_context.buffer_size=0; 618 619 av_freep(&s->mb_type); 620 av_freep(&s->p_mv_table_base); 621 av_freep(&s->b_forw_mv_table_base); 622 av_freep(&s->b_back_mv_table_base); 623 av_freep(&s->b_bidir_forw_mv_table_base); 624 av_freep(&s->b_bidir_back_mv_table_base); 625 av_freep(&s->b_direct_mv_table_base); 626 s->p_mv_table= NULL; 627 s->b_forw_mv_table= NULL; 628 s->b_back_mv_table= NULL; 629 s->b_bidir_forw_mv_table= NULL; 630 s->b_bidir_back_mv_table= NULL; 631 s->b_direct_mv_table= NULL; 632 for(i=0; i<2; i++){ 633 for(j=0; j<2; j++){ 634 for(k=0; k<2; k++){ 635 av_freep(&s->b_field_mv_table_base[i][j][k]); 636 s->b_field_mv_table[i][j][k]=NULL; 637 } 638 av_freep(&s->b_field_select_table[i][j]); 639 av_freep(&s->p_field_mv_table_base[i][j]); 640 s->p_field_mv_table[i][j]=NULL; 641 } 642 av_freep(&s->p_field_select_table[i]); 643 } 644 645 av_freep(&s->dc_val_base); 646 av_freep(&s->ac_val_base); 647 av_freep(&s->coded_block_base); 648 av_freep(&s->mbintra_table); 649 av_freep(&s->cbp_table); 650 av_freep(&s->pred_dir_table); 651 652 av_freep(&s->mbskip_table); 653 av_freep(&s->prev_pict_types); 654 av_freep(&s->bitstream_buffer); 655 s->allocated_bitstream_buffer_size=0; 656 657 av_freep(&s->avctx->stats_out); 658 av_freep(&s->ac_stats); 659 av_freep(&s->error_status_table); 660 av_freep(&s->mb_index2xy); 661 av_freep(&s->lambda_table); 662 av_freep(&s->q_intra_matrix); 663 av_freep(&s->q_inter_matrix); 664 av_freep(&s->q_intra_matrix16); 665 av_freep(&s->q_inter_matrix16); 666 av_freep(&s->input_picture); 667 av_freep(&s->reordered_input_picture); 668 av_freep(&s->dct_offset); 669 670 if(s->picture){ 671 for(i=0; i<MAX_PICTURE_COUNT; i++){ 672 free_picture(s, &s->picture[i]); 673 } 674 } 675 av_freep(&s->picture); 676 s->context_initialized = 0; 677 s->last_picture_ptr= 678 s->next_picture_ptr= 679 s->current_picture_ptr= NULL; 680 s->linesize= s->uvlinesize= 0; 681 682 for(i=0; i<3; i++) 683 av_freep(&s->visualization_buffer[i]); 684 685 avcodec_default_free_buffers(s->avctx); 686} 687 688void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3]) 689{ 690 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1]; 691 uint8_t index_run[MAX_RUN+1]; 692 int last, run, level, start, end, i; 693 694 /* If table is static, we can quit if rl->max_level[0] is not NULL */ 695 if(static_store && rl->max_level[0]) 696 return; 697 698 /* compute max_level[], max_run[] and index_run[] */ 699 for(last=0;last<2;last++) { 700 if (last == 0) { 701 start = 0; 702 end = rl->last; 703 } else { 704 start = rl->last; 705 end = rl->n; 706 } 707 708 memset(max_level, 0, MAX_RUN + 1); 709 memset(max_run, 0, MAX_LEVEL + 1); 710 memset(index_run, rl->n, MAX_RUN + 1); 711 for(i=start;i<end;i++) { 712 run = rl->table_run[i]; 713 level = rl->table_level[i]; 714 if (index_run[run] == rl->n) 715 index_run[run] = i; 716 if (level > max_level[run]) 717 max_level[run] = level; 718 if (run > max_run[level]) 719 max_run[level] = run; 720 } 721 if(static_store) 722 rl->max_level[last] = static_store[last]; 723 else 724 rl->max_level[last] = av_malloc(MAX_RUN + 1); 725 memcpy(rl->max_level[last], max_level, MAX_RUN + 1); 726 if(static_store) 727 rl->max_run[last] = static_store[last] + MAX_RUN + 1; 728 else 729 rl->max_run[last] = av_malloc(MAX_LEVEL + 1); 730 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1); 731 if(static_store) 732 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2; 733 else 734 rl->index_run[last] = av_malloc(MAX_RUN + 1); 735 memcpy(rl->index_run[last], index_run, MAX_RUN + 1); 736 } 737} 738 739void init_vlc_rl(RLTable *rl) 740{ 741 int i, q; 742 743 for(q=0; q<32; q++){ 744 int qmul= q*2; 745 int qadd= (q-1)|1; 746 747 if(q==0){ 748 qmul=1; 749 qadd=0; 750 } 751 for(i=0; i<rl->vlc.table_size; i++){ 752 int code= rl->vlc.table[i][0]; 753 int len = rl->vlc.table[i][1]; 754 int level, run; 755 756 if(len==0){ // illegal code 757 run= 66; 758 level= MAX_LEVEL; 759 }else if(len<0){ //more bits needed 760 run= 0; 761 level= code; 762 }else{ 763 if(code==rl->n){ //esc 764 run= 66; 765 level= 0; 766 }else{ 767 run= rl->table_run [code] + 1; 768 level= rl->table_level[code] * qmul + qadd; 769 if(code >= rl->last) run+=192; 770 } 771 } 772 rl->rl_vlc[q][i].len= len; 773 rl->rl_vlc[q][i].level= level; 774 rl->rl_vlc[q][i].run= run; 775 } 776 } 777} 778 779int ff_find_unused_picture(MpegEncContext *s, int shared){ 780 int i; 781 782 if(shared){ 783 for(i=0; i<MAX_PICTURE_COUNT; i++){ 784 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i; 785 } 786 }else{ 787 for(i=0; i<MAX_PICTURE_COUNT; i++){ 788 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME 789 } 790 for(i=0; i<MAX_PICTURE_COUNT; i++){ 791 if(s->picture[i].data[0]==NULL) return i; 792 } 793 } 794 795 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n"); 796 /* We could return -1, but the codec would crash trying to draw into a 797 * non-existing frame anyway. This is safer than waiting for a random crash. 798 * Also the return of this is never useful, an encoder must only allocate 799 * as much as allowed in the specification. This has no relationship to how 800 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large 801 * enough for such valid streams). 802 * Plus, a decoder has to check stream validity and remove frames if too 803 * many reference frames are around. Waiting for "OOM" is not correct at 804 * all. Similarly, missing reference frames have to be replaced by 805 * interpolated/MC frames, anything else is a bug in the codec ... 806 */ 807 abort(); 808 return -1; 809} 810 811static void update_noise_reduction(MpegEncContext *s){ 812 int intra, i; 813 814 for(intra=0; intra<2; intra++){ 815 if(s->dct_count[intra] > (1<<16)){ 816 for(i=0; i<64; i++){ 817 s->dct_error_sum[intra][i] >>=1; 818 } 819 s->dct_count[intra] >>= 1; 820 } 821 822 for(i=0; i<64; i++){ 823 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); 824 } 825 } 826} 827 828/** 829 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded 830 */ 831int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx) 832{ 833 int i; 834 AVFrame *pic; 835 s->mb_skipped = 0; 836 837 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3); 838 839 /* mark&release old frames */ 840 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]) { 841 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){ 842 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr); 843 844 /* release forgotten pictures */ 845 /* if(mpeg124/h263) */ 846 if(!s->encoding){ 847 for(i=0; i<MAX_PICTURE_COUNT; i++){ 848 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){ 849 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n"); 850 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); 851 } 852 } 853 } 854 } 855 } 856alloc: 857 if(!s->encoding){ 858 /* release non reference frames */ 859 for(i=0; i<MAX_PICTURE_COUNT; i++){ 860 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ 861 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); 862 } 863 } 864 865 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL) 866 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header) 867 else{ 868 i= ff_find_unused_picture(s, 0); 869 pic= (AVFrame*)&s->picture[i]; 870 } 871 872 pic->reference= 0; 873 if (!s->dropable){ 874 if (s->codec_id == CODEC_ID_H264) 875 pic->reference = s->picture_structure; 876 else if (s->pict_type != FF_B_TYPE) 877 pic->reference = 3; 878 } 879 880 pic->coded_picture_number= s->coded_picture_number++; 881 882 if( alloc_picture(s, (Picture*)pic, 0) < 0) 883 return -1; 884 885 s->current_picture_ptr= (Picture*)pic; 886 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic 887 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence; 888 } 889 890 s->current_picture_ptr->pict_type= s->pict_type; 891// if(s->flags && CODEC_FLAG_QSCALE) 892 // s->current_picture_ptr->quality= s->new_picture_ptr->quality; 893 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE; 894 895 ff_copy_picture(&s->current_picture, s->current_picture_ptr); 896 897 if (s->pict_type != FF_B_TYPE) { 898 s->last_picture_ptr= s->next_picture_ptr; 899 if(!s->dropable) 900 s->next_picture_ptr= s->current_picture_ptr; 901 } 902/* 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, 903 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL, 904 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL, 905 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL, 906 s->pict_type, s->dropable);*/ 907 908 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr); 909 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr); 910 911 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){ 912 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n"); 913 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference 914 goto alloc; 915 } 916 917 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0])); 918 919 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){ 920 int i; 921 for(i=0; i<4; i++){ 922 if(s->picture_structure == PICT_BOTTOM_FIELD){ 923 s->current_picture.data[i] += s->current_picture.linesize[i]; 924 } 925 s->current_picture.linesize[i] *= 2; 926 s->last_picture.linesize[i] *=2; 927 s->next_picture.linesize[i] *=2; 928 } 929 } 930 931 s->hurry_up= s->avctx->hurry_up; 932 s->error_recognition= avctx->error_recognition; 933 934 /* set dequantizer, we can't do it during init as it might change for mpeg4 935 and we can't do it in the header decode as init is not called for mpeg4 there yet */ 936 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){ 937 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra; 938 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter; 939 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ 940 s->dct_unquantize_intra = s->dct_unquantize_h263_intra; 941 s->dct_unquantize_inter = s->dct_unquantize_h263_inter; 942 }else{ 943 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra; 944 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter; 945 } 946 947 if(s->dct_error_sum){ 948 assert(s->avctx->noise_reduction && s->encoding); 949 950 update_noise_reduction(s); 951 } 952 953 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) 954 return ff_xvmc_field_start(s, avctx); 955 956 return 0; 957} 958 959/* generic function for encode/decode called after a frame has been coded/decoded */ 960void MPV_frame_end(MpegEncContext *s) 961{ 962 int i; 963 /* draw edge for correct motion prediction if outside */ 964 //just to make sure that all data is rendered. 965 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){ 966 ff_xvmc_field_end(s); 967 }else if(!s->avctx->hwaccel 968 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) 969 && s->unrestricted_mv 970 && s->current_picture.reference 971 && !s->intra_only 972 && !(s->flags&CODEC_FLAG_EMU_EDGE)) { 973 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH ); 974 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); 975 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2); 976 } 977 emms_c(); 978 979 s->last_pict_type = s->pict_type; 980 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality; 981 if(s->pict_type!=FF_B_TYPE){ 982 s->last_non_b_pict_type= s->pict_type; 983 } 984#if 0 985 /* copy back current_picture variables */ 986 for(i=0; i<MAX_PICTURE_COUNT; i++){ 987 if(s->picture[i].data[0] == s->current_picture.data[0]){ 988 s->picture[i]= s->current_picture; 989 break; 990 } 991 } 992 assert(i<MAX_PICTURE_COUNT); 993#endif 994 995 if(s->encoding){ 996 /* release non-reference frames */ 997 for(i=0; i<MAX_PICTURE_COUNT; i++){ 998 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){ 999 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]); 1000 } 1001 } 1002 } 1003 // clear copies, to avoid confusion 1004#if 0 1005 memset(&s->last_picture, 0, sizeof(Picture)); 1006 memset(&s->next_picture, 0, sizeof(Picture)); 1007 memset(&s->current_picture, 0, sizeof(Picture)); 1008#endif 1009 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr; 1010} 1011 1012/** 1013 * draws an line from (ex, ey) -> (sx, sy). 1014 * @param w width of the image 1015 * @param h height of the image 1016 * @param stride stride/linesize of the image 1017 * @param color color of the arrow 1018 */ 1019static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 1020 int x, y, fr, f; 1021 1022 sx= av_clip(sx, 0, w-1); 1023 sy= av_clip(sy, 0, h-1); 1024 ex= av_clip(ex, 0, w-1); 1025 ey= av_clip(ey, 0, h-1); 1026 1027 buf[sy*stride + sx]+= color; 1028 1029 if(FFABS(ex - sx) > FFABS(ey - sy)){ 1030 if(sx > ex){ 1031 FFSWAP(int, sx, ex); 1032 FFSWAP(int, sy, ey); 1033 } 1034 buf+= sx + sy*stride; 1035 ex-= sx; 1036 f= ((ey-sy)<<16)/ex; 1037 for(x= 0; x <= ex; x++){ 1038 y = (x*f)>>16; 1039 fr= (x*f)&0xFFFF; 1040 buf[ y *stride + x]+= (color*(0x10000-fr))>>16; 1041 buf[(y+1)*stride + x]+= (color* fr )>>16; 1042 } 1043 }else{ 1044 if(sy > ey){ 1045 FFSWAP(int, sx, ex); 1046 FFSWAP(int, sy, ey); 1047 } 1048 buf+= sx + sy*stride; 1049 ey-= sy; 1050 if(ey) f= ((ex-sx)<<16)/ey; 1051 else f= 0; 1052 for(y= 0; y <= ey; y++){ 1053 x = (y*f)>>16; 1054 fr= (y*f)&0xFFFF; 1055 buf[y*stride + x ]+= (color*(0x10000-fr))>>16; 1056 buf[y*stride + x+1]+= (color* fr )>>16; 1057 } 1058 } 1059} 1060 1061/** 1062 * draws an arrow from (ex, ey) -> (sx, sy). 1063 * @param w width of the image 1064 * @param h height of the image 1065 * @param stride stride/linesize of the image 1066 * @param color color of the arrow 1067 */ 1068static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){ 1069 int dx,dy; 1070 1071 sx= av_clip(sx, -100, w+100); 1072 sy= av_clip(sy, -100, h+100); 1073 ex= av_clip(ex, -100, w+100); 1074 ey= av_clip(ey, -100, h+100); 1075 1076 dx= ex - sx; 1077 dy= ey - sy; 1078 1079 if(dx*dx + dy*dy > 3*3){ 1080 int rx= dx + dy; 1081 int ry= -dx + dy; 1082 int length= ff_sqrt((rx*rx + ry*ry)<<8); 1083 1084 //FIXME subpixel accuracy 1085 rx= ROUNDED_DIV(rx*3<<4, length); 1086 ry= ROUNDED_DIV(ry*3<<4, length); 1087 1088 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color); 1089 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color); 1090 } 1091 draw_line(buf, sx, sy, ex, ey, w, h, stride, color); 1092} 1093 1094/** 1095 * prints debuging info for the given picture. 1096 */ 1097void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){ 1098 1099 if(s->avctx->hwaccel) return; 1100 if(!pict || !pict->mb_type) return; 1101 1102 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){ 1103 int x,y; 1104 1105 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: "); 1106 switch (pict->pict_type) { 1107 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break; 1108 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break; 1109 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break; 1110 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break; 1111 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break; 1112 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break; 1113 } 1114 for(y=0; y<s->mb_height; y++){ 1115 for(x=0; x<s->mb_width; x++){ 1116 if(s->avctx->debug&FF_DEBUG_SKIP){ 1117 int count= s->mbskip_table[x + y*s->mb_stride]; 1118 if(count>9) count=9; 1119 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count); 1120 } 1121 if(s->avctx->debug&FF_DEBUG_QP){ 1122 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]); 1123 } 1124 if(s->avctx->debug&FF_DEBUG_MB_TYPE){ 1125 int mb_type= pict->mb_type[x + y*s->mb_stride]; 1126 //Type & MV direction 1127 if(IS_PCM(mb_type)) 1128 av_log(s->avctx, AV_LOG_DEBUG, "P"); 1129 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type)) 1130 av_log(s->avctx, AV_LOG_DEBUG, "A"); 1131 else if(IS_INTRA4x4(mb_type)) 1132 av_log(s->avctx, AV_LOG_DEBUG, "i"); 1133 else if(IS_INTRA16x16(mb_type)) 1134 av_log(s->avctx, AV_LOG_DEBUG, "I"); 1135 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)) 1136 av_log(s->avctx, AV_LOG_DEBUG, "d"); 1137 else if(IS_DIRECT(mb_type)) 1138 av_log(s->avctx, AV_LOG_DEBUG, "D"); 1139 else if(IS_GMC(mb_type) && IS_SKIP(mb_type)) 1140 av_log(s->avctx, AV_LOG_DEBUG, "g"); 1141 else if(IS_GMC(mb_type)) 1142 av_log(s->avctx, AV_LOG_DEBUG, "G"); 1143 else if(IS_SKIP(mb_type)) 1144 av_log(s->avctx, AV_LOG_DEBUG, "S"); 1145 else if(!USES_LIST(mb_type, 1)) 1146 av_log(s->avctx, AV_LOG_DEBUG, ">"); 1147 else if(!USES_LIST(mb_type, 0)) 1148 av_log(s->avctx, AV_LOG_DEBUG, "<"); 1149 else{ 1150 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); 1151 av_log(s->avctx, AV_LOG_DEBUG, "X"); 1152 } 1153 1154 //segmentation 1155 if(IS_8X8(mb_type)) 1156 av_log(s->avctx, AV_LOG_DEBUG, "+"); 1157 else if(IS_16X8(mb_type)) 1158 av_log(s->avctx, AV_LOG_DEBUG, "-"); 1159 else if(IS_8X16(mb_type)) 1160 av_log(s->avctx, AV_LOG_DEBUG, "|"); 1161 else if(IS_INTRA(mb_type) || IS_16X16(mb_type)) 1162 av_log(s->avctx, AV_LOG_DEBUG, " "); 1163 else 1164 av_log(s->avctx, AV_LOG_DEBUG, "?"); 1165 1166 1167 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264) 1168 av_log(s->avctx, AV_LOG_DEBUG, "="); 1169 else 1170 av_log(s->avctx, AV_LOG_DEBUG, " "); 1171 } 1172// av_log(s->avctx, AV_LOG_DEBUG, " "); 1173 } 1174 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1175 } 1176 } 1177 1178 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){ 1179 const int shift= 1 + s->quarter_sample; 1180 int mb_y; 1181 uint8_t *ptr; 1182 int i; 1183 int h_chroma_shift, v_chroma_shift, block_height; 1184 const int width = s->avctx->width; 1185 const int height= s->avctx->height; 1186 const int mv_sample_log2= 4 - pict->motion_subsample_log2; 1187 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1); 1188 s->low_delay=0; //needed to see the vectors without trashing the buffers 1189 1190 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); 1191 for(i=0; i<3; i++){ 1192 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift); 1193 pict->data[i]= s->visualization_buffer[i]; 1194 } 1195 pict->type= FF_BUFFER_TYPE_COPY; 1196 ptr= pict->data[0]; 1197 block_height = 16>>v_chroma_shift; 1198 1199 for(mb_y=0; mb_y<s->mb_height; mb_y++){ 1200 int mb_x; 1201 for(mb_x=0; mb_x<s->mb_width; mb_x++){ 1202 const int mb_index= mb_x + mb_y*s->mb_stride; 1203 if((s->avctx->debug_mv) && pict->motion_val){ 1204 int type; 1205 for(type=0; type<3; type++){ 1206 int direction = 0; 1207 switch (type) { 1208 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE)) 1209 continue; 1210 direction = 0; 1211 break; 1212 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE)) 1213 continue; 1214 direction = 0; 1215 break; 1216 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE)) 1217 continue; 1218 direction = 1; 1219 break; 1220 } 1221 if(!USES_LIST(pict->mb_type[mb_index], direction)) 1222 continue; 1223 1224 if(IS_8X8(pict->mb_type[mb_index])){ 1225 int i; 1226 for(i=0; i<4; i++){ 1227 int sx= mb_x*16 + 4 + 8*(i&1); 1228 int sy= mb_y*16 + 4 + 8*(i>>1); 1229 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); 1230 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx; 1231 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; 1232 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100); 1233 } 1234 }else if(IS_16X8(pict->mb_type[mb_index])){ 1235 int i; 1236 for(i=0; i<2; i++){ 1237 int sx=mb_x*16 + 8; 1238 int sy=mb_y*16 + 4 + 8*i; 1239 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1); 1240 int mx=(pict->motion_val[direction][xy][0]>>shift); 1241 int my=(pict->motion_val[direction][xy][1]>>shift); 1242 1243 if(IS_INTERLACED(pict->mb_type[mb_index])) 1244 my*=2; 1245 1246 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); 1247 } 1248 }else if(IS_8X16(pict->mb_type[mb_index])){ 1249 int i; 1250 for(i=0; i<2; i++){ 1251 int sx=mb_x*16 + 4 + 8*i; 1252 int sy=mb_y*16 + 8; 1253 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1); 1254 int mx=(pict->motion_val[direction][xy][0]>>shift); 1255 int my=(pict->motion_val[direction][xy][1]>>shift); 1256 1257 if(IS_INTERLACED(pict->mb_type[mb_index])) 1258 my*=2; 1259 1260 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100); 1261 } 1262 }else{ 1263 int sx= mb_x*16 + 8; 1264 int sy= mb_y*16 + 8; 1265 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2; 1266 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx; 1267 int my= (pict->motion_val[direction][xy][1]>>shift) + sy; 1268 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100); 1269 } 1270 } 1271 } 1272 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){ 1273 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL; 1274 int y; 1275 for(y=0; y<block_height; y++){ 1276 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c; 1277 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c; 1278 } 1279 } 1280 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){ 1281 int mb_type= pict->mb_type[mb_index]; 1282 uint64_t u,v; 1283 int y; 1284#define COLOR(theta, r)\ 1285u= (int)(128 + r*cos(theta*3.141592/180));\ 1286v= (int)(128 + r*sin(theta*3.141592/180)); 1287 1288 1289 u=v=128; 1290 if(IS_PCM(mb_type)){ 1291 COLOR(120,48) 1292 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){ 1293 COLOR(30,48) 1294 }else if(IS_INTRA4x4(mb_type)){ 1295 COLOR(90,48) 1296 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){ 1297// COLOR(120,48) 1298 }else if(IS_DIRECT(mb_type)){ 1299 COLOR(150,48) 1300 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){ 1301 COLOR(170,48) 1302 }else if(IS_GMC(mb_type)){ 1303 COLOR(190,48) 1304 }else if(IS_SKIP(mb_type)){ 1305// COLOR(180,48) 1306 }else if(!USES_LIST(mb_type, 1)){ 1307 COLOR(240,48) 1308 }else if(!USES_LIST(mb_type, 0)){ 1309 COLOR(0,48) 1310 }else{ 1311 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1)); 1312 COLOR(300,48) 1313 } 1314 1315 u*= 0x0101010101010101ULL; 1316 v*= 0x0101010101010101ULL; 1317 for(y=0; y<block_height; y++){ 1318 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u; 1319 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v; 1320 } 1321 1322 //segmentation 1323 if(IS_8X8(mb_type) || IS_16X8(mb_type)){ 1324 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; 1325 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL; 1326 } 1327 if(IS_8X8(mb_type) || IS_8X16(mb_type)){ 1328 for(y=0; y<16; y++) 1329 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80; 1330 } 1331 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){ 1332 int dm= 1 << (mv_sample_log2-2); 1333 for(i=0; i<4; i++){ 1334 int sx= mb_x*16 + 8*(i&1); 1335 int sy= mb_y*16 + 8*(i>>1); 1336 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1); 1337 //FIXME bidir 1338 int32_t *mv = (int32_t*)&pict->motion_val[0][xy]; 1339 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)]) 1340 for(y=0; y<8; y++) 1341 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80; 1342 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)]) 1343 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL; 1344 } 1345 } 1346 1347 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){ 1348 // hmm 1349 } 1350 } 1351 s->mbskip_table[mb_index]=0; 1352 } 1353 } 1354 } 1355} 1356 1357static inline int hpel_motion_lowres(MpegEncContext *s, 1358 uint8_t *dest, uint8_t *src, 1359 int field_based, int field_select, 1360 int src_x, int src_y, 1361 int width, int height, int stride, 1362 int h_edge_pos, int v_edge_pos, 1363 int w, int h, h264_chroma_mc_func *pix_op, 1364 int motion_x, int motion_y) 1365{ 1366 const int lowres= s->avctx->lowres; 1367 const int s_mask= (2<<lowres)-1; 1368 int emu=0; 1369 int sx, sy; 1370 1371 if(s->quarter_sample){ 1372 motion_x/=2; 1373 motion_y/=2; 1374 } 1375 1376 sx= motion_x & s_mask; 1377 sy= motion_y & s_mask; 1378 src_x += motion_x >> (lowres+1); 1379 src_y += motion_y >> (lowres+1); 1380 1381 src += src_y * stride + src_x; 1382 1383 if( (unsigned)src_x > h_edge_pos - (!!sx) - w 1384 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ 1385 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based, 1386 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); 1387 src= s->edge_emu_buffer; 1388 emu=1; 1389 } 1390 1391 sx <<= 2 - lowres; 1392 sy <<= 2 - lowres; 1393 if(field_select) 1394 src += s->linesize; 1395 pix_op[lowres](dest, src, stride, h, sx, sy); 1396 return emu; 1397} 1398 1399/* apply one mpeg motion vector to the three components */ 1400static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, 1401 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 1402 int field_based, int bottom_field, int field_select, 1403 uint8_t **ref_picture, h264_chroma_mc_func *pix_op, 1404 int motion_x, int motion_y, int h) 1405{ 1406 uint8_t *ptr_y, *ptr_cb, *ptr_cr; 1407 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy; 1408 const int lowres= s->avctx->lowres; 1409 const int block_s= 8>>lowres; 1410 const int s_mask= (2<<lowres)-1; 1411 const int h_edge_pos = s->h_edge_pos >> lowres; 1412 const int v_edge_pos = s->v_edge_pos >> lowres; 1413 linesize = s->current_picture.linesize[0] << field_based; 1414 uvlinesize = s->current_picture.linesize[1] << field_based; 1415 1416 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway 1417 motion_x/=2; 1418 motion_y/=2; 1419 } 1420 1421 if(field_based){ 1422 motion_y += (bottom_field - field_select)*((1<<lowres)-1); 1423 } 1424 1425 sx= motion_x & s_mask; 1426 sy= motion_y & s_mask; 1427 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1)); 1428 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1)); 1429 1430 if (s->out_format == FMT_H263) { 1431 uvsx = ((motion_x>>1) & s_mask) | (sx&1); 1432 uvsy = ((motion_y>>1) & s_mask) | (sy&1); 1433 uvsrc_x = src_x>>1; 1434 uvsrc_y = src_y>>1; 1435 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261 1436 mx = motion_x / 4; 1437 my = motion_y / 4; 1438 uvsx = (2*mx) & s_mask; 1439 uvsy = (2*my) & s_mask; 1440 uvsrc_x = s->mb_x*block_s + (mx >> lowres); 1441 uvsrc_y = s->mb_y*block_s + (my >> lowres); 1442 } else { 1443 mx = motion_x / 2; 1444 my = motion_y / 2; 1445 uvsx = mx & s_mask; 1446 uvsy = my & s_mask; 1447 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); 1448 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1)); 1449 } 1450 1451 ptr_y = ref_picture[0] + src_y * linesize + src_x; 1452 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; 1453 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; 1454 1455 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s 1456 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){ 1457 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based, 1458 src_x, src_y<<field_based, h_edge_pos, v_edge_pos); 1459 ptr_y = s->edge_emu_buffer; 1460 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 1461 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize; 1462 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based, 1463 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); 1464 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based, 1465 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1); 1466 ptr_cb= uvbuf; 1467 ptr_cr= uvbuf+16; 1468 } 1469 } 1470 1471 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data 1472 dest_y += s->linesize; 1473 dest_cb+= s->uvlinesize; 1474 dest_cr+= s->uvlinesize; 1475 } 1476 1477 if(field_select){ 1478 ptr_y += s->linesize; 1479 ptr_cb+= s->uvlinesize; 1480 ptr_cr+= s->uvlinesize; 1481 } 1482 1483 sx <<= 2 - lowres; 1484 sy <<= 2 - lowres; 1485 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy); 1486 1487 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 1488 uvsx <<= 2 - lowres; 1489 uvsy <<= 2 - lowres; 1490 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); 1491 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy); 1492 } 1493 //FIXME h261 lowres loop filter 1494} 1495 1496static inline void chroma_4mv_motion_lowres(MpegEncContext *s, 1497 uint8_t *dest_cb, uint8_t *dest_cr, 1498 uint8_t **ref_picture, 1499 h264_chroma_mc_func *pix_op, 1500 int mx, int my){ 1501 const int lowres= s->avctx->lowres; 1502 const int block_s= 8>>lowres; 1503 const int s_mask= (2<<lowres)-1; 1504 const int h_edge_pos = s->h_edge_pos >> (lowres+1); 1505 const int v_edge_pos = s->v_edge_pos >> (lowres+1); 1506 int emu=0, src_x, src_y, offset, sx, sy; 1507 uint8_t *ptr; 1508 1509 if(s->quarter_sample){ 1510 mx/=2; 1511 my/=2; 1512 } 1513 1514 /* In case of 8X8, we construct a single chroma motion vector 1515 with a special rounding */ 1516 mx= ff_h263_round_chroma(mx); 1517 my= ff_h263_round_chroma(my); 1518 1519 sx= mx & s_mask; 1520 sy= my & s_mask; 1521 src_x = s->mb_x*block_s + (mx >> (lowres+1)); 1522 src_y = s->mb_y*block_s + (my >> (lowres+1)); 1523 1524 offset = src_y * s->uvlinesize + src_x; 1525 ptr = ref_picture[1] + offset; 1526 if(s->flags&CODEC_FLAG_EMU_EDGE){ 1527 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s 1528 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){ 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; 1531 emu=1; 1532 } 1533 } 1534 sx <<= 2 - lowres; 1535 sy <<= 2 - lowres; 1536 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); 1537 1538 ptr = ref_picture[2] + offset; 1539 if(emu){ 1540 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos); 1541 ptr= s->edge_emu_buffer; 1542 } 1543 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); 1544} 1545 1546/** 1547 * motion compensation of a single macroblock 1548 * @param s context 1549 * @param dest_y luma destination pointer 1550 * @param dest_cb chroma cb/u destination pointer 1551 * @param dest_cr chroma cr/v destination pointer 1552 * @param dir direction (0->forward, 1->backward) 1553 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture 1554 * @param pic_op halfpel motion compensation function (average or put normally) 1555 * the motion vectors are taken from s->mv and the MV type from s->mv_type 1556 */ 1557static inline void MPV_motion_lowres(MpegEncContext *s, 1558 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 1559 int dir, uint8_t **ref_picture, 1560 h264_chroma_mc_func *pix_op) 1561{ 1562 int mx, my; 1563 int mb_x, mb_y, i; 1564 const int lowres= s->avctx->lowres; 1565 const int block_s= 8>>lowres; 1566 1567 mb_x = s->mb_x; 1568 mb_y = s->mb_y; 1569 1570 switch(s->mv_type) { 1571 case MV_TYPE_16X16: 1572 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1573 0, 0, 0, 1574 ref_picture, pix_op, 1575 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); 1576 break; 1577 case MV_TYPE_8X8: 1578 mx = 0; 1579 my = 0; 1580 for(i=0;i<4;i++) { 1581 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s, 1582 ref_picture[0], 0, 0, 1583 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s, 1584 s->width, s->height, s->linesize, 1585 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, 1586 block_s, block_s, pix_op, 1587 s->mv[dir][i][0], s->mv[dir][i][1]); 1588 1589 mx += s->mv[dir][i][0]; 1590 my += s->mv[dir][i][1]; 1591 } 1592 1593 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) 1594 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my); 1595 break; 1596 case MV_TYPE_FIELD: 1597 if (s->picture_structure == PICT_FRAME) { 1598 /* top field */ 1599 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1600 1, 0, s->field_select[dir][0], 1601 ref_picture, pix_op, 1602 s->mv[dir][0][0], s->mv[dir][0][1], block_s); 1603 /* bottom field */ 1604 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1605 1, 1, s->field_select[dir][1], 1606 ref_picture, pix_op, 1607 s->mv[dir][1][0], s->mv[dir][1][1], block_s); 1608 } else { 1609 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){ 1610 ref_picture= s->current_picture_ptr->data; 1611 } 1612 1613 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1614 0, 0, s->field_select[dir][0], 1615 ref_picture, pix_op, 1616 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s); 1617 } 1618 break; 1619 case MV_TYPE_16X8: 1620 for(i=0; i<2; i++){ 1621 uint8_t ** ref2picture; 1622 1623 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){ 1624 ref2picture= ref_picture; 1625 }else{ 1626 ref2picture= s->current_picture_ptr->data; 1627 } 1628 1629 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1630 0, 0, s->field_select[dir][i], 1631 ref2picture, pix_op, 1632 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s); 1633 1634 dest_y += 2*block_s*s->linesize; 1635 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; 1636 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize; 1637 } 1638 break; 1639 case MV_TYPE_DMV: 1640 if(s->picture_structure == PICT_FRAME){ 1641 for(i=0; i<2; i++){ 1642 int j; 1643 for(j=0; j<2; j++){ 1644 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1645 1, j, j^i, 1646 ref_picture, pix_op, 1647 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s); 1648 } 1649 pix_op = s->dsp.avg_h264_chroma_pixels_tab; 1650 } 1651 }else{ 1652 for(i=0; i<2; i++){ 1653 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1654 0, 0, s->picture_structure != i+1, 1655 ref_picture, pix_op, 1656 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s); 1657 1658 // after put we make avg of the same block 1659 pix_op = s->dsp.avg_h264_chroma_pixels_tab; 1660 1661 //opposite parity is always in the same frame if this is second field 1662 if(!s->first_field){ 1663 ref_picture = s->current_picture_ptr->data; 1664 } 1665 } 1666 } 1667 break; 1668 default: assert(0); 1669 } 1670} 1671 1672/* put block[] to dest[] */ 1673static inline void put_dct(MpegEncContext *s, 1674 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) 1675{ 1676 s->dct_unquantize_intra(s, block, i, qscale); 1677 s->dsp.idct_put (dest, line_size, block); 1678} 1679 1680/* add block[] to dest[] */ 1681static inline void add_dct(MpegEncContext *s, 1682 DCTELEM *block, int i, uint8_t *dest, int line_size) 1683{ 1684 if (s->block_last_index[i] >= 0) { 1685 s->dsp.idct_add (dest, line_size, block); 1686 } 1687} 1688 1689static inline void add_dequant_dct(MpegEncContext *s, 1690 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale) 1691{ 1692 if (s->block_last_index[i] >= 0) { 1693 s->dct_unquantize_inter(s, block, i, qscale); 1694 1695 s->dsp.idct_add (dest, line_size, block); 1696 } 1697} 1698 1699/** 1700 * cleans dc, ac, coded_block for the current non intra MB 1701 */ 1702void ff_clean_intra_table_entries(MpegEncContext *s) 1703{ 1704 int wrap = s->b8_stride; 1705 int xy = s->block_index[0]; 1706 1707 s->dc_val[0][xy ] = 1708 s->dc_val[0][xy + 1 ] = 1709 s->dc_val[0][xy + wrap] = 1710 s->dc_val[0][xy + 1 + wrap] = 1024; 1711 /* ac pred */ 1712 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); 1713 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); 1714 if (s->msmpeg4_version>=3) { 1715 s->coded_block[xy ] = 1716 s->coded_block[xy + 1 ] = 1717 s->coded_block[xy + wrap] = 1718 s->coded_block[xy + 1 + wrap] = 0; 1719 } 1720 /* chroma */ 1721 wrap = s->mb_stride; 1722 xy = s->mb_x + s->mb_y * wrap; 1723 s->dc_val[1][xy] = 1724 s->dc_val[2][xy] = 1024; 1725 /* ac pred */ 1726 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); 1727 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); 1728 1729 s->mbintra_table[xy]= 0; 1730} 1731 1732/* generic function called after a macroblock has been parsed by the 1733 decoder or after it has been encoded by the encoder. 1734 1735 Important variables used: 1736 s->mb_intra : true if intra macroblock 1737 s->mv_dir : motion vector direction 1738 s->mv_type : motion vector type 1739 s->mv : motion vector 1740 s->interlaced_dct : true if interlaced dct used (mpeg2) 1741 */ 1742static av_always_inline 1743void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], 1744 int lowres_flag, int is_mpeg12) 1745{ 1746 int mb_x, mb_y; 1747 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; 1748 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){ 1749 ff_xvmc_decode_mb(s);//xvmc uses pblocks 1750 return; 1751 } 1752 1753 mb_x = s->mb_x; 1754 mb_y = s->mb_y; 1755 1756 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) { 1757 /* save DCT coefficients */ 1758 int i,j; 1759 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6]; 1760 for(i=0; i<6; i++) 1761 for(j=0; j<64; j++) 1762 *dct++ = block[i][s->dsp.idct_permutation[j]]; 1763 } 1764 1765 s->current_picture.qscale_table[mb_xy]= s->qscale; 1766 1767 /* update DC predictors for P macroblocks */ 1768 if (!s->mb_intra) { 1769 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) { 1770 if(s->mbintra_table[mb_xy]) 1771 ff_clean_intra_table_entries(s); 1772 } else { 1773 s->last_dc[0] = 1774 s->last_dc[1] = 1775 s->last_dc[2] = 128 << s->intra_dc_precision; 1776 } 1777 } 1778 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) 1779 s->mbintra_table[mb_xy]=1; 1780 1781 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 1782 uint8_t *dest_y, *dest_cb, *dest_cr; 1783 int dct_linesize, dct_offset; 1784 op_pixels_func (*op_pix)[4]; 1785 qpel_mc_func (*op_qpix)[16]; 1786 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics 1787 const int uvlinesize= s->current_picture.linesize[1]; 1788 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag; 1789 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8; 1790 1791 /* avoid copy if macroblock skipped in last frame too */ 1792 /* skip only during decoding as we might trash the buffers during encoding a bit */ 1793 if(!s->encoding){ 1794 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; 1795 const int age= s->current_picture.age; 1796 1797 assert(age); 1798 1799 if (s->mb_skipped) { 1800 s->mb_skipped= 0; 1801 assert(s->pict_type!=FF_I_TYPE); 1802 1803 (*mbskip_ptr) ++; /* indicate that this time we skipped it */ 1804 if(*mbskip_ptr >99) *mbskip_ptr= 99; 1805 1806 /* if previous was skipped too, then nothing to do ! */ 1807 if (*mbskip_ptr >= age && s->current_picture.reference){ 1808 return; 1809 } 1810 } else if(!s->current_picture.reference){ 1811 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */ 1812 if(*mbskip_ptr >99) *mbskip_ptr= 99; 1813 } else{ 1814 *mbskip_ptr = 0; /* not skipped */ 1815 } 1816 } 1817 1818 dct_linesize = linesize << s->interlaced_dct; 1819 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size; 1820 1821 if(readable){ 1822 dest_y= s->dest[0]; 1823 dest_cb= s->dest[1]; 1824 dest_cr= s->dest[2]; 1825 }else{ 1826 dest_y = s->b_scratchpad; 1827 dest_cb= s->b_scratchpad+16*linesize; 1828 dest_cr= s->b_scratchpad+32*linesize; 1829 } 1830 1831 if (!s->mb_intra) { 1832 /* motion handling */ 1833 /* decoding or more than one mb_type (MC was already done otherwise) */ 1834 if(!s->encoding){ 1835 if(lowres_flag){ 1836 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab; 1837 1838 if (s->mv_dir & MV_DIR_FORWARD) { 1839 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix); 1840 op_pix = s->dsp.avg_h264_chroma_pixels_tab; 1841 } 1842 if (s->mv_dir & MV_DIR_BACKWARD) { 1843 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix); 1844 } 1845 }else{ 1846 op_qpix= s->me.qpel_put; 1847 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){ 1848 op_pix = s->dsp.put_pixels_tab; 1849 }else{ 1850 op_pix = s->dsp.put_no_rnd_pixels_tab; 1851 } 1852 if (s->mv_dir & MV_DIR_FORWARD) { 1853 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); 1854 op_pix = s->dsp.avg_pixels_tab; 1855 op_qpix= s->me.qpel_avg; 1856 } 1857 if (s->mv_dir & MV_DIR_BACKWARD) { 1858 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); 1859 } 1860 } 1861 } 1862 1863 /* skip dequant / idct if we are really late ;) */ 1864 if(s->hurry_up>1) goto skip_idct; 1865 if(s->avctx->skip_idct){ 1866 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE) 1867 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE) 1868 || s->avctx->skip_idct >= AVDISCARD_ALL) 1869 goto skip_idct; 1870 } 1871 1872 /* add dct residue */ 1873 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO 1874 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){ 1875 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); 1876 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); 1877 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); 1878 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); 1879 1880 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 1881 if (s->chroma_y_shift){ 1882 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); 1883 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); 1884 }else{ 1885 dct_linesize >>= 1; 1886 dct_offset >>=1; 1887 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); 1888 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); 1889 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); 1890 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); 1891 } 1892 } 1893 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){ 1894 add_dct(s, block[0], 0, dest_y , dct_linesize); 1895 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); 1896 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); 1897 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); 1898 1899 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 1900 if(s->chroma_y_shift){//Chroma420 1901 add_dct(s, block[4], 4, dest_cb, uvlinesize); 1902 add_dct(s, block[5], 5, dest_cr, uvlinesize); 1903 }else{ 1904 //chroma422 1905 dct_linesize = uvlinesize << s->interlaced_dct; 1906 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8; 1907 1908 add_dct(s, block[4], 4, dest_cb, dct_linesize); 1909 add_dct(s, block[5], 5, dest_cr, dct_linesize); 1910 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize); 1911 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize); 1912 if(!s->chroma_x_shift){//Chroma444 1913 add_dct(s, block[8], 8, dest_cb+8, dct_linesize); 1914 add_dct(s, block[9], 9, dest_cr+8, dct_linesize); 1915 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize); 1916 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize); 1917 } 1918 } 1919 }//fi gray 1920 } 1921 else if (CONFIG_WMV2) { 1922 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); 1923 } 1924 } else { 1925 /* dct only in intra block */ 1926 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){ 1927 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); 1928 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); 1929 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); 1930 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); 1931 1932 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 1933 if(s->chroma_y_shift){ 1934 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); 1935 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); 1936 }else{ 1937 dct_offset >>=1; 1938 dct_linesize >>=1; 1939 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); 1940 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); 1941 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); 1942 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); 1943 } 1944 } 1945 }else{ 1946 s->dsp.idct_put(dest_y , dct_linesize, block[0]); 1947 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]); 1948 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]); 1949 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); 1950 1951 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 1952 if(s->chroma_y_shift){ 1953 s->dsp.idct_put(dest_cb, uvlinesize, block[4]); 1954 s->dsp.idct_put(dest_cr, uvlinesize, block[5]); 1955 }else{ 1956 1957 dct_linesize = uvlinesize << s->interlaced_dct; 1958 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8; 1959 1960 s->dsp.idct_put(dest_cb, dct_linesize, block[4]); 1961 s->dsp.idct_put(dest_cr, dct_linesize, block[5]); 1962 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]); 1963 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]); 1964 if(!s->chroma_x_shift){//Chroma444 1965 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]); 1966 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]); 1967 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]); 1968 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]); 1969 } 1970 } 1971 }//gray 1972 } 1973 } 1974skip_idct: 1975 if(!readable){ 1976 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16); 1977 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift); 1978 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); 1979 } 1980 } 1981} 1982 1983void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){ 1984#if !CONFIG_SMALL 1985 if(s->out_format == FMT_MPEG1) { 1986 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1); 1987 else MPV_decode_mb_internal(s, block, 0, 1); 1988 } else 1989#endif 1990 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0); 1991 else MPV_decode_mb_internal(s, block, 0, 0); 1992} 1993 1994/** 1995 * 1996 * @param h is the normal height, this will be reduced automatically if needed for the last row 1997 */ 1998void ff_draw_horiz_band(MpegEncContext *s, int y, int h){ 1999 if (s->avctx->draw_horiz_band) { 2000 AVFrame *src; 2001 int offset[4]; 2002 2003 if(s->picture_structure != PICT_FRAME){ 2004 h <<= 1; 2005 y <<= 1; 2006 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return; 2007 } 2008 2009 h= FFMIN(h, s->avctx->height - y); 2010 2011 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER)) 2012 src= (AVFrame*)s->current_picture_ptr; 2013 else if(s->last_picture_ptr) 2014 src= (AVFrame*)s->last_picture_ptr; 2015 else 2016 return; 2017 2018 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){ 2019 offset[0]= 2020 offset[1]= 2021 offset[2]= 2022 offset[3]= 0; 2023 }else{ 2024 offset[0]= y * s->linesize; 2025 offset[1]= 2026 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize; 2027 offset[3]= 0; 2028 } 2029 2030 emms_c(); 2031 2032 s->avctx->draw_horiz_band(s->avctx, src, offset, 2033 y, s->picture_structure, h); 2034 } 2035} 2036 2037void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename 2038 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics 2039 const int uvlinesize= s->current_picture.linesize[1]; 2040 const int mb_size= 4 - s->avctx->lowres; 2041 2042 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2; 2043 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2; 2044 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2; 2045 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2; 2046 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1; 2047 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; 2048 //block_index is not used by mpeg2, so it is not affected by chroma_format 2049 2050 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size); 2051 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); 2052 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift)); 2053 2054 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME)) 2055 { 2056 s->dest[0] += s->mb_y * linesize << mb_size; 2057 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); 2058 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift); 2059 } 2060} 2061 2062void ff_mpeg_flush(AVCodecContext *avctx){ 2063 int i; 2064 MpegEncContext *s = avctx->priv_data; 2065 2066 if(s==NULL || s->picture==NULL) 2067 return; 2068 2069 for(i=0; i<MAX_PICTURE_COUNT; i++){ 2070 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL 2071 || s->picture[i].type == FF_BUFFER_TYPE_USER)) 2072 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]); 2073 } 2074 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL; 2075 2076 s->mb_x= s->mb_y= 0; 2077 2078 s->parse_context.state= -1; 2079 s->parse_context.frame_start_found= 0; 2080 s->parse_context.overread= 0; 2081 s->parse_context.overread_index= 0; 2082 s->parse_context.index= 0; 2083 s->parse_context.last_index= 0; 2084 s->bitstream_buffer_size=0; 2085 s->pp_time=0; 2086} 2087 2088static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 2089 DCTELEM *block, int n, int qscale) 2090{ 2091 int i, level, nCoeffs; 2092 const uint16_t *quant_matrix; 2093 2094 nCoeffs= s->block_last_index[n]; 2095 2096 if (n < 4) 2097 block[0] = block[0] * s->y_dc_scale; 2098 else 2099 block[0] = block[0] * s->c_dc_scale; 2100 /* XXX: only mpeg1 */ 2101 quant_matrix = s->intra_matrix; 2102 for(i=1;i<=nCoeffs;i++) { 2103 int j= s->intra_scantable.permutated[i]; 2104 level = block[j]; 2105 if (level) { 2106 if (level < 0) { 2107 level = -level; 2108 level = (int)(level * qscale * quant_matrix[j]) >> 3; 2109 level = (level - 1) | 1; 2110 level = -level; 2111 } else { 2112 level = (int)(level * qscale * quant_matrix[j]) >> 3; 2113 level = (level - 1) | 1; 2114 } 2115 block[j] = level; 2116 } 2117 } 2118} 2119 2120static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 2121 DCTELEM *block, int n, int qscale) 2122{ 2123 int i, level, nCoeffs; 2124 const uint16_t *quant_matrix; 2125 2126 nCoeffs= s->block_last_index[n]; 2127 2128 quant_matrix = s->inter_matrix; 2129 for(i=0; i<=nCoeffs; i++) { 2130 int j= s->intra_scantable.permutated[i]; 2131 level = block[j]; 2132 if (level) { 2133 if (level < 0) { 2134 level = -level; 2135 level = (((level << 1) + 1) * qscale * 2136 ((int) (quant_matrix[j]))) >> 4; 2137 level = (level - 1) | 1; 2138 level = -level; 2139 } else { 2140 level = (((level << 1) + 1) * qscale * 2141 ((int) (quant_matrix[j]))) >> 4; 2142 level = (level - 1) | 1; 2143 } 2144 block[j] = level; 2145 } 2146 } 2147} 2148 2149static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, 2150 DCTELEM *block, int n, int qscale) 2151{ 2152 int i, level, nCoeffs; 2153 const uint16_t *quant_matrix; 2154 2155 if(s->alternate_scan) nCoeffs= 63; 2156 else nCoeffs= s->block_last_index[n]; 2157 2158 if (n < 4) 2159 block[0] = block[0] * s->y_dc_scale; 2160 else 2161 block[0] = block[0] * s->c_dc_scale; 2162 quant_matrix = s->intra_matrix; 2163 for(i=1;i<=nCoeffs;i++) { 2164 int j= s->intra_scantable.permutated[i]; 2165 level = block[j]; 2166 if (level) { 2167 if (level < 0) { 2168 level = -level; 2169 level = (int)(level * qscale * quant_matrix[j]) >> 3; 2170 level = -level; 2171 } else { 2172 level = (int)(level * qscale * quant_matrix[j]) >> 3; 2173 } 2174 block[j] = level; 2175 } 2176 } 2177} 2178 2179static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, 2180 DCTELEM *block, int n, int qscale) 2181{ 2182 int i, level, nCoeffs; 2183 const uint16_t *quant_matrix; 2184 int sum=-1; 2185 2186 if(s->alternate_scan) nCoeffs= 63; 2187 else nCoeffs= s->block_last_index[n]; 2188 2189 if (n < 4) 2190 block[0] = block[0] * s->y_dc_scale; 2191 else 2192 block[0] = block[0] * s->c_dc_scale; 2193 quant_matrix = s->intra_matrix; 2194 for(i=1;i<=nCoeffs;i++) { 2195 int j= s->intra_scantable.permutated[i]; 2196 level = block[j]; 2197 if (level) { 2198 if (level < 0) { 2199 level = -level; 2200 level = (int)(level * qscale * quant_matrix[j]) >> 3; 2201 level = -level; 2202 } else { 2203 level = (int)(level * qscale * quant_matrix[j]) >> 3; 2204 } 2205 block[j] = level; 2206 sum+=level; 2207 } 2208 } 2209 block[63]^=sum&1; 2210} 2211 2212static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, 2213 DCTELEM *block, int n, int qscale) 2214{ 2215 int i, level, nCoeffs; 2216 const uint16_t *quant_matrix; 2217 int sum=-1; 2218 2219 if(s->alternate_scan) nCoeffs= 63; 2220 else nCoeffs= s->block_last_index[n]; 2221 2222 quant_matrix = s->inter_matrix; 2223 for(i=0; i<=nCoeffs; i++) { 2224 int j= s->intra_scantable.permutated[i]; 2225 level = block[j]; 2226 if (level) { 2227 if (level < 0) { 2228 level = -level; 2229 level = (((level << 1) + 1) * qscale * 2230 ((int) (quant_matrix[j]))) >> 4; 2231 level = -level; 2232 } else { 2233 level = (((level << 1) + 1) * qscale * 2234 ((int) (quant_matrix[j]))) >> 4; 2235 } 2236 block[j] = level; 2237 sum+=level; 2238 } 2239 } 2240 block[63]^=sum&1; 2241} 2242 2243static void dct_unquantize_h263_intra_c(MpegEncContext *s, 2244 DCTELEM *block, int n, int qscale) 2245{ 2246 int i, level, qmul, qadd; 2247 int nCoeffs; 2248 2249 assert(s->block_last_index[n]>=0); 2250 2251 qmul = qscale << 1; 2252 2253 if (!s->h263_aic) { 2254 if (n < 4) 2255 block[0] = block[0] * s->y_dc_scale; 2256 else 2257 block[0] = block[0] * s->c_dc_scale; 2258 qadd = (qscale - 1) | 1; 2259 }else{ 2260 qadd = 0; 2261 } 2262 if(s->ac_pred) 2263 nCoeffs=63; 2264 else 2265 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; 2266 2267 for(i=1; i<=nCoeffs; i++) { 2268 level = block[i]; 2269 if (level) { 2270 if (level < 0) { 2271 level = level * qmul - qadd; 2272 } else { 2273 level = level * qmul + qadd; 2274 } 2275 block[i] = level; 2276 } 2277 } 2278} 2279 2280static void dct_unquantize_h263_inter_c(MpegEncContext *s, 2281 DCTELEM *block, int n, int qscale) 2282{ 2283 int i, level, qmul, qadd; 2284 int nCoeffs; 2285 2286 assert(s->block_last_index[n]>=0); 2287 2288 qadd = (qscale - 1) | 1; 2289 qmul = qscale << 1; 2290 2291 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; 2292 2293 for(i=0; i<=nCoeffs; i++) { 2294 level = block[i]; 2295 if (level) { 2296 if (level < 0) { 2297 level = level * qmul - qadd; 2298 } else { 2299 level = level * qmul + qadd; 2300 } 2301 block[i] = level; 2302 } 2303 } 2304} 2305 2306/** 2307 * set qscale and update qscale dependent variables. 2308 */ 2309void ff_set_qscale(MpegEncContext * s, int qscale) 2310{ 2311 if (qscale < 1) 2312 qscale = 1; 2313 else if (qscale > 31) 2314 qscale = 31; 2315 2316 s->qscale = qscale; 2317 s->chroma_qscale= s->chroma_qscale_table[qscale]; 2318 2319 s->y_dc_scale= s->y_dc_scale_table[ qscale ]; 2320 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; 2321} 2322