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