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_enc.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 "h263.h" 37#include "faandct.h" 38#include "aandcttab.h" 39#include <limits.h> 40 41//#undef NDEBUG 42//#include <assert.h> 43 44static int encode_picture(MpegEncContext *s, int picture_number); 45static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale); 46static int sse_mb(MpegEncContext *s); 47 48/* enable all paranoid tests for rounding, overflows, etc... */ 49//#define PARANOID 50 51//#define DEBUG 52 53static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 54static uint8_t default_fcode_tab[MAX_MV*2+1]; 55 56void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64], 57 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra) 58{ 59 int qscale; 60 int shift=0; 61 62 for(qscale=qmin; qscale<=qmax; qscale++){ 63 int i; 64 if (dsp->fdct == ff_jpeg_fdct_islow 65#ifdef FAAN_POSTSCALE 66 || dsp->fdct == ff_faandct 67#endif 68 ) { 69 for(i=0;i<64;i++) { 70 const int j= dsp->idct_permutation[i]; 71 /* 16 <= qscale * quant_matrix[i] <= 7905 */ 72 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ 73 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1 << 36) / 249205026 */ 74 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */ 75 76 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / 77 (qscale * quant_matrix[j])); 78 } 79 } else if (dsp->fdct == fdct_ifast 80#ifndef FAAN_POSTSCALE 81 || dsp->fdct == ff_faandct 82#endif 83 ) { 84 for(i=0;i<64;i++) { 85 const int j= dsp->idct_permutation[i]; 86 /* 16 <= qscale * quant_matrix[i] <= 7905 */ 87 /* 19952 <= ff_aanscales[i] * qscale * quant_matrix[i] <= 249205026 */ 88 /* (1 << 36) / 19952 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */ 89 /* 3444240 >= (1 << 36) / (ff_aanscales[i] * qscale * quant_matrix[i]) >= 275 */ 90 91 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / 92 (ff_aanscales[i] * qscale * quant_matrix[j])); 93 } 94 } else { 95 for(i=0;i<64;i++) { 96 const int j= dsp->idct_permutation[i]; 97 /* We can safely suppose that 16 <= quant_matrix[i] <= 255 98 So 16 <= qscale * quant_matrix[i] <= 7905 99 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905 100 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67 101 */ 102 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j])); 103// qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]); 104 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]); 105 106 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1; 107 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]); 108 } 109 } 110 111 for(i=intra; i<64; i++){ 112 int64_t max= 8191; 113 if (dsp->fdct == fdct_ifast 114#ifndef FAAN_POSTSCALE 115 || dsp->fdct == ff_faandct 116#endif 117 ) { 118 max = (8191LL*ff_aanscales[i]) >> 14; 119 } 120 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){ 121 shift++; 122 } 123 } 124 } 125 if(shift){ 126 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift); 127 } 128} 129 130static inline void update_qscale(MpegEncContext *s){ 131 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); 132 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax); 133 134 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; 135} 136 137void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){ 138 int i; 139 140 if(matrix){ 141 put_bits(pb, 1, 1); 142 for(i=0;i<64;i++) { 143 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]); 144 } 145 }else 146 put_bits(pb, 1, 0); 147} 148 149static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){ 150 int i; 151 152 dst->pict_type = src->pict_type; 153 dst->quality = src->quality; 154 dst->coded_picture_number = src->coded_picture_number; 155 dst->display_picture_number = src->display_picture_number; 156// dst->reference = src->reference; 157 dst->pts = src->pts; 158 dst->interlaced_frame = src->interlaced_frame; 159 dst->top_field_first = src->top_field_first; 160 161 if(s->avctx->me_threshold){ 162 if(!src->motion_val[0]) 163 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n"); 164 if(!src->mb_type) 165 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n"); 166 if(!src->ref_index[0]) 167 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n"); 168 if(src->motion_subsample_log2 != dst->motion_subsample_log2) 169 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n", 170 src->motion_subsample_log2, dst->motion_subsample_log2); 171 172 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0])); 173 174 for(i=0; i<2; i++){ 175 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1; 176 int height= ((16*s->mb_height)>>src->motion_subsample_log2); 177 178 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){ 179 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t)); 180 } 181 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){ 182 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t)); 183 } 184 } 185 } 186} 187 188static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){ 189#define COPY(a) dst->a= src->a 190 COPY(pict_type); 191 COPY(current_picture); 192 COPY(f_code); 193 COPY(b_code); 194 COPY(qscale); 195 COPY(lambda); 196 COPY(lambda2); 197 COPY(picture_in_gop_number); 198 COPY(gop_picture_number); 199 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header 200 COPY(progressive_frame); //FIXME don't set in encode_header 201 COPY(partitioned_frame); //FIXME don't set in encode_header 202#undef COPY 203} 204 205/** 206 * sets the given MpegEncContext to defaults for encoding. 207 * the changed fields will not depend upon the prior state of the MpegEncContext. 208 */ 209static void MPV_encode_defaults(MpegEncContext *s){ 210 int i; 211 MPV_common_defaults(s); 212 213 for(i=-16; i<16; i++){ 214 default_fcode_tab[i + MAX_MV]= 1; 215 } 216 s->me.mv_penalty= default_mv_penalty; 217 s->fcode_tab= default_fcode_tab; 218} 219 220/* init video encoder */ 221av_cold int MPV_encode_init(AVCodecContext *avctx) 222{ 223 MpegEncContext *s = avctx->priv_data; 224 int i; 225 int chroma_h_shift, chroma_v_shift; 226 227 MPV_encode_defaults(s); 228 229 switch (avctx->codec_id) { 230 case CODEC_ID_MPEG2VIDEO: 231 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){ 232 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n"); 233 return -1; 234 } 235 break; 236 case CODEC_ID_LJPEG: 237 case CODEC_ID_MJPEG: 238 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P && avctx->pix_fmt != PIX_FMT_RGB32 && 239 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){ 240 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n"); 241 return -1; 242 } 243 break; 244 default: 245 if(avctx->pix_fmt != PIX_FMT_YUV420P){ 246 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n"); 247 return -1; 248 } 249 } 250 251 switch (avctx->pix_fmt) { 252 case PIX_FMT_YUVJ422P: 253 case PIX_FMT_YUV422P: 254 s->chroma_format = CHROMA_422; 255 break; 256 case PIX_FMT_YUVJ420P: 257 case PIX_FMT_YUV420P: 258 default: 259 s->chroma_format = CHROMA_420; 260 break; 261 } 262 263 s->bit_rate = avctx->bit_rate; 264 s->width = avctx->width; 265 s->height = avctx->height; 266 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){ 267 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n"); 268 avctx->gop_size=600; 269 } 270 s->gop_size = avctx->gop_size; 271 s->avctx = avctx; 272 s->flags= avctx->flags; 273 s->flags2= avctx->flags2; 274 s->max_b_frames= avctx->max_b_frames; 275 s->codec_id= avctx->codec->id; 276 s->luma_elim_threshold = avctx->luma_elim_threshold; 277 s->chroma_elim_threshold= avctx->chroma_elim_threshold; 278 s->strict_std_compliance= avctx->strict_std_compliance; 279 s->data_partitioning= avctx->flags & CODEC_FLAG_PART; 280 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0; 281 s->mpeg_quant= avctx->mpeg_quant; 282 s->rtp_mode= !!avctx->rtp_payload_size; 283 s->intra_dc_precision= avctx->intra_dc_precision; 284 s->user_specified_pts = AV_NOPTS_VALUE; 285 286 if (s->gop_size <= 1) { 287 s->intra_only = 1; 288 s->gop_size = 12; 289 } else { 290 s->intra_only = 0; 291 } 292 293 s->me_method = avctx->me_method; 294 295 /* Fixed QSCALE */ 296 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE); 297 298 s->adaptive_quant= ( s->avctx->lumi_masking 299 || s->avctx->dark_masking 300 || s->avctx->temporal_cplx_masking 301 || s->avctx->spatial_cplx_masking 302 || s->avctx->p_masking 303 || s->avctx->border_masking 304 || (s->flags&CODEC_FLAG_QP_RD)) 305 && !s->fixed_qscale; 306 307 s->obmc= !!(s->flags & CODEC_FLAG_OBMC); 308 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER); 309 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN); 310 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC); 311 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT); 312 313 if(avctx->rc_max_rate && !avctx->rc_buffer_size){ 314 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n"); 315 return -1; 316 } 317 318 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){ 319 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n"); 320 } 321 322 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){ 323 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n"); 324 return -1; 325 } 326 327 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){ 328 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n"); 329 return -1; 330 } 331 332 if(avctx->rc_max_rate && avctx->rc_max_rate == avctx->bit_rate && avctx->rc_max_rate != avctx->rc_min_rate){ 333 av_log(avctx, AV_LOG_INFO, "impossible bitrate constraints, this will fail\n"); 334 } 335 336 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){ 337 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n"); 338 return -1; 339 } 340 341 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){ 342 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n"); 343 return -1; 344 } 345 346 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate 347 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) 348 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){ 349 350 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n"); 351 } 352 353 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4 354 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){ 355 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n"); 356 return -1; 357 } 358 359 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){ 360 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n"); 361 return -1; 362 } 363 364 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){ 365 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n"); 366 return -1; 367 } 368 369 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){ 370 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n"); 371 return -1; 372 } 373 374 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){ 375 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n"); 376 return -1; 377 } 378 379 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){ 380 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n"); 381 return -1; 382 } 383 384 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)) 385 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){ 386 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n"); 387 return -1; 388 } 389 390 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too 391 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n"); 392 return -1; 393 } 394 395 if((s->flags & CODEC_FLAG_CBP_RD) && !avctx->trellis){ 396 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n"); 397 return -1; 398 } 399 400 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){ 401 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n"); 402 return -1; 403 } 404 405 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){ 406 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection are not supported yet, set threshold to 1000000000\n"); 407 return -1; 408 } 409 410 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){ 411 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n"); 412 return -1; 413 } 414 415 if(s->flags & CODEC_FLAG_LOW_DELAY){ 416 if (s->codec_id != CODEC_ID_MPEG2VIDEO){ 417 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg2\n"); 418 return -1; 419 } 420 if (s->max_b_frames != 0){ 421 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n"); 422 return -1; 423 } 424 } 425 426 if(s->q_scale_type == 1){ 427 if(s->codec_id != CODEC_ID_MPEG2VIDEO){ 428 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n"); 429 return -1; 430 } 431 if(avctx->qmax > 12){ 432 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n"); 433 return -1; 434 } 435 } 436 437 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4 438 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO 439 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){ 440 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n"); 441 return -1; 442 } 443 444 if(s->avctx->thread_count > 1) 445 s->rtp_mode= 1; 446 447 if(!avctx->time_base.den || !avctx->time_base.num){ 448 av_log(avctx, AV_LOG_ERROR, "framerate not set\n"); 449 return -1; 450 } 451 452 i= (INT_MAX/2+128)>>8; 453 if(avctx->me_threshold >= i){ 454 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1); 455 return -1; 456 } 457 if(avctx->mb_threshold >= i){ 458 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1); 459 return -1; 460 } 461 462 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){ 463 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n"); 464 avctx->b_frame_strategy = 0; 465 } 466 467 i= av_gcd(avctx->time_base.den, avctx->time_base.num); 468 if(i > 1){ 469 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n"); 470 avctx->time_base.den /= i; 471 avctx->time_base.num /= i; 472// return -1; 473 } 474 475 if(s->codec_id==CODEC_ID_MJPEG){ 476 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x 477 s->inter_quant_bias= 0; 478 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){ 479 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x 480 s->inter_quant_bias= 0; 481 }else{ 482 s->intra_quant_bias=0; 483 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x 484 } 485 486 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS) 487 s->intra_quant_bias= avctx->intra_quant_bias; 488 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS) 489 s->inter_quant_bias= avctx->inter_quant_bias; 490 491 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift); 492 493 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){ 494 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n"); 495 return -1; 496 } 497 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1; 498 499 switch(avctx->codec->id) { 500 case CODEC_ID_MPEG1VIDEO: 501 s->out_format = FMT_MPEG1; 502 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); 503 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 504 break; 505 case CODEC_ID_MPEG2VIDEO: 506 s->out_format = FMT_MPEG1; 507 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY); 508 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 509 s->rtp_mode= 1; 510 break; 511 case CODEC_ID_LJPEG: 512 case CODEC_ID_MJPEG: 513 s->out_format = FMT_MJPEG; 514 s->intra_only = 1; /* force intra only for jpeg */ 515 s->mjpeg_vsample[0] = 2; 516 s->mjpeg_vsample[1] = 2>>chroma_v_shift; 517 s->mjpeg_vsample[2] = 2>>chroma_v_shift; 518 s->mjpeg_hsample[0] = 2; 519 s->mjpeg_hsample[1] = 2>>chroma_h_shift; 520 s->mjpeg_hsample[2] = 2>>chroma_h_shift; 521 if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) 522 || ff_mjpeg_encode_init(s) < 0) 523 return -1; 524 avctx->delay=0; 525 s->low_delay=1; 526 break; 527 case CODEC_ID_H261: 528 if (!CONFIG_H261_ENCODER) return -1; 529 if (ff_h261_get_picture_format(s->width, s->height) < 0) { 530 av_log(avctx, AV_LOG_ERROR, "The specified picture size of %dx%d is not valid for the H.261 codec.\nValid sizes are 176x144, 352x288\n", s->width, s->height); 531 return -1; 532 } 533 s->out_format = FMT_H261; 534 avctx->delay=0; 535 s->low_delay=1; 536 break; 537 case CODEC_ID_H263: 538 if (!CONFIG_H263_ENCODER) return -1; 539 if (h263_get_picture_format(s->width, s->height) == 7) { 540 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height); 541 return -1; 542 } 543 s->out_format = FMT_H263; 544 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; 545 avctx->delay=0; 546 s->low_delay=1; 547 break; 548 case CODEC_ID_H263P: 549 s->out_format = FMT_H263; 550 s->h263_plus = 1; 551 /* Fx */ 552 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0; 553 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0; 554 s->modified_quant= s->h263_aic; 555 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0; 556 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0; 557 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0; 558 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; 559 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0; 560 561 /* /Fx */ 562 /* These are just to be sure */ 563 avctx->delay=0; 564 s->low_delay=1; 565 break; 566 case CODEC_ID_FLV1: 567 s->out_format = FMT_H263; 568 s->h263_flv = 2; /* format = 1; 11-bit codes */ 569 s->unrestricted_mv = 1; 570 s->rtp_mode=0; /* don't allow GOB */ 571 avctx->delay=0; 572 s->low_delay=1; 573 break; 574 case CODEC_ID_RV10: 575 s->out_format = FMT_H263; 576 avctx->delay=0; 577 s->low_delay=1; 578 break; 579 case CODEC_ID_RV20: 580 s->out_format = FMT_H263; 581 avctx->delay=0; 582 s->low_delay=1; 583 s->modified_quant=1; 584 s->h263_aic=1; 585 s->h263_plus=1; 586 s->loop_filter=1; 587 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus; 588 break; 589 case CODEC_ID_MPEG4: 590 s->out_format = FMT_H263; 591 s->h263_pred = 1; 592 s->unrestricted_mv = 1; 593 s->low_delay= s->max_b_frames ? 0 : 1; 594 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1); 595 break; 596 case CODEC_ID_MSMPEG4V1: 597 s->out_format = FMT_H263; 598 s->h263_msmpeg4 = 1; 599 s->h263_pred = 1; 600 s->unrestricted_mv = 1; 601 s->msmpeg4_version= 1; 602 avctx->delay=0; 603 s->low_delay=1; 604 break; 605 case CODEC_ID_MSMPEG4V2: 606 s->out_format = FMT_H263; 607 s->h263_msmpeg4 = 1; 608 s->h263_pred = 1; 609 s->unrestricted_mv = 1; 610 s->msmpeg4_version= 2; 611 avctx->delay=0; 612 s->low_delay=1; 613 break; 614 case CODEC_ID_MSMPEG4V3: 615 s->out_format = FMT_H263; 616 s->h263_msmpeg4 = 1; 617 s->h263_pred = 1; 618 s->unrestricted_mv = 1; 619 s->msmpeg4_version= 3; 620 s->flipflop_rounding=1; 621 avctx->delay=0; 622 s->low_delay=1; 623 break; 624 case CODEC_ID_WMV1: 625 s->out_format = FMT_H263; 626 s->h263_msmpeg4 = 1; 627 s->h263_pred = 1; 628 s->unrestricted_mv = 1; 629 s->msmpeg4_version= 4; 630 s->flipflop_rounding=1; 631 avctx->delay=0; 632 s->low_delay=1; 633 break; 634 case CODEC_ID_WMV2: 635 s->out_format = FMT_H263; 636 s->h263_msmpeg4 = 1; 637 s->h263_pred = 1; 638 s->unrestricted_mv = 1; 639 s->msmpeg4_version= 5; 640 s->flipflop_rounding=1; 641 avctx->delay=0; 642 s->low_delay=1; 643 break; 644 default: 645 return -1; 646 } 647 648 avctx->has_b_frames= !s->low_delay; 649 650 s->encoding = 1; 651 652 /* init */ 653 if (MPV_common_init(s) < 0) 654 return -1; 655 656 if(!s->dct_quantize) 657 s->dct_quantize = dct_quantize_c; 658 if(!s->denoise_dct) 659 s->denoise_dct = denoise_dct_c; 660 s->fast_dct_quantize = s->dct_quantize; 661 if(avctx->trellis) 662 s->dct_quantize = dct_quantize_trellis_c; 663 664 if((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant) 665 s->chroma_qscale_table= ff_h263_chroma_qscale_table; 666 s->progressive_frame= 667 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN)); 668 s->quant_precision=5; 669 670 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp); 671 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp); 672 673 if (CONFIG_H261_ENCODER && s->out_format == FMT_H261) 674 ff_h261_encode_init(s); 675 if (CONFIG_ANY_H263_ENCODER && s->out_format == FMT_H263) 676 h263_encode_init(s); 677 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version) 678 ff_msmpeg4_encode_init(s); 679 if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) 680 && s->out_format == FMT_MPEG1) 681 ff_mpeg1_encode_init(s); 682 683 /* init q matrix */ 684 for(i=0;i<64;i++) { 685 int j= s->dsp.idct_permutation[i]; 686 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){ 687 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i]; 688 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i]; 689 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){ 690 s->intra_matrix[j] = 691 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; 692 }else 693 { /* mpeg1/2 */ 694 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i]; 695 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i]; 696 } 697 if(s->avctx->intra_matrix) 698 s->intra_matrix[j] = s->avctx->intra_matrix[i]; 699 if(s->avctx->inter_matrix) 700 s->inter_matrix[j] = s->avctx->inter_matrix[i]; 701 } 702 703 /* precompute matrix */ 704 /* for mjpeg, we do include qscale in the matrix */ 705 if (s->out_format != FMT_MJPEG) { 706 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 707 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1); 708 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16, 709 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0); 710 } 711 712 if(ff_rate_control_init(s) < 0) 713 return -1; 714 715 return 0; 716} 717 718av_cold int MPV_encode_end(AVCodecContext *avctx) 719{ 720 MpegEncContext *s = avctx->priv_data; 721 722 ff_rate_control_uninit(s); 723 724 MPV_common_end(s); 725 if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) && s->out_format == FMT_MJPEG) 726 ff_mjpeg_encode_close(s); 727 728 av_freep(&avctx->extradata); 729 730 return 0; 731} 732 733static int get_sae(uint8_t *src, int ref, int stride){ 734 int x,y; 735 int acc=0; 736 737 for(y=0; y<16; y++){ 738 for(x=0; x<16; x++){ 739 acc+= FFABS(src[x+y*stride] - ref); 740 } 741 } 742 743 return acc; 744} 745 746static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){ 747 int x, y, w, h; 748 int acc=0; 749 750 w= s->width &~15; 751 h= s->height&~15; 752 753 for(y=0; y<h; y+=16){ 754 for(x=0; x<w; x+=16){ 755 int offset= x + y*stride; 756 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16); 757 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8; 758 int sae = get_sae(src + offset, mean, stride); 759 760 acc+= sae + 500 < sad; 761 } 762 } 763 return acc; 764} 765 766 767static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){ 768 AVFrame *pic=NULL; 769 int64_t pts; 770 int i; 771 const int encoding_delay= s->max_b_frames; 772 int direct=1; 773 774 if(pic_arg){ 775 pts= pic_arg->pts; 776 pic_arg->display_picture_number= s->input_picture_number++; 777 778 if(pts != AV_NOPTS_VALUE){ 779 if(s->user_specified_pts != AV_NOPTS_VALUE){ 780 int64_t time= pts; 781 int64_t last= s->user_specified_pts; 782 783 if(time <= last){ 784 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts); 785 return -1; 786 } 787 } 788 s->user_specified_pts= pts; 789 }else{ 790 if(s->user_specified_pts != AV_NOPTS_VALUE){ 791 s->user_specified_pts= 792 pts= s->user_specified_pts + 1; 793 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts); 794 }else{ 795 pts= pic_arg->display_picture_number; 796 } 797 } 798 } 799 800 if(pic_arg){ 801 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0; 802 if(pic_arg->linesize[0] != s->linesize) direct=0; 803 if(pic_arg->linesize[1] != s->uvlinesize) direct=0; 804 if(pic_arg->linesize[2] != s->uvlinesize) direct=0; 805 806// av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize); 807 808 if(direct){ 809 i= ff_find_unused_picture(s, 1); 810 811 pic= (AVFrame*)&s->picture[i]; 812 pic->reference= 3; 813 814 for(i=0; i<4; i++){ 815 pic->data[i]= pic_arg->data[i]; 816 pic->linesize[i]= pic_arg->linesize[i]; 817 } 818 alloc_picture(s, (Picture*)pic, 1); 819 }else{ 820 i= ff_find_unused_picture(s, 0); 821 822 pic= (AVFrame*)&s->picture[i]; 823 pic->reference= 3; 824 825 alloc_picture(s, (Picture*)pic, 0); 826 827 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0] 828 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1] 829 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){ 830 // empty 831 }else{ 832 int h_chroma_shift, v_chroma_shift; 833 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift); 834 835 for(i=0; i<3; i++){ 836 int src_stride= pic_arg->linesize[i]; 837 int dst_stride= i ? s->uvlinesize : s->linesize; 838 int h_shift= i ? h_chroma_shift : 0; 839 int v_shift= i ? v_chroma_shift : 0; 840 int w= s->width >>h_shift; 841 int h= s->height>>v_shift; 842 uint8_t *src= pic_arg->data[i]; 843 uint8_t *dst= pic->data[i]; 844 845 if(!s->avctx->rc_buffer_size) 846 dst +=INPLACE_OFFSET; 847 848 if(src_stride==dst_stride) 849 memcpy(dst, src, src_stride*h); 850 else{ 851 while(h--){ 852 memcpy(dst, src, w); 853 dst += dst_stride; 854 src += src_stride; 855 } 856 } 857 } 858 } 859 } 860 copy_picture_attributes(s, pic, pic_arg); 861 pic->pts= pts; //we set this here to avoid modifiying pic_arg 862 } 863 864 /* shift buffer entries */ 865 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++) 866 s->input_picture[i-1]= s->input_picture[i]; 867 868 s->input_picture[encoding_delay]= (Picture*)pic; 869 870 return 0; 871} 872 873static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){ 874 int x, y, plane; 875 int score=0; 876 int64_t score64=0; 877 878 for(plane=0; plane<3; plane++){ 879 const int stride= p->linesize[plane]; 880 const int bw= plane ? 1 : 2; 881 for(y=0; y<s->mb_height*bw; y++){ 882 for(x=0; x<s->mb_width*bw; x++){ 883 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16; 884 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8); 885 886 switch(s->avctx->frame_skip_exp){ 887 case 0: score= FFMAX(score, v); break; 888 case 1: score+= FFABS(v);break; 889 case 2: score+= v*v;break; 890 case 3: score64+= FFABS(v*v*(int64_t)v);break; 891 case 4: score64+= v*v*(int64_t)(v*v);break; 892 } 893 } 894 } 895 } 896 897 if(score) score64= score; 898 899 if(score64 < s->avctx->frame_skip_threshold) 900 return 1; 901 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8)) 902 return 1; 903 return 0; 904} 905 906static int estimate_best_b_count(MpegEncContext *s){ 907 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id); 908 AVCodecContext *c= avcodec_alloc_context(); 909 AVFrame input[FF_MAX_B_FRAMES+2]; 910 const int scale= s->avctx->brd_scale; 911 int i, j, out_size, p_lambda, b_lambda, lambda2; 912 int outbuf_size= s->width * s->height; //FIXME 913 uint8_t *outbuf= av_malloc(outbuf_size); 914 int64_t best_rd= INT64_MAX; 915 int best_b_count= -1; 916 917 assert(scale>=0 && scale <=3); 918 919// emms_c(); 920 p_lambda= s->last_lambda_for[FF_P_TYPE]; //s->next_picture_ptr->quality; 921 b_lambda= s->last_lambda_for[FF_B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset; 922 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else 923 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT; 924 925 c->width = s->width >> scale; 926 c->height= s->height>> scale; 927 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/; 928 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL; 929 c->mb_decision= s->avctx->mb_decision; 930 c->me_cmp= s->avctx->me_cmp; 931 c->mb_cmp= s->avctx->mb_cmp; 932 c->me_sub_cmp= s->avctx->me_sub_cmp; 933 c->pix_fmt = PIX_FMT_YUV420P; 934 c->time_base= s->avctx->time_base; 935 c->max_b_frames= s->max_b_frames; 936 937 if (avcodec_open(c, codec) < 0) 938 return -1; 939 940 for(i=0; i<s->max_b_frames+2; i++){ 941 int ysize= c->width*c->height; 942 int csize= (c->width/2)*(c->height/2); 943 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr; 944 945 avcodec_get_frame_defaults(&input[i]); 946 input[i].data[0]= av_malloc(ysize + 2*csize); 947 input[i].data[1]= input[i].data[0] + ysize; 948 input[i].data[2]= input[i].data[1] + csize; 949 input[i].linesize[0]= c->width; 950 input[i].linesize[1]= 951 input[i].linesize[2]= c->width/2; 952 953 if(pre_input_ptr && (!i || s->input_picture[i-1])) { 954 pre_input= *pre_input_ptr; 955 956 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) { 957 pre_input.data[0]+=INPLACE_OFFSET; 958 pre_input.data[1]+=INPLACE_OFFSET; 959 pre_input.data[2]+=INPLACE_OFFSET; 960 } 961 962 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height); 963 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1); 964 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1); 965 } 966 } 967 968 for(j=0; j<s->max_b_frames+1; j++){ 969 int64_t rd=0; 970 971 if(!s->input_picture[j]) 972 break; 973 974 c->error[0]= c->error[1]= c->error[2]= 0; 975 976 input[0].pict_type= FF_I_TYPE; 977 input[0].quality= 1 * FF_QP2LAMBDA; 978 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]); 979// rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT; 980 981 for(i=0; i<s->max_b_frames+1; i++){ 982 int is_p= i % (j+1) == j || i==s->max_b_frames; 983 984 input[i+1].pict_type= is_p ? FF_P_TYPE : FF_B_TYPE; 985 input[i+1].quality= is_p ? p_lambda : b_lambda; 986 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]); 987 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); 988 } 989 990 /* get the delayed frames */ 991 while(out_size){ 992 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL); 993 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3); 994 } 995 996 rd += c->error[0] + c->error[1] + c->error[2]; 997 998 if(rd < best_rd){ 999 best_rd= rd; 1000 best_b_count= j; 1001 } 1002 } 1003 1004 av_freep(&outbuf); 1005 avcodec_close(c); 1006 av_freep(&c); 1007 1008 for(i=0; i<s->max_b_frames+2; i++){ 1009 av_freep(&input[i].data[0]); 1010 } 1011 1012 return best_b_count; 1013} 1014 1015static void select_input_picture(MpegEncContext *s){ 1016 int i; 1017 1018 for(i=1; i<MAX_PICTURE_COUNT; i++) 1019 s->reordered_input_picture[i-1]= s->reordered_input_picture[i]; 1020 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL; 1021 1022 /* set next picture type & ordering */ 1023 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){ 1024 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){ 1025 s->reordered_input_picture[0]= s->input_picture[0]; 1026 s->reordered_input_picture[0]->pict_type= FF_I_TYPE; 1027 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; 1028 }else{ 1029 int b_frames; 1030 1031 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){ 1032 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){ 1033 //FIXME check that te gop check above is +-1 correct 1034//av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts); 1035 1036 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){ 1037 for(i=0; i<4; i++) 1038 s->input_picture[0]->data[i]= NULL; 1039 s->input_picture[0]->type= 0; 1040 }else{ 1041 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER 1042 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); 1043 1044 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]); 1045 } 1046 1047 emms_c(); 1048 ff_vbv_update(s, 0); 1049 1050 goto no_output_pic; 1051 } 1052 } 1053 1054 if(s->flags&CODEC_FLAG_PASS2){ 1055 for(i=0; i<s->max_b_frames+1; i++){ 1056 int pict_num= s->input_picture[0]->display_picture_number + i; 1057 1058 if(pict_num >= s->rc_context.num_entries) 1059 break; 1060 if(!s->input_picture[i]){ 1061 s->rc_context.entry[pict_num-1].new_pict_type = FF_P_TYPE; 1062 break; 1063 } 1064 1065 s->input_picture[i]->pict_type= 1066 s->rc_context.entry[pict_num].new_pict_type; 1067 } 1068 } 1069 1070 if(s->avctx->b_frame_strategy==0){ 1071 b_frames= s->max_b_frames; 1072 while(b_frames && !s->input_picture[b_frames]) b_frames--; 1073 }else if(s->avctx->b_frame_strategy==1){ 1074 for(i=1; i<s->max_b_frames+1; i++){ 1075 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){ 1076 s->input_picture[i]->b_frame_score= 1077 get_intra_count(s, s->input_picture[i ]->data[0], 1078 s->input_picture[i-1]->data[0], s->linesize) + 1; 1079 } 1080 } 1081 for(i=0; i<s->max_b_frames+1; i++){ 1082 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break; 1083 } 1084 1085 b_frames= FFMAX(0, i-1); 1086 1087 /* reset scores */ 1088 for(i=0; i<b_frames+1; i++){ 1089 s->input_picture[i]->b_frame_score=0; 1090 } 1091 }else if(s->avctx->b_frame_strategy==2){ 1092 b_frames= estimate_best_b_count(s); 1093 }else{ 1094 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n"); 1095 b_frames=0; 1096 } 1097 1098 emms_c(); 1099//static int b_count=0; 1100//b_count+= b_frames; 1101//av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count); 1102 1103 for(i= b_frames - 1; i>=0; i--){ 1104 int type= s->input_picture[i]->pict_type; 1105 if(type && type != FF_B_TYPE) 1106 b_frames= i; 1107 } 1108 if(s->input_picture[b_frames]->pict_type == FF_B_TYPE && b_frames == s->max_b_frames){ 1109 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n"); 1110 } 1111 1112 if(s->picture_in_gop_number + b_frames >= s->gop_size){ 1113 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){ 1114 b_frames= s->gop_size - s->picture_in_gop_number - 1; 1115 }else{ 1116 if(s->flags & CODEC_FLAG_CLOSED_GOP) 1117 b_frames=0; 1118 s->input_picture[b_frames]->pict_type= FF_I_TYPE; 1119 } 1120 } 1121 1122 if( (s->flags & CODEC_FLAG_CLOSED_GOP) 1123 && b_frames 1124 && s->input_picture[b_frames]->pict_type== FF_I_TYPE) 1125 b_frames--; 1126 1127 s->reordered_input_picture[0]= s->input_picture[b_frames]; 1128 if(s->reordered_input_picture[0]->pict_type != FF_I_TYPE) 1129 s->reordered_input_picture[0]->pict_type= FF_P_TYPE; 1130 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++; 1131 for(i=0; i<b_frames; i++){ 1132 s->reordered_input_picture[i+1]= s->input_picture[i]; 1133 s->reordered_input_picture[i+1]->pict_type= FF_B_TYPE; 1134 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++; 1135 } 1136 } 1137 } 1138no_output_pic: 1139 if(s->reordered_input_picture[0]){ 1140 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=FF_B_TYPE ? 3 : 0; 1141 1142 ff_copy_picture(&s->new_picture, s->reordered_input_picture[0]); 1143 1144 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){ 1145 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable 1146 1147 int i= ff_find_unused_picture(s, 0); 1148 Picture *pic= &s->picture[i]; 1149 1150 pic->reference = s->reordered_input_picture[0]->reference; 1151 alloc_picture(s, pic, 0); 1152 1153 /* mark us unused / free shared pic */ 1154 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL) 1155 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]); 1156 for(i=0; i<4; i++) 1157 s->reordered_input_picture[0]->data[i]= NULL; 1158 s->reordered_input_picture[0]->type= 0; 1159 1160 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]); 1161 1162 s->current_picture_ptr= pic; 1163 }else{ 1164 // input is not a shared pix -> reuse buffer for current_pix 1165 1166 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER 1167 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL); 1168 1169 s->current_picture_ptr= s->reordered_input_picture[0]; 1170 for(i=0; i<4; i++){ 1171 s->new_picture.data[i]+= INPLACE_OFFSET; 1172 } 1173 } 1174 ff_copy_picture(&s->current_picture, s->current_picture_ptr); 1175 1176 s->picture_number= s->new_picture.display_picture_number; 1177//printf("dpn:%d\n", s->picture_number); 1178 }else{ 1179 memset(&s->new_picture, 0, sizeof(Picture)); 1180 } 1181} 1182 1183int MPV_encode_picture(AVCodecContext *avctx, 1184 unsigned char *buf, int buf_size, void *data) 1185{ 1186 MpegEncContext *s = avctx->priv_data; 1187 AVFrame *pic_arg = data; 1188 int i, stuffing_count; 1189 1190 for(i=0; i<avctx->thread_count; i++){ 1191 int start_y= s->thread_context[i]->start_mb_y; 1192 int end_y= s->thread_context[i]-> end_mb_y; 1193 int h= s->mb_height; 1194 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h); 1195 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h); 1196 1197 init_put_bits(&s->thread_context[i]->pb, start, end - start); 1198 } 1199 1200 s->picture_in_gop_number++; 1201 1202 if(load_input_picture(s, pic_arg) < 0) 1203 return -1; 1204 1205 select_input_picture(s); 1206 1207 /* output? */ 1208 if(s->new_picture.data[0]){ 1209 s->pict_type= s->new_picture.pict_type; 1210//emms_c(); 1211//printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale); 1212 MPV_frame_start(s, avctx); 1213vbv_retry: 1214 if (encode_picture(s, s->picture_number) < 0) 1215 return -1; 1216 1217 avctx->real_pict_num = s->picture_number; 1218 avctx->header_bits = s->header_bits; 1219 avctx->mv_bits = s->mv_bits; 1220 avctx->misc_bits = s->misc_bits; 1221 avctx->i_tex_bits = s->i_tex_bits; 1222 avctx->p_tex_bits = s->p_tex_bits; 1223 avctx->i_count = s->i_count; 1224 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx 1225 avctx->skip_count = s->skip_count; 1226 1227 MPV_frame_end(s); 1228 1229 if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG) 1230 ff_mjpeg_encode_picture_trailer(s); 1231 1232 if(avctx->rc_buffer_size){ 1233 RateControlContext *rcc= &s->rc_context; 1234 int max_size= rcc->buffer_index * avctx->rc_max_available_vbv_use; 1235 1236 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){ 1237 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale); 1238 if(s->adaptive_quant){ 1239 int i; 1240 for(i=0; i<s->mb_height*s->mb_stride; i++) 1241 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale); 1242 } 1243 s->mb_skipped = 0; //done in MPV_frame_start() 1244 if(s->pict_type==FF_P_TYPE){ //done in encode_picture() so we must undo it 1245 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) 1246 s->no_rounding ^= 1; 1247 } 1248 if(s->pict_type!=FF_B_TYPE){ 1249 s->time_base= s->last_time_base; 1250 s->last_non_b_time= s->time - s->pp_time; 1251 } 1252// av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda); 1253 for(i=0; i<avctx->thread_count; i++){ 1254 PutBitContext *pb= &s->thread_context[i]->pb; 1255 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf); 1256 } 1257 goto vbv_retry; 1258 } 1259 1260 assert(s->avctx->rc_max_rate); 1261 } 1262 1263 if(s->flags&CODEC_FLAG_PASS1) 1264 ff_write_pass1_stats(s); 1265 1266 for(i=0; i<4; i++){ 1267 s->current_picture_ptr->error[i]= s->current_picture.error[i]; 1268 avctx->error[i] += s->current_picture_ptr->error[i]; 1269 } 1270 1271 if(s->flags&CODEC_FLAG_PASS1) 1272 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb)); 1273 flush_put_bits(&s->pb); 1274 s->frame_bits = put_bits_count(&s->pb); 1275 1276 stuffing_count= ff_vbv_update(s, s->frame_bits); 1277 if(stuffing_count){ 1278 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){ 1279 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n"); 1280 return -1; 1281 } 1282 1283 switch(s->codec_id){ 1284 case CODEC_ID_MPEG1VIDEO: 1285 case CODEC_ID_MPEG2VIDEO: 1286 while(stuffing_count--){ 1287 put_bits(&s->pb, 8, 0); 1288 } 1289 break; 1290 case CODEC_ID_MPEG4: 1291 put_bits(&s->pb, 16, 0); 1292 put_bits(&s->pb, 16, 0x1C3); 1293 stuffing_count -= 4; 1294 while(stuffing_count--){ 1295 put_bits(&s->pb, 8, 0xFF); 1296 } 1297 break; 1298 default: 1299 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n"); 1300 } 1301 flush_put_bits(&s->pb); 1302 s->frame_bits = put_bits_count(&s->pb); 1303 } 1304 1305 /* update mpeg1/2 vbv_delay for CBR */ 1306 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1 1307 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){ 1308 int vbv_delay; 1309 1310 assert(s->repeat_first_field==0); 1311 1312 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate); 1313 assert(vbv_delay < 0xFFFF); 1314 1315 s->vbv_delay_ptr[0] &= 0xF8; 1316 s->vbv_delay_ptr[0] |= vbv_delay>>13; 1317 s->vbv_delay_ptr[1] = vbv_delay>>5; 1318 s->vbv_delay_ptr[2] &= 0x07; 1319 s->vbv_delay_ptr[2] |= vbv_delay<<3; 1320 } 1321 s->total_bits += s->frame_bits; 1322 avctx->frame_bits = s->frame_bits; 1323 }else{ 1324 assert((pbBufPtr(&s->pb) == s->pb.buf)); 1325 s->frame_bits=0; 1326 } 1327 assert((s->frame_bits&7)==0); 1328 1329 return s->frame_bits/8; 1330} 1331 1332static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold) 1333{ 1334 static const char tab[64]= 1335 {3,2,2,1,1,1,1,1, 1336 1,1,1,1,1,1,1,1, 1337 1,1,1,1,1,1,1,1, 1338 0,0,0,0,0,0,0,0, 1339 0,0,0,0,0,0,0,0, 1340 0,0,0,0,0,0,0,0, 1341 0,0,0,0,0,0,0,0, 1342 0,0,0,0,0,0,0,0}; 1343 int score=0; 1344 int run=0; 1345 int i; 1346 DCTELEM *block= s->block[n]; 1347 const int last_index= s->block_last_index[n]; 1348 int skip_dc; 1349 1350 if(threshold<0){ 1351 skip_dc=0; 1352 threshold= -threshold; 1353 }else 1354 skip_dc=1; 1355 1356 /* Are all we could set to zero already zero? */ 1357 if(last_index<=skip_dc - 1) return; 1358 1359 for(i=0; i<=last_index; i++){ 1360 const int j = s->intra_scantable.permutated[i]; 1361 const int level = FFABS(block[j]); 1362 if(level==1){ 1363 if(skip_dc && i==0) continue; 1364 score+= tab[run]; 1365 run=0; 1366 }else if(level>1){ 1367 return; 1368 }else{ 1369 run++; 1370 } 1371 } 1372 if(score >= threshold) return; 1373 for(i=skip_dc; i<=last_index; i++){ 1374 const int j = s->intra_scantable.permutated[i]; 1375 block[j]=0; 1376 } 1377 if(block[0]) s->block_last_index[n]= 0; 1378 else s->block_last_index[n]= -1; 1379} 1380 1381static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index) 1382{ 1383 int i; 1384 const int maxlevel= s->max_qcoeff; 1385 const int minlevel= s->min_qcoeff; 1386 int overflow=0; 1387 1388 if(s->mb_intra){ 1389 i=1; //skip clipping of intra dc 1390 }else 1391 i=0; 1392 1393 for(;i<=last_index; i++){ 1394 const int j= s->intra_scantable.permutated[i]; 1395 int level = block[j]; 1396 1397 if (level>maxlevel){ 1398 level=maxlevel; 1399 overflow++; 1400 }else if(level<minlevel){ 1401 level=minlevel; 1402 overflow++; 1403 } 1404 1405 block[j]= level; 1406 } 1407 1408 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE) 1409 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel); 1410} 1411 1412static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride){ 1413 int x, y; 1414//FIXME optimize 1415 for(y=0; y<8; y++){ 1416 for(x=0; x<8; x++){ 1417 int x2, y2; 1418 int sum=0; 1419 int sqr=0; 1420 int count=0; 1421 1422 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){ 1423 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){ 1424 int v= ptr[x2 + y2*stride]; 1425 sum += v; 1426 sqr += v*v; 1427 count++; 1428 } 1429 } 1430 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count; 1431 } 1432 } 1433} 1434 1435static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count) 1436{ 1437 int16_t weight[8][64]; 1438 DCTELEM orig[8][64]; 1439 const int mb_x= s->mb_x; 1440 const int mb_y= s->mb_y; 1441 int i; 1442 int skip_dct[8]; 1443 int dct_offset = s->linesize*8; //default for progressive frames 1444 uint8_t *ptr_y, *ptr_cb, *ptr_cr; 1445 int wrap_y, wrap_c; 1446 1447 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct; 1448 1449 if(s->adaptive_quant){ 1450 const int last_qp= s->qscale; 1451 const int mb_xy= mb_x + mb_y*s->mb_stride; 1452 1453 s->lambda= s->lambda_table[mb_xy]; 1454 update_qscale(s); 1455 1456 if(!(s->flags&CODEC_FLAG_QP_RD)){ 1457 s->qscale= s->current_picture_ptr->qscale_table[mb_xy]; 1458 s->dquant= s->qscale - last_qp; 1459 1460 if(s->out_format==FMT_H263){ 1461 s->dquant= av_clip(s->dquant, -2, 2); 1462 1463 if(s->codec_id==CODEC_ID_MPEG4){ 1464 if(!s->mb_intra){ 1465 if(s->pict_type == FF_B_TYPE){ 1466 if(s->dquant&1 || s->mv_dir&MV_DIRECT) 1467 s->dquant= 0; 1468 } 1469 if(s->mv_type==MV_TYPE_8X8) 1470 s->dquant=0; 1471 } 1472 } 1473 } 1474 } 1475 ff_set_qscale(s, last_qp + s->dquant); 1476 }else if(s->flags&CODEC_FLAG_QP_RD) 1477 ff_set_qscale(s, s->qscale + s->dquant); 1478 1479 wrap_y = s->linesize; 1480 wrap_c = s->uvlinesize; 1481 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16; 1482 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; 1483 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8; 1484 1485 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){ 1486 uint8_t *ebuf= s->edge_emu_buffer + 32; 1487 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height); 1488 ptr_y= ebuf; 1489 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); 1490 ptr_cb= ebuf+18*wrap_y; 1491 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1); 1492 ptr_cr= ebuf+18*wrap_y+8; 1493 } 1494 1495 if (s->mb_intra) { 1496 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ 1497 int progressive_score, interlaced_score; 1498 1499 s->interlaced_dct=0; 1500 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8) 1501 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400; 1502 1503 if(progressive_score > 0){ 1504 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8) 1505 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8); 1506 if(progressive_score > interlaced_score){ 1507 s->interlaced_dct=1; 1508 1509 dct_offset= wrap_y; 1510 wrap_y<<=1; 1511 if (s->chroma_format == CHROMA_422) 1512 wrap_c<<=1; 1513 } 1514 } 1515 } 1516 1517 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y); 1518 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y); 1519 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y); 1520 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y); 1521 1522 if(s->flags&CODEC_FLAG_GRAY){ 1523 skip_dct[4]= 1; 1524 skip_dct[5]= 1; 1525 }else{ 1526 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c); 1527 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c); 1528 if(!s->chroma_y_shift){ /* 422 */ 1529 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c); 1530 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c); 1531 } 1532 } 1533 }else{ 1534 op_pixels_func (*op_pix)[4]; 1535 qpel_mc_func (*op_qpix)[16]; 1536 uint8_t *dest_y, *dest_cb, *dest_cr; 1537 1538 dest_y = s->dest[0]; 1539 dest_cb = s->dest[1]; 1540 dest_cr = s->dest[2]; 1541 1542 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){ 1543 op_pix = s->dsp.put_pixels_tab; 1544 op_qpix= s->dsp.put_qpel_pixels_tab; 1545 }else{ 1546 op_pix = s->dsp.put_no_rnd_pixels_tab; 1547 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab; 1548 } 1549 1550 if (s->mv_dir & MV_DIR_FORWARD) { 1551 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix); 1552 op_pix = s->dsp.avg_pixels_tab; 1553 op_qpix= s->dsp.avg_qpel_pixels_tab; 1554 } 1555 if (s->mv_dir & MV_DIR_BACKWARD) { 1556 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix); 1557 } 1558 1559 if(s->flags&CODEC_FLAG_INTERLACED_DCT){ 1560 int progressive_score, interlaced_score; 1561 1562 s->interlaced_dct=0; 1563 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8) 1564 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400; 1565 1566 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400; 1567 1568 if(progressive_score>0){ 1569 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8) 1570 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8); 1571 1572 if(progressive_score > interlaced_score){ 1573 s->interlaced_dct=1; 1574 1575 dct_offset= wrap_y; 1576 wrap_y<<=1; 1577 if (s->chroma_format == CHROMA_422) 1578 wrap_c<<=1; 1579 } 1580 } 1581 } 1582 1583 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y); 1584 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y); 1585 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y); 1586 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y); 1587 1588 if(s->flags&CODEC_FLAG_GRAY){ 1589 skip_dct[4]= 1; 1590 skip_dct[5]= 1; 1591 }else{ 1592 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c); 1593 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c); 1594 if(!s->chroma_y_shift){ /* 422 */ 1595 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c); 1596 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c); 1597 } 1598 } 1599 /* pre quantization */ 1600 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){ 1601 //FIXME optimize 1602 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1; 1603 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1; 1604 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1; 1605 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1; 1606 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1; 1607 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1; 1608 if(!s->chroma_y_shift){ /* 422 */ 1609 if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1; 1610 if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1; 1611 } 1612 } 1613 } 1614 1615 if(s->avctx->quantizer_noise_shaping){ 1616 if(!skip_dct[0]) get_visual_weight(weight[0], ptr_y , wrap_y); 1617 if(!skip_dct[1]) get_visual_weight(weight[1], ptr_y + 8, wrap_y); 1618 if(!skip_dct[2]) get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y); 1619 if(!skip_dct[3]) get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y); 1620 if(!skip_dct[4]) get_visual_weight(weight[4], ptr_cb , wrap_c); 1621 if(!skip_dct[5]) get_visual_weight(weight[5], ptr_cr , wrap_c); 1622 if(!s->chroma_y_shift){ /* 422 */ 1623 if(!skip_dct[6]) get_visual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c); 1624 if(!skip_dct[7]) get_visual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c); 1625 } 1626 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count); 1627 } 1628 1629 /* DCT & quantize */ 1630 assert(s->out_format!=FMT_MJPEG || s->qscale==8); 1631 { 1632 for(i=0;i<mb_block_count;i++) { 1633 if(!skip_dct[i]){ 1634 int overflow; 1635 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow); 1636 // FIXME we could decide to change to quantizer instead of clipping 1637 // JS: I don't think that would be a good idea it could lower quality instead 1638 // of improve it. Just INTRADC clipping deserves changes in quantizer 1639 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]); 1640 }else 1641 s->block_last_index[i]= -1; 1642 } 1643 if(s->avctx->quantizer_noise_shaping){ 1644 for(i=0;i<mb_block_count;i++) { 1645 if(!skip_dct[i]){ 1646 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale); 1647 } 1648 } 1649 } 1650 1651 if(s->luma_elim_threshold && !s->mb_intra) 1652 for(i=0; i<4; i++) 1653 dct_single_coeff_elimination(s, i, s->luma_elim_threshold); 1654 if(s->chroma_elim_threshold && !s->mb_intra) 1655 for(i=4; i<mb_block_count; i++) 1656 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold); 1657 1658 if(s->flags & CODEC_FLAG_CBP_RD){ 1659 for(i=0;i<mb_block_count;i++) { 1660 if(s->block_last_index[i] == -1) 1661 s->coded_score[i]= INT_MAX/256; 1662 } 1663 } 1664 } 1665 1666 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){ 1667 s->block_last_index[4]= 1668 s->block_last_index[5]= 0; 1669 s->block[4][0]= 1670 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale; 1671 } 1672 1673 //non c quantize code returns incorrect block_last_index FIXME 1674 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){ 1675 for(i=0; i<mb_block_count; i++){ 1676 int j; 1677 if(s->block_last_index[i]>0){ 1678 for(j=63; j>0; j--){ 1679 if(s->block[i][ s->intra_scantable.permutated[j] ]) break; 1680 } 1681 s->block_last_index[i]= j; 1682 } 1683 } 1684 } 1685 1686 /* huffman encode */ 1687 switch(s->codec_id){ //FIXME funct ptr could be slightly faster 1688 case CODEC_ID_MPEG1VIDEO: 1689 case CODEC_ID_MPEG2VIDEO: 1690 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) 1691 mpeg1_encode_mb(s, s->block, motion_x, motion_y); 1692 break; 1693 case CODEC_ID_MPEG4: 1694 if (CONFIG_MPEG4_ENCODER) 1695 mpeg4_encode_mb(s, s->block, motion_x, motion_y); 1696 break; 1697 case CODEC_ID_MSMPEG4V2: 1698 case CODEC_ID_MSMPEG4V3: 1699 case CODEC_ID_WMV1: 1700 if (CONFIG_MSMPEG4_ENCODER) 1701 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); 1702 break; 1703 case CODEC_ID_WMV2: 1704 if (CONFIG_WMV2_ENCODER) 1705 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); 1706 break; 1707 case CODEC_ID_H261: 1708 if (CONFIG_H261_ENCODER) 1709 ff_h261_encode_mb(s, s->block, motion_x, motion_y); 1710 break; 1711 case CODEC_ID_H263: 1712 case CODEC_ID_H263P: 1713 case CODEC_ID_FLV1: 1714 case CODEC_ID_RV10: 1715 case CODEC_ID_RV20: 1716 if (CONFIG_H263_ENCODER || CONFIG_H263P_ENCODER || 1717 CONFIG_FLV_ENCODER || CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER) 1718 h263_encode_mb(s, s->block, motion_x, motion_y); 1719 break; 1720 case CODEC_ID_MJPEG: 1721 if (CONFIG_MJPEG_ENCODER) 1722 ff_mjpeg_encode_mb(s, s->block); 1723 break; 1724 default: 1725 assert(0); 1726 } 1727} 1728 1729static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y) 1730{ 1731 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6); 1732 else encode_mb_internal(s, motion_x, motion_y, 16, 8); 1733} 1734 1735static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){ 1736 int i; 1737 1738 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? 1739 1740 /* mpeg1 */ 1741 d->mb_skip_run= s->mb_skip_run; 1742 for(i=0; i<3; i++) 1743 d->last_dc[i]= s->last_dc[i]; 1744 1745 /* statistics */ 1746 d->mv_bits= s->mv_bits; 1747 d->i_tex_bits= s->i_tex_bits; 1748 d->p_tex_bits= s->p_tex_bits; 1749 d->i_count= s->i_count; 1750 d->f_count= s->f_count; 1751 d->b_count= s->b_count; 1752 d->skip_count= s->skip_count; 1753 d->misc_bits= s->misc_bits; 1754 d->last_bits= 0; 1755 1756 d->mb_skipped= 0; 1757 d->qscale= s->qscale; 1758 d->dquant= s->dquant; 1759 1760 d->esc3_level_length= s->esc3_level_length; 1761} 1762 1763static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ 1764 int i; 1765 1766 memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); 1767 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? 1768 1769 /* mpeg1 */ 1770 d->mb_skip_run= s->mb_skip_run; 1771 for(i=0; i<3; i++) 1772 d->last_dc[i]= s->last_dc[i]; 1773 1774 /* statistics */ 1775 d->mv_bits= s->mv_bits; 1776 d->i_tex_bits= s->i_tex_bits; 1777 d->p_tex_bits= s->p_tex_bits; 1778 d->i_count= s->i_count; 1779 d->f_count= s->f_count; 1780 d->b_count= s->b_count; 1781 d->skip_count= s->skip_count; 1782 d->misc_bits= s->misc_bits; 1783 1784 d->mb_intra= s->mb_intra; 1785 d->mb_skipped= s->mb_skipped; 1786 d->mv_type= s->mv_type; 1787 d->mv_dir= s->mv_dir; 1788 d->pb= s->pb; 1789 if(s->data_partitioning){ 1790 d->pb2= s->pb2; 1791 d->tex_pb= s->tex_pb; 1792 } 1793 d->block= s->block; 1794 for(i=0; i<8; i++) 1795 d->block_last_index[i]= s->block_last_index[i]; 1796 d->interlaced_dct= s->interlaced_dct; 1797 d->qscale= s->qscale; 1798 1799 d->esc3_level_length= s->esc3_level_length; 1800} 1801 1802static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type, 1803 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2], 1804 int *dmin, int *next_block, int motion_x, int motion_y) 1805{ 1806 int score; 1807 uint8_t *dest_backup[3]; 1808 1809 copy_context_before_encode(s, backup, type); 1810 1811 s->block= s->blocks[*next_block]; 1812 s->pb= pb[*next_block]; 1813 if(s->data_partitioning){ 1814 s->pb2 = pb2 [*next_block]; 1815 s->tex_pb= tex_pb[*next_block]; 1816 } 1817 1818 if(*next_block){ 1819 memcpy(dest_backup, s->dest, sizeof(s->dest)); 1820 s->dest[0] = s->rd_scratchpad; 1821 s->dest[1] = s->rd_scratchpad + 16*s->linesize; 1822 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8; 1823 assert(s->linesize >= 32); //FIXME 1824 } 1825 1826 encode_mb(s, motion_x, motion_y); 1827 1828 score= put_bits_count(&s->pb); 1829 if(s->data_partitioning){ 1830 score+= put_bits_count(&s->pb2); 1831 score+= put_bits_count(&s->tex_pb); 1832 } 1833 1834 if(s->avctx->mb_decision == FF_MB_DECISION_RD){ 1835 MPV_decode_mb(s, s->block); 1836 1837 score *= s->lambda2; 1838 score += sse_mb(s) << FF_LAMBDA_SHIFT; 1839 } 1840 1841 if(*next_block){ 1842 memcpy(s->dest, dest_backup, sizeof(s->dest)); 1843 } 1844 1845 if(score<*dmin){ 1846 *dmin= score; 1847 *next_block^=1; 1848 1849 copy_context_after_encode(best, s, type); 1850 } 1851} 1852 1853static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){ 1854 uint32_t *sq = ff_squareTbl + 256; 1855 int acc=0; 1856 int x,y; 1857 1858 if(w==16 && h==16) 1859 return s->dsp.sse[0](NULL, src1, src2, stride, 16); 1860 else if(w==8 && h==8) 1861 return s->dsp.sse[1](NULL, src1, src2, stride, 8); 1862 1863 for(y=0; y<h; y++){ 1864 for(x=0; x<w; x++){ 1865 acc+= sq[src1[x + y*stride] - src2[x + y*stride]]; 1866 } 1867 } 1868 1869 assert(acc>=0); 1870 1871 return acc; 1872} 1873 1874static int sse_mb(MpegEncContext *s){ 1875 int w= 16; 1876 int h= 16; 1877 1878 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; 1879 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; 1880 1881 if(w==16 && h==16) 1882 if(s->avctx->mb_cmp == FF_CMP_NSSE){ 1883 return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) 1884 +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) 1885 +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); 1886 }else{ 1887 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16) 1888 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8) 1889 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8); 1890 } 1891 else 1892 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize) 1893 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize) 1894 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize); 1895} 1896 1897static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){ 1898 MpegEncContext *s= *(void**)arg; 1899 1900 1901 s->me.pre_pass=1; 1902 s->me.dia_size= s->avctx->pre_dia_size; 1903 s->first_slice_line=1; 1904 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) { 1905 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) { 1906 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y); 1907 } 1908 s->first_slice_line=0; 1909 } 1910 1911 s->me.pre_pass=0; 1912 1913 return 0; 1914} 1915 1916static int estimate_motion_thread(AVCodecContext *c, void *arg){ 1917 MpegEncContext *s= *(void**)arg; 1918 1919 ff_check_alignment(); 1920 1921 s->me.dia_size= s->avctx->dia_size; 1922 s->first_slice_line=1; 1923 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { 1924 s->mb_x=0; //for block init below 1925 ff_init_block_index(s); 1926 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { 1927 s->block_index[0]+=2; 1928 s->block_index[1]+=2; 1929 s->block_index[2]+=2; 1930 s->block_index[3]+=2; 1931 1932 /* compute motion vector & mb_type and store in context */ 1933 if(s->pict_type==FF_B_TYPE) 1934 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y); 1935 else 1936 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y); 1937 } 1938 s->first_slice_line=0; 1939 } 1940 return 0; 1941} 1942 1943static int mb_var_thread(AVCodecContext *c, void *arg){ 1944 MpegEncContext *s= *(void**)arg; 1945 int mb_x, mb_y; 1946 1947 ff_check_alignment(); 1948 1949 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { 1950 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 1951 int xx = mb_x * 16; 1952 int yy = mb_y * 16; 1953 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx; 1954 int varc; 1955 int sum = s->dsp.pix_sum(pix, s->linesize); 1956 1957 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8; 1958 1959 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc; 1960 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8; 1961 s->me.mb_var_sum_temp += varc; 1962 } 1963 } 1964 return 0; 1965} 1966 1967static void write_slice_end(MpegEncContext *s){ 1968 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){ 1969 if(s->partitioned_frame){ 1970 ff_mpeg4_merge_partitions(s); 1971 } 1972 1973 ff_mpeg4_stuffing(&s->pb); 1974 }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){ 1975 ff_mjpeg_encode_stuffing(&s->pb); 1976 } 1977 1978 align_put_bits(&s->pb); 1979 flush_put_bits(&s->pb); 1980 1981 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame) 1982 s->misc_bits+= get_bits_diff(s); 1983} 1984 1985static int encode_thread(AVCodecContext *c, void *arg){ 1986 MpegEncContext *s= *(void**)arg; 1987 int mb_x, mb_y, pdif = 0; 1988 int chr_h= 16>>s->chroma_y_shift; 1989 int i, j; 1990 MpegEncContext best_s, backup_s; 1991 uint8_t bit_buf[2][MAX_MB_BYTES]; 1992 uint8_t bit_buf2[2][MAX_MB_BYTES]; 1993 uint8_t bit_buf_tex[2][MAX_MB_BYTES]; 1994 PutBitContext pb[2], pb2[2], tex_pb[2]; 1995//printf("%d->%d\n", s->resync_mb_y, s->end_mb_y); 1996 1997 ff_check_alignment(); 1998 1999 for(i=0; i<2; i++){ 2000 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES); 2001 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES); 2002 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES); 2003 } 2004 2005 s->last_bits= put_bits_count(&s->pb); 2006 s->mv_bits=0; 2007 s->misc_bits=0; 2008 s->i_tex_bits=0; 2009 s->p_tex_bits=0; 2010 s->i_count=0; 2011 s->f_count=0; 2012 s->b_count=0; 2013 s->skip_count=0; 2014 2015 for(i=0; i<3; i++){ 2016 /* init last dc values */ 2017 /* note: quant matrix value (8) is implied here */ 2018 s->last_dc[i] = 128 << s->intra_dc_precision; 2019 2020 s->current_picture.error[i] = 0; 2021 } 2022 s->mb_skip_run = 0; 2023 memset(s->last_mv, 0, sizeof(s->last_mv)); 2024 2025 s->last_mv_dir = 0; 2026 2027 switch(s->codec_id){ 2028 case CODEC_ID_H263: 2029 case CODEC_ID_H263P: 2030 case CODEC_ID_FLV1: 2031 if (CONFIG_H263_ENCODER || CONFIG_H263P_ENCODER || CONFIG_FLV_ENCODER) 2032 s->gob_index = ff_h263_get_gob_height(s); 2033 break; 2034 case CODEC_ID_MPEG4: 2035 if(CONFIG_MPEG4_ENCODER && s->partitioned_frame) 2036 ff_mpeg4_init_partitions(s); 2037 break; 2038 } 2039 2040 s->resync_mb_x=0; 2041 s->resync_mb_y=0; 2042 s->first_slice_line = 1; 2043 s->ptr_lastgob = s->pb.buf; 2044 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) { 2045// printf("row %d at %X\n", s->mb_y, (int)s); 2046 s->mb_x=0; 2047 s->mb_y= mb_y; 2048 2049 ff_set_qscale(s, s->qscale); 2050 ff_init_block_index(s); 2051 2052 for(mb_x=0; mb_x < s->mb_width; mb_x++) { 2053 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this 2054 int mb_type= s->mb_type[xy]; 2055// int d; 2056 int dmin= INT_MAX; 2057 int dir; 2058 2059 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){ 2060 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); 2061 return -1; 2062 } 2063 if(s->data_partitioning){ 2064 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES 2065 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){ 2066 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); 2067 return -1; 2068 } 2069 } 2070 2071 s->mb_x = mb_x; 2072 s->mb_y = mb_y; // moved into loop, can get changed by H.261 2073 ff_update_block_index(s); 2074 2075 if(CONFIG_H261_ENCODER && s->codec_id == CODEC_ID_H261){ 2076 ff_h261_reorder_mb_index(s); 2077 xy= s->mb_y*s->mb_stride + s->mb_x; 2078 mb_type= s->mb_type[xy]; 2079 } 2080 2081 /* write gob / video packet header */ 2082 if(s->rtp_mode){ 2083 int current_packet_size, is_gob_start; 2084 2085 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf); 2086 2087 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0; 2088 2089 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1; 2090 2091 switch(s->codec_id){ 2092 case CODEC_ID_H263: 2093 case CODEC_ID_H263P: 2094 if(!s->h263_slice_structured) 2095 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0; 2096 break; 2097 case CODEC_ID_MPEG2VIDEO: 2098 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1; 2099 case CODEC_ID_MPEG1VIDEO: 2100 if(s->mb_skip_run) is_gob_start=0; 2101 break; 2102 } 2103 2104 if(is_gob_start){ 2105 if(s->start_mb_y != mb_y || mb_x!=0){ 2106 write_slice_end(s); 2107 2108 if(CONFIG_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){ 2109 ff_mpeg4_init_partitions(s); 2110 } 2111 } 2112 2113 assert((put_bits_count(&s->pb)&7) == 0); 2114 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob; 2115 2116 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){ 2117 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y; 2118 int d= 100 / s->avctx->error_rate; 2119 if(r % d == 0){ 2120 current_packet_size=0; 2121#ifndef ALT_BITSTREAM_WRITER 2122 s->pb.buf_ptr= s->ptr_lastgob; 2123#endif 2124 assert(pbBufPtr(&s->pb) == s->ptr_lastgob); 2125 } 2126 } 2127 2128 if (s->avctx->rtp_callback){ 2129 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x; 2130 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb); 2131 } 2132 2133 switch(s->codec_id){ 2134 case CODEC_ID_MPEG4: 2135 if (CONFIG_MPEG4_ENCODER) { 2136 ff_mpeg4_encode_video_packet_header(s); 2137 ff_mpeg4_clean_buffers(s); 2138 } 2139 break; 2140 case CODEC_ID_MPEG1VIDEO: 2141 case CODEC_ID_MPEG2VIDEO: 2142 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) { 2143 ff_mpeg1_encode_slice_header(s); 2144 ff_mpeg1_clean_buffers(s); 2145 } 2146 break; 2147 case CODEC_ID_H263: 2148 case CODEC_ID_H263P: 2149 if (CONFIG_H263_ENCODER || CONFIG_H263P_ENCODER) 2150 h263_encode_gob_header(s, mb_y); 2151 break; 2152 } 2153 2154 if(s->flags&CODEC_FLAG_PASS1){ 2155 int bits= put_bits_count(&s->pb); 2156 s->misc_bits+= bits - s->last_bits; 2157 s->last_bits= bits; 2158 } 2159 2160 s->ptr_lastgob += current_packet_size; 2161 s->first_slice_line=1; 2162 s->resync_mb_x=mb_x; 2163 s->resync_mb_y=mb_y; 2164 } 2165 } 2166 2167 if( (s->resync_mb_x == s->mb_x) 2168 && s->resync_mb_y+1 == s->mb_y){ 2169 s->first_slice_line=0; 2170 } 2171 2172 s->mb_skipped=0; 2173 s->dquant=0; //only for QP_RD 2174 2175 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD 2176 int next_block=0; 2177 int pb_bits_count, pb2_bits_count, tex_pb_bits_count; 2178 2179 copy_context_before_encode(&backup_s, s, -1); 2180 backup_s.pb= s->pb; 2181 best_s.data_partitioning= s->data_partitioning; 2182 best_s.partitioned_frame= s->partitioned_frame; 2183 if(s->data_partitioning){ 2184 backup_s.pb2= s->pb2; 2185 backup_s.tex_pb= s->tex_pb; 2186 } 2187 2188 if(mb_type&CANDIDATE_MB_TYPE_INTER){ 2189 s->mv_dir = MV_DIR_FORWARD; 2190 s->mv_type = MV_TYPE_16X16; 2191 s->mb_intra= 0; 2192 s->mv[0][0][0] = s->p_mv_table[xy][0]; 2193 s->mv[0][0][1] = s->p_mv_table[xy][1]; 2194 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb, 2195 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); 2196 } 2197 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){ 2198 s->mv_dir = MV_DIR_FORWARD; 2199 s->mv_type = MV_TYPE_FIELD; 2200 s->mb_intra= 0; 2201 for(i=0; i<2; i++){ 2202 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; 2203 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; 2204 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; 2205 } 2206 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb, 2207 &dmin, &next_block, 0, 0); 2208 } 2209 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){ 2210 s->mv_dir = MV_DIR_FORWARD; 2211 s->mv_type = MV_TYPE_16X16; 2212 s->mb_intra= 0; 2213 s->mv[0][0][0] = 0; 2214 s->mv[0][0][1] = 0; 2215 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb, 2216 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); 2217 } 2218 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){ 2219 s->mv_dir = MV_DIR_FORWARD; 2220 s->mv_type = MV_TYPE_8X8; 2221 s->mb_intra= 0; 2222 for(i=0; i<4; i++){ 2223 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; 2224 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; 2225 } 2226 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb, 2227 &dmin, &next_block, 0, 0); 2228 } 2229 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){ 2230 s->mv_dir = MV_DIR_FORWARD; 2231 s->mv_type = MV_TYPE_16X16; 2232 s->mb_intra= 0; 2233 s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; 2234 s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; 2235 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb, 2236 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]); 2237 } 2238 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){ 2239 s->mv_dir = MV_DIR_BACKWARD; 2240 s->mv_type = MV_TYPE_16X16; 2241 s->mb_intra= 0; 2242 s->mv[1][0][0] = s->b_back_mv_table[xy][0]; 2243 s->mv[1][0][1] = s->b_back_mv_table[xy][1]; 2244 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb, 2245 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]); 2246 } 2247 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){ 2248 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 2249 s->mv_type = MV_TYPE_16X16; 2250 s->mb_intra= 0; 2251 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; 2252 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; 2253 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; 2254 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; 2255 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb, 2256 &dmin, &next_block, 0, 0); 2257 } 2258 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){ 2259 s->mv_dir = MV_DIR_FORWARD; 2260 s->mv_type = MV_TYPE_FIELD; 2261 s->mb_intra= 0; 2262 for(i=0; i<2; i++){ 2263 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; 2264 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; 2265 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; 2266 } 2267 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb, 2268 &dmin, &next_block, 0, 0); 2269 } 2270 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){ 2271 s->mv_dir = MV_DIR_BACKWARD; 2272 s->mv_type = MV_TYPE_FIELD; 2273 s->mb_intra= 0; 2274 for(i=0; i<2; i++){ 2275 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; 2276 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; 2277 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; 2278 } 2279 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb, 2280 &dmin, &next_block, 0, 0); 2281 } 2282 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){ 2283 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 2284 s->mv_type = MV_TYPE_FIELD; 2285 s->mb_intra= 0; 2286 for(dir=0; dir<2; dir++){ 2287 for(i=0; i<2; i++){ 2288 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; 2289 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; 2290 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; 2291 } 2292 } 2293 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb, 2294 &dmin, &next_block, 0, 0); 2295 } 2296 if(mb_type&CANDIDATE_MB_TYPE_INTRA){ 2297 s->mv_dir = 0; 2298 s->mv_type = MV_TYPE_16X16; 2299 s->mb_intra= 1; 2300 s->mv[0][0][0] = 0; 2301 s->mv[0][0][1] = 0; 2302 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb, 2303 &dmin, &next_block, 0, 0); 2304 if(s->h263_pred || s->h263_aic){ 2305 if(best_s.mb_intra) 2306 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1; 2307 else 2308 ff_clean_intra_table_entries(s); //old mode? 2309 } 2310 } 2311 2312 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){ 2313 if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD 2314 const int last_qp= backup_s.qscale; 2315 int qpi, qp, dc[6]; 2316 DCTELEM ac[6][16]; 2317 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0; 2318 static const int dquant_tab[4]={-1,1,-2,2}; 2319 2320 assert(backup_s.dquant == 0); 2321 2322 //FIXME intra 2323 s->mv_dir= best_s.mv_dir; 2324 s->mv_type = MV_TYPE_16X16; 2325 s->mb_intra= best_s.mb_intra; 2326 s->mv[0][0][0] = best_s.mv[0][0][0]; 2327 s->mv[0][0][1] = best_s.mv[0][0][1]; 2328 s->mv[1][0][0] = best_s.mv[1][0][0]; 2329 s->mv[1][0][1] = best_s.mv[1][0][1]; 2330 2331 qpi = s->pict_type == FF_B_TYPE ? 2 : 0; 2332 for(; qpi<4; qpi++){ 2333 int dquant= dquant_tab[qpi]; 2334 qp= last_qp + dquant; 2335 if(qp < s->avctx->qmin || qp > s->avctx->qmax) 2336 continue; 2337 backup_s.dquant= dquant; 2338 if(s->mb_intra && s->dc_val[0]){ 2339 for(i=0; i<6; i++){ 2340 dc[i]= s->dc_val[0][ s->block_index[i] ]; 2341 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16); 2342 } 2343 } 2344 2345 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 2346 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]); 2347 if(best_s.qscale != qp){ 2348 if(s->mb_intra && s->dc_val[0]){ 2349 for(i=0; i<6; i++){ 2350 s->dc_val[0][ s->block_index[i] ]= dc[i]; 2351 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16); 2352 } 2353 } 2354 } 2355 } 2356 } 2357 } 2358 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){ 2359 int mx= s->b_direct_mv_table[xy][0]; 2360 int my= s->b_direct_mv_table[xy][1]; 2361 2362 backup_s.dquant = 0; 2363 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 2364 s->mb_intra= 0; 2365 ff_mpeg4_set_direct_mv(s, mx, my); 2366 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 2367 &dmin, &next_block, mx, my); 2368 } 2369 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){ 2370 backup_s.dquant = 0; 2371 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT; 2372 s->mb_intra= 0; 2373 ff_mpeg4_set_direct_mv(s, 0, 0); 2374 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb, 2375 &dmin, &next_block, 0, 0); 2376 } 2377 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){ 2378 int coded=0; 2379 for(i=0; i<6; i++) 2380 coded |= s->block_last_index[i]; 2381 if(coded){ 2382 int mx,my; 2383 memcpy(s->mv, best_s.mv, sizeof(s->mv)); 2384 if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){ 2385 mx=my=0; //FIXME find the one we actually used 2386 ff_mpeg4_set_direct_mv(s, mx, my); 2387 }else if(best_s.mv_dir&MV_DIR_BACKWARD){ 2388 mx= s->mv[1][0][0]; 2389 my= s->mv[1][0][1]; 2390 }else{ 2391 mx= s->mv[0][0][0]; 2392 my= s->mv[0][0][1]; 2393 } 2394 2395 s->mv_dir= best_s.mv_dir; 2396 s->mv_type = best_s.mv_type; 2397 s->mb_intra= 0; 2398/* s->mv[0][0][0] = best_s.mv[0][0][0]; 2399 s->mv[0][0][1] = best_s.mv[0][0][1]; 2400 s->mv[1][0][0] = best_s.mv[1][0][0]; 2401 s->mv[1][0][1] = best_s.mv[1][0][1];*/ 2402 backup_s.dquant= 0; 2403 s->skipdct=1; 2404 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb, 2405 &dmin, &next_block, mx, my); 2406 s->skipdct=0; 2407 } 2408 } 2409 2410 s->current_picture.qscale_table[xy]= best_s.qscale; 2411 2412 copy_context_after_encode(s, &best_s, -1); 2413 2414 pb_bits_count= put_bits_count(&s->pb); 2415 flush_put_bits(&s->pb); 2416 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count); 2417 s->pb= backup_s.pb; 2418 2419 if(s->data_partitioning){ 2420 pb2_bits_count= put_bits_count(&s->pb2); 2421 flush_put_bits(&s->pb2); 2422 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count); 2423 s->pb2= backup_s.pb2; 2424 2425 tex_pb_bits_count= put_bits_count(&s->tex_pb); 2426 flush_put_bits(&s->tex_pb); 2427 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count); 2428 s->tex_pb= backup_s.tex_pb; 2429 } 2430 s->last_bits= put_bits_count(&s->pb); 2431 2432 if (CONFIG_ANY_H263_ENCODER && 2433 s->out_format == FMT_H263 && s->pict_type!=FF_B_TYPE) 2434 ff_h263_update_motion_val(s); 2435 2436 if(next_block==0){ //FIXME 16 vs linesize16 2437 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16); 2438 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8); 2439 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8); 2440 } 2441 2442 if(s->avctx->mb_decision == FF_MB_DECISION_BITS) 2443 MPV_decode_mb(s, s->block); 2444 } else { 2445 int motion_x = 0, motion_y = 0; 2446 s->mv_type=MV_TYPE_16X16; 2447 // only one MB-Type possible 2448 2449 switch(mb_type){ 2450 case CANDIDATE_MB_TYPE_INTRA: 2451 s->mv_dir = 0; 2452 s->mb_intra= 1; 2453 motion_x= s->mv[0][0][0] = 0; 2454 motion_y= s->mv[0][0][1] = 0; 2455 break; 2456 case CANDIDATE_MB_TYPE_INTER: 2457 s->mv_dir = MV_DIR_FORWARD; 2458 s->mb_intra= 0; 2459 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0]; 2460 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1]; 2461 break; 2462 case CANDIDATE_MB_TYPE_INTER_I: 2463 s->mv_dir = MV_DIR_FORWARD; 2464 s->mv_type = MV_TYPE_FIELD; 2465 s->mb_intra= 0; 2466 for(i=0; i<2; i++){ 2467 j= s->field_select[0][i] = s->p_field_select_table[i][xy]; 2468 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0]; 2469 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1]; 2470 } 2471 break; 2472 case CANDIDATE_MB_TYPE_INTER4V: 2473 s->mv_dir = MV_DIR_FORWARD; 2474 s->mv_type = MV_TYPE_8X8; 2475 s->mb_intra= 0; 2476 for(i=0; i<4; i++){ 2477 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0]; 2478 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1]; 2479 } 2480 break; 2481 case CANDIDATE_MB_TYPE_DIRECT: 2482 if (CONFIG_MPEG4_ENCODER) { 2483 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT; 2484 s->mb_intra= 0; 2485 motion_x=s->b_direct_mv_table[xy][0]; 2486 motion_y=s->b_direct_mv_table[xy][1]; 2487 ff_mpeg4_set_direct_mv(s, motion_x, motion_y); 2488 } 2489 break; 2490 case CANDIDATE_MB_TYPE_DIRECT0: 2491 if (CONFIG_MPEG4_ENCODER) { 2492 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT; 2493 s->mb_intra= 0; 2494 ff_mpeg4_set_direct_mv(s, 0, 0); 2495 } 2496 break; 2497 case CANDIDATE_MB_TYPE_BIDIR: 2498 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 2499 s->mb_intra= 0; 2500 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0]; 2501 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1]; 2502 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0]; 2503 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1]; 2504 break; 2505 case CANDIDATE_MB_TYPE_BACKWARD: 2506 s->mv_dir = MV_DIR_BACKWARD; 2507 s->mb_intra= 0; 2508 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0]; 2509 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1]; 2510 break; 2511 case CANDIDATE_MB_TYPE_FORWARD: 2512 s->mv_dir = MV_DIR_FORWARD; 2513 s->mb_intra= 0; 2514 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0]; 2515 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1]; 2516// printf(" %d %d ", motion_x, motion_y); 2517 break; 2518 case CANDIDATE_MB_TYPE_FORWARD_I: 2519 s->mv_dir = MV_DIR_FORWARD; 2520 s->mv_type = MV_TYPE_FIELD; 2521 s->mb_intra= 0; 2522 for(i=0; i<2; i++){ 2523 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy]; 2524 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0]; 2525 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1]; 2526 } 2527 break; 2528 case CANDIDATE_MB_TYPE_BACKWARD_I: 2529 s->mv_dir = MV_DIR_BACKWARD; 2530 s->mv_type = MV_TYPE_FIELD; 2531 s->mb_intra= 0; 2532 for(i=0; i<2; i++){ 2533 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy]; 2534 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0]; 2535 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1]; 2536 } 2537 break; 2538 case CANDIDATE_MB_TYPE_BIDIR_I: 2539 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD; 2540 s->mv_type = MV_TYPE_FIELD; 2541 s->mb_intra= 0; 2542 for(dir=0; dir<2; dir++){ 2543 for(i=0; i<2; i++){ 2544 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy]; 2545 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0]; 2546 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1]; 2547 } 2548 } 2549 break; 2550 default: 2551 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n"); 2552 } 2553 2554 encode_mb(s, motion_x, motion_y); 2555 2556 // RAL: Update last macroblock type 2557 s->last_mv_dir = s->mv_dir; 2558 2559 if (CONFIG_ANY_H263_ENCODER && 2560 s->out_format == FMT_H263 && s->pict_type!=FF_B_TYPE) 2561 ff_h263_update_motion_val(s); 2562 2563 MPV_decode_mb(s, s->block); 2564 } 2565 2566 /* clean the MV table in IPS frames for direct mode in B frames */ 2567 if(s->mb_intra /* && I,P,S_TYPE */){ 2568 s->p_mv_table[xy][0]=0; 2569 s->p_mv_table[xy][1]=0; 2570 } 2571 2572 if(s->flags&CODEC_FLAG_PSNR){ 2573 int w= 16; 2574 int h= 16; 2575 2576 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16; 2577 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16; 2578 2579 s->current_picture.error[0] += sse( 2580 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, 2581 s->dest[0], w, h, s->linesize); 2582 s->current_picture.error[1] += sse( 2583 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h, 2584 s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize); 2585 s->current_picture.error[2] += sse( 2586 s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*chr_h, 2587 s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize); 2588 } 2589 if(s->loop_filter){ 2590 if(CONFIG_ANY_H263_ENCODER && s->out_format == FMT_H263) 2591 ff_h263_loop_filter(s); 2592 } 2593//printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb)); 2594 } 2595 } 2596 2597 //not beautiful here but we must write it before flushing so it has to be here 2598 if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == FF_I_TYPE) 2599 msmpeg4_encode_ext_header(s); 2600 2601 write_slice_end(s); 2602 2603 /* Send the last GOB if RTP */ 2604 if (s->avctx->rtp_callback) { 2605 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x; 2606 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob; 2607 /* Call the RTP callback to send the last GOB */ 2608 emms_c(); 2609 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb); 2610 } 2611 2612 return 0; 2613} 2614 2615#define MERGE(field) dst->field += src->field; src->field=0 2616static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){ 2617 MERGE(me.scene_change_score); 2618 MERGE(me.mc_mb_var_sum_temp); 2619 MERGE(me.mb_var_sum_temp); 2620} 2621 2622static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){ 2623 int i; 2624 2625 MERGE(dct_count[0]); //note, the other dct vars are not part of the context 2626 MERGE(dct_count[1]); 2627 MERGE(mv_bits); 2628 MERGE(i_tex_bits); 2629 MERGE(p_tex_bits); 2630 MERGE(i_count); 2631 MERGE(f_count); 2632 MERGE(b_count); 2633 MERGE(skip_count); 2634 MERGE(misc_bits); 2635 MERGE(error_count); 2636 MERGE(padding_bug_score); 2637 MERGE(current_picture.error[0]); 2638 MERGE(current_picture.error[1]); 2639 MERGE(current_picture.error[2]); 2640 2641 if(dst->avctx->noise_reduction){ 2642 for(i=0; i<64; i++){ 2643 MERGE(dct_error_sum[0][i]); 2644 MERGE(dct_error_sum[1][i]); 2645 } 2646 } 2647 2648 assert(put_bits_count(&src->pb) % 8 ==0); 2649 assert(put_bits_count(&dst->pb) % 8 ==0); 2650 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb)); 2651 flush_put_bits(&dst->pb); 2652} 2653 2654static int estimate_qp(MpegEncContext *s, int dry_run){ 2655 if (s->next_lambda){ 2656 s->current_picture_ptr->quality= 2657 s->current_picture.quality = s->next_lambda; 2658 if(!dry_run) s->next_lambda= 0; 2659 } else if (!s->fixed_qscale) { 2660 s->current_picture_ptr->quality= 2661 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run); 2662 if (s->current_picture.quality < 0) 2663 return -1; 2664 } 2665 2666 if(s->adaptive_quant){ 2667 switch(s->codec_id){ 2668 case CODEC_ID_MPEG4: 2669 if (CONFIG_MPEG4_ENCODER) 2670 ff_clean_mpeg4_qscales(s); 2671 break; 2672 case CODEC_ID_H263: 2673 case CODEC_ID_H263P: 2674 case CODEC_ID_FLV1: 2675 if (CONFIG_H263_ENCODER||CONFIG_H263P_ENCODER||CONFIG_FLV_ENCODER) 2676 ff_clean_h263_qscales(s); 2677 break; 2678 } 2679 2680 s->lambda= s->lambda_table[0]; 2681 //FIXME broken 2682 }else 2683 s->lambda= s->current_picture.quality; 2684//printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality); 2685 update_qscale(s); 2686 return 0; 2687} 2688 2689/* must be called before writing the header */ 2690static void set_frame_distances(MpegEncContext * s){ 2691 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE); 2692 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num; 2693 2694 if(s->pict_type==FF_B_TYPE){ 2695 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); 2696 assert(s->pb_time > 0 && s->pb_time < s->pp_time); 2697 }else{ 2698 s->pp_time= s->time - s->last_non_b_time; 2699 s->last_non_b_time= s->time; 2700 assert(s->picture_number==0 || s->pp_time > 0); 2701 } 2702} 2703 2704static int encode_picture(MpegEncContext *s, int picture_number) 2705{ 2706 int i; 2707 int bits; 2708 2709 s->picture_number = picture_number; 2710 2711 /* Reset the average MB variance */ 2712 s->me.mb_var_sum_temp = 2713 s->me.mc_mb_var_sum_temp = 0; 2714 2715 /* we need to initialize some time vars before we can encode b-frames */ 2716 // RAL: Condition added for MPEG1VIDEO 2717 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4)) 2718 set_frame_distances(s); 2719 if(CONFIG_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4) 2720 ff_set_mpeg4_time(s); 2721 2722 s->me.scene_change_score=0; 2723 2724// s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion 2725 2726 if(s->pict_type==FF_I_TYPE){ 2727 if(s->msmpeg4_version >= 3) s->no_rounding=1; 2728 else s->no_rounding=0; 2729 }else if(s->pict_type!=FF_B_TYPE){ 2730 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4) 2731 s->no_rounding ^= 1; 2732 } 2733 2734 if(s->flags & CODEC_FLAG_PASS2){ 2735 if (estimate_qp(s,1) < 0) 2736 return -1; 2737 ff_get_2pass_fcode(s); 2738 }else if(!(s->flags & CODEC_FLAG_QSCALE)){ 2739 if(s->pict_type==FF_B_TYPE) 2740 s->lambda= s->last_lambda_for[s->pict_type]; 2741 else 2742 s->lambda= s->last_lambda_for[s->last_non_b_pict_type]; 2743 update_qscale(s); 2744 } 2745 2746 s->mb_intra=0; //for the rate distortion & bit compare functions 2747 for(i=1; i<s->avctx->thread_count; i++){ 2748 ff_update_duplicate_context(s->thread_context[i], s); 2749 } 2750 2751 if(ff_init_me(s)<0) 2752 return -1; 2753 2754 /* Estimate motion for every MB */ 2755 if(s->pict_type != FF_I_TYPE){ 2756 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8; 2757 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8; 2758 if(s->pict_type != FF_B_TYPE && s->avctx->me_threshold==0){ 2759 if((s->avctx->pre_me && s->last_non_b_pict_type==FF_I_TYPE) || s->avctx->pre_me==2){ 2760 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count, sizeof(void*)); 2761 } 2762 } 2763 2764 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count, sizeof(void*)); 2765 }else /* if(s->pict_type == FF_I_TYPE) */{ 2766 /* I-Frame */ 2767 for(i=0; i<s->mb_stride*s->mb_height; i++) 2768 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; 2769 2770 if(!s->fixed_qscale){ 2771 /* finding spatial complexity for I-frame rate control */ 2772 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count, sizeof(void*)); 2773 } 2774 } 2775 for(i=1; i<s->avctx->thread_count; i++){ 2776 merge_context_after_me(s, s->thread_context[i]); 2777 } 2778 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp; 2779 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp; 2780 emms_c(); 2781 2782 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == FF_P_TYPE){ 2783 s->pict_type= FF_I_TYPE; 2784 for(i=0; i<s->mb_stride*s->mb_height; i++) 2785 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA; 2786//printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum); 2787 } 2788 2789 if(!s->umvplus){ 2790 if(s->pict_type==FF_P_TYPE || s->pict_type==FF_S_TYPE) { 2791 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER); 2792 2793 if(s->flags & CODEC_FLAG_INTERLACED_ME){ 2794 int a,b; 2795 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select 2796 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I); 2797 s->f_code= FFMAX3(s->f_code, a, b); 2798 } 2799 2800 ff_fix_long_p_mvs(s); 2801 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0); 2802 if(s->flags & CODEC_FLAG_INTERLACED_ME){ 2803 int j; 2804 for(i=0; i<2; i++){ 2805 for(j=0; j<2; j++) 2806 ff_fix_long_mvs(s, s->p_field_select_table[i], j, 2807 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0); 2808 } 2809 } 2810 } 2811 2812 if(s->pict_type==FF_B_TYPE){ 2813 int a, b; 2814 2815 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD); 2816 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR); 2817 s->f_code = FFMAX(a, b); 2818 2819 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD); 2820 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR); 2821 s->b_code = FFMAX(a, b); 2822 2823 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1); 2824 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1); 2825 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1); 2826 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1); 2827 if(s->flags & CODEC_FLAG_INTERLACED_ME){ 2828 int dir, j; 2829 for(dir=0; dir<2; dir++){ 2830 for(i=0; i<2; i++){ 2831 for(j=0; j<2; j++){ 2832 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I) 2833 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I); 2834 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j, 2835 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1); 2836 } 2837 } 2838 } 2839 } 2840 } 2841 } 2842 2843 if (estimate_qp(s, 0) < 0) 2844 return -1; 2845 2846 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==FF_I_TYPE && !(s->flags & CODEC_FLAG_QSCALE)) 2847 s->qscale= 3; //reduce clipping problems 2848 2849 if (s->out_format == FMT_MJPEG) { 2850 /* for mjpeg, we do include qscale in the matrix */ 2851 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0]; 2852 for(i=1;i<64;i++){ 2853 int j= s->dsp.idct_permutation[i]; 2854 2855 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3); 2856 } 2857 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16, 2858 s->intra_matrix, s->intra_quant_bias, 8, 8, 1); 2859 s->qscale= 8; 2860 } 2861 2862 //FIXME var duplication 2863 s->current_picture_ptr->key_frame= 2864 s->current_picture.key_frame= s->pict_type == FF_I_TYPE; //FIXME pic_ptr 2865 s->current_picture_ptr->pict_type= 2866 s->current_picture.pict_type= s->pict_type; 2867 2868 if(s->current_picture.key_frame) 2869 s->picture_in_gop_number=0; 2870 2871 s->last_bits= put_bits_count(&s->pb); 2872 switch(s->out_format) { 2873 case FMT_MJPEG: 2874 if (CONFIG_MJPEG_ENCODER) 2875 ff_mjpeg_encode_picture_header(s); 2876 break; 2877 case FMT_H261: 2878 if (CONFIG_H261_ENCODER) 2879 ff_h261_encode_picture_header(s, picture_number); 2880 break; 2881 case FMT_H263: 2882 if (CONFIG_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2) 2883 ff_wmv2_encode_picture_header(s, picture_number); 2884 else if (CONFIG_MSMPEG4_ENCODER && s->h263_msmpeg4) 2885 msmpeg4_encode_picture_header(s, picture_number); 2886 else if (CONFIG_MPEG4_ENCODER && s->h263_pred) 2887 mpeg4_encode_picture_header(s, picture_number); 2888 else if (CONFIG_RV10_ENCODER && s->codec_id == CODEC_ID_RV10) 2889 rv10_encode_picture_header(s, picture_number); 2890 else if (CONFIG_RV20_ENCODER && s->codec_id == CODEC_ID_RV20) 2891 rv20_encode_picture_header(s, picture_number); 2892 else if (CONFIG_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1) 2893 ff_flv_encode_picture_header(s, picture_number); 2894 else if (CONFIG_ANY_H263_ENCODER) 2895 h263_encode_picture_header(s, picture_number); 2896 break; 2897 case FMT_MPEG1: 2898 if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) 2899 mpeg1_encode_picture_header(s, picture_number); 2900 break; 2901 case FMT_H264: 2902 break; 2903 default: 2904 assert(0); 2905 } 2906 bits= put_bits_count(&s->pb); 2907 s->header_bits= bits - s->last_bits; 2908 2909 for(i=1; i<s->avctx->thread_count; i++){ 2910 update_duplicate_context_after_me(s->thread_context[i], s); 2911 } 2912 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count, sizeof(void*)); 2913 for(i=1; i<s->avctx->thread_count; i++){ 2914 merge_context_after_encode(s, s->thread_context[i]); 2915 } 2916 emms_c(); 2917 return 0; 2918} 2919 2920void denoise_dct_c(MpegEncContext *s, DCTELEM *block){ 2921 const int intra= s->mb_intra; 2922 int i; 2923 2924 s->dct_count[intra]++; 2925 2926 for(i=0; i<64; i++){ 2927 int level= block[i]; 2928 2929 if(level){ 2930 if(level>0){ 2931 s->dct_error_sum[intra][i] += level; 2932 level -= s->dct_offset[intra][i]; 2933 if(level<0) level=0; 2934 }else{ 2935 s->dct_error_sum[intra][i] -= level; 2936 level += s->dct_offset[intra][i]; 2937 if(level>0) level=0; 2938 } 2939 block[i]= level; 2940 } 2941 } 2942} 2943 2944int dct_quantize_trellis_c(MpegEncContext *s, 2945 DCTELEM *block, int n, 2946 int qscale, int *overflow){ 2947 const int *qmat; 2948 const uint8_t *scantable= s->intra_scantable.scantable; 2949 const uint8_t *perm_scantable= s->intra_scantable.permutated; 2950 int max=0; 2951 unsigned int threshold1, threshold2; 2952 int bias=0; 2953 int run_tab[65]; 2954 int level_tab[65]; 2955 int score_tab[65]; 2956 int survivor[65]; 2957 int survivor_count; 2958 int last_run=0; 2959 int last_level=0; 2960 int last_score= 0; 2961 int last_i; 2962 int coeff[2][64]; 2963 int coeff_count[64]; 2964 int qmul, qadd, start_i, last_non_zero, i, dc; 2965 const int esc_length= s->ac_esc_length; 2966 uint8_t * length; 2967 uint8_t * last_length; 2968 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6); 2969 2970 s->dsp.fdct (block); 2971 2972 if(s->dct_error_sum) 2973 s->denoise_dct(s, block); 2974 qmul= qscale*16; 2975 qadd= ((qscale-1)|1)*8; 2976 2977 if (s->mb_intra) { 2978 int q; 2979 if (!s->h263_aic) { 2980 if (n < 4) 2981 q = s->y_dc_scale; 2982 else 2983 q = s->c_dc_scale; 2984 q = q << 3; 2985 } else{ 2986 /* For AIC we skip quant/dequant of INTRADC */ 2987 q = 1 << 3; 2988 qadd=0; 2989 } 2990 2991 /* note: block[0] is assumed to be positive */ 2992 block[0] = (block[0] + (q >> 1)) / q; 2993 start_i = 1; 2994 last_non_zero = 0; 2995 qmat = s->q_intra_matrix[qscale]; 2996 if(s->mpeg_quant || s->out_format == FMT_MPEG1) 2997 bias= 1<<(QMAT_SHIFT-1); 2998 length = s->intra_ac_vlc_length; 2999 last_length= s->intra_ac_vlc_last_length; 3000 } else { 3001 start_i = 0; 3002 last_non_zero = -1; 3003 qmat = s->q_inter_matrix[qscale]; 3004 length = s->inter_ac_vlc_length; 3005 last_length= s->inter_ac_vlc_last_length; 3006 } 3007 last_i= start_i; 3008 3009 threshold1= (1<<QMAT_SHIFT) - bias - 1; 3010 threshold2= (threshold1<<1); 3011 3012 for(i=63; i>=start_i; i--) { 3013 const int j = scantable[i]; 3014 int level = block[j] * qmat[j]; 3015 3016 if(((unsigned)(level+threshold1))>threshold2){ 3017 last_non_zero = i; 3018 break; 3019 } 3020 } 3021 3022 for(i=start_i; i<=last_non_zero; i++) { 3023 const int j = scantable[i]; 3024 int level = block[j] * qmat[j]; 3025 3026// if( bias+level >= (1<<(QMAT_SHIFT - 3)) 3027// || bias-level >= (1<<(QMAT_SHIFT - 3))){ 3028 if(((unsigned)(level+threshold1))>threshold2){ 3029 if(level>0){ 3030 level= (bias + level)>>QMAT_SHIFT; 3031 coeff[0][i]= level; 3032 coeff[1][i]= level-1; 3033// coeff[2][k]= level-2; 3034 }else{ 3035 level= (bias - level)>>QMAT_SHIFT; 3036 coeff[0][i]= -level; 3037 coeff[1][i]= -level+1; 3038// coeff[2][k]= -level+2; 3039 } 3040 coeff_count[i]= FFMIN(level, 2); 3041 assert(coeff_count[i]); 3042 max |=level; 3043 }else{ 3044 coeff[0][i]= (level>>31)|1; 3045 coeff_count[i]= 1; 3046 } 3047 } 3048 3049 *overflow= s->max_qcoeff < max; //overflow might have happened 3050 3051 if(last_non_zero < start_i){ 3052 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); 3053 return last_non_zero; 3054 } 3055 3056 score_tab[start_i]= 0; 3057 survivor[0]= start_i; 3058 survivor_count= 1; 3059 3060 for(i=start_i; i<=last_non_zero; i++){ 3061 int level_index, j, zero_distortion; 3062 int dct_coeff= FFABS(block[ scantable[i] ]); 3063 int best_score=256*256*256*120; 3064 3065 if ( s->dsp.fdct == fdct_ifast 3066#ifndef FAAN_POSTSCALE 3067 || s->dsp.fdct == ff_faandct 3068#endif 3069 ) 3070 dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12; 3071 zero_distortion= dct_coeff*dct_coeff; 3072 3073 for(level_index=0; level_index < coeff_count[i]; level_index++){ 3074 int distortion; 3075 int level= coeff[level_index][i]; 3076 const int alevel= FFABS(level); 3077 int unquant_coeff; 3078 3079 assert(level); 3080 3081 if(s->out_format == FMT_H263){ 3082 unquant_coeff= alevel*qmul + qadd; 3083 }else{ //MPEG1 3084 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize 3085 if(s->mb_intra){ 3086 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3; 3087 unquant_coeff = (unquant_coeff - 1) | 1; 3088 }else{ 3089 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4; 3090 unquant_coeff = (unquant_coeff - 1) | 1; 3091 } 3092 unquant_coeff<<= 3; 3093 } 3094 3095 distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion; 3096 level+=64; 3097 if((level&(~127)) == 0){ 3098 for(j=survivor_count-1; j>=0; j--){ 3099 int run= i - survivor[j]; 3100 int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda; 3101 score += score_tab[i-run]; 3102 3103 if(score < best_score){ 3104 best_score= score; 3105 run_tab[i+1]= run; 3106 level_tab[i+1]= level-64; 3107 } 3108 } 3109 3110 if(s->out_format == FMT_H263){ 3111 for(j=survivor_count-1; j>=0; j--){ 3112 int run= i - survivor[j]; 3113 int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda; 3114 score += score_tab[i-run]; 3115 if(score < last_score){ 3116 last_score= score; 3117 last_run= run; 3118 last_level= level-64; 3119 last_i= i+1; 3120 } 3121 } 3122 } 3123 }else{ 3124 distortion += esc_length*lambda; 3125 for(j=survivor_count-1; j>=0; j--){ 3126 int run= i - survivor[j]; 3127 int score= distortion + score_tab[i-run]; 3128 3129 if(score < best_score){ 3130 best_score= score; 3131 run_tab[i+1]= run; 3132 level_tab[i+1]= level-64; 3133 } 3134 } 3135 3136 if(s->out_format == FMT_H263){ 3137 for(j=survivor_count-1; j>=0; j--){ 3138 int run= i - survivor[j]; 3139 int score= distortion + score_tab[i-run]; 3140 if(score < last_score){ 3141 last_score= score; 3142 last_run= run; 3143 last_level= level-64; 3144 last_i= i+1; 3145 } 3146 } 3147 } 3148 } 3149 } 3150 3151 score_tab[i+1]= best_score; 3152 3153 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level 3154 if(last_non_zero <= 27){ 3155 for(; survivor_count; survivor_count--){ 3156 if(score_tab[ survivor[survivor_count-1] ] <= best_score) 3157 break; 3158 } 3159 }else{ 3160 for(; survivor_count; survivor_count--){ 3161 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda) 3162 break; 3163 } 3164 } 3165 3166 survivor[ survivor_count++ ]= i+1; 3167 } 3168 3169 if(s->out_format != FMT_H263){ 3170 last_score= 256*256*256*120; 3171 for(i= survivor[0]; i<=last_non_zero + 1; i++){ 3172 int score= score_tab[i]; 3173 if(i) score += lambda*2; //FIXME exacter? 3174 3175 if(score < last_score){ 3176 last_score= score; 3177 last_i= i; 3178 last_level= level_tab[i]; 3179 last_run= run_tab[i]; 3180 } 3181 } 3182 } 3183 3184 s->coded_score[n] = last_score; 3185 3186 dc= FFABS(block[0]); 3187 last_non_zero= last_i - 1; 3188 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM)); 3189 3190 if(last_non_zero < start_i) 3191 return last_non_zero; 3192 3193 if(last_non_zero == 0 && start_i == 0){ 3194 int best_level= 0; 3195 int best_score= dc * dc; 3196 3197 for(i=0; i<coeff_count[0]; i++){ 3198 int level= coeff[i][0]; 3199 int alevel= FFABS(level); 3200 int unquant_coeff, score, distortion; 3201 3202 if(s->out_format == FMT_H263){ 3203 unquant_coeff= (alevel*qmul + qadd)>>3; 3204 }else{ //MPEG1 3205 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4; 3206 unquant_coeff = (unquant_coeff - 1) | 1; 3207 } 3208 unquant_coeff = (unquant_coeff + 4) >> 3; 3209 unquant_coeff<<= 3 + 3; 3210 3211 distortion= (unquant_coeff - dc) * (unquant_coeff - dc); 3212 level+=64; 3213 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda; 3214 else score= distortion + esc_length*lambda; 3215 3216 if(score < best_score){ 3217 best_score= score; 3218 best_level= level - 64; 3219 } 3220 } 3221 block[0]= best_level; 3222 s->coded_score[n] = best_score - dc*dc; 3223 if(best_level == 0) return -1; 3224 else return last_non_zero; 3225 } 3226 3227 i= last_i; 3228 assert(last_level); 3229 3230 block[ perm_scantable[last_non_zero] ]= last_level; 3231 i -= last_run + 1; 3232 3233 for(; i>start_i; i -= run_tab[i] + 1){ 3234 block[ perm_scantable[i-1] ]= level_tab[i]; 3235 } 3236 3237 return last_non_zero; 3238} 3239 3240//#define REFINE_STATS 1 3241static int16_t basis[64][64]; 3242 3243static void build_basis(uint8_t *perm){ 3244 int i, j, x, y; 3245 emms_c(); 3246 for(i=0; i<8; i++){ 3247 for(j=0; j<8; j++){ 3248 for(y=0; y<8; y++){ 3249 for(x=0; x<8; x++){ 3250 double s= 0.25*(1<<BASIS_SHIFT); 3251 int index= 8*i + j; 3252 int perm_index= perm[index]; 3253 if(i==0) s*= sqrt(0.5); 3254 if(j==0) s*= sqrt(0.5); 3255 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5))); 3256 } 3257 } 3258 } 3259 } 3260} 3261 3262static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise? 3263 DCTELEM *block, int16_t *weight, DCTELEM *orig, 3264 int n, int qscale){ 3265 int16_t rem[64]; 3266 DECLARE_ALIGNED_16(DCTELEM, d1[64]); 3267 const int *qmat; 3268 const uint8_t *scantable= s->intra_scantable.scantable; 3269 const uint8_t *perm_scantable= s->intra_scantable.permutated; 3270// unsigned int threshold1, threshold2; 3271// int bias=0; 3272 int run_tab[65]; 3273 int prev_run=0; 3274 int prev_level=0; 3275 int qmul, qadd, start_i, last_non_zero, i, dc; 3276 uint8_t * length; 3277 uint8_t * last_length; 3278 int lambda; 3279 int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true 3280#ifdef REFINE_STATS 3281static int count=0; 3282static int after_last=0; 3283static int to_zero=0; 3284static int from_zero=0; 3285static int raise=0; 3286static int lower=0; 3287static int messed_sign=0; 3288#endif 3289 3290 if(basis[0][0] == 0) 3291 build_basis(s->dsp.idct_permutation); 3292 3293 qmul= qscale*2; 3294 qadd= (qscale-1)|1; 3295 if (s->mb_intra) { 3296 if (!s->h263_aic) { 3297 if (n < 4) 3298 q = s->y_dc_scale; 3299 else 3300 q = s->c_dc_scale; 3301 } else{ 3302 /* For AIC we skip quant/dequant of INTRADC */ 3303 q = 1; 3304 qadd=0; 3305 } 3306 q <<= RECON_SHIFT-3; 3307 /* note: block[0] is assumed to be positive */ 3308 dc= block[0]*q; 3309// block[0] = (block[0] + (q >> 1)) / q; 3310 start_i = 1; 3311 qmat = s->q_intra_matrix[qscale]; 3312// if(s->mpeg_quant || s->out_format == FMT_MPEG1) 3313// bias= 1<<(QMAT_SHIFT-1); 3314 length = s->intra_ac_vlc_length; 3315 last_length= s->intra_ac_vlc_last_length; 3316 } else { 3317 dc= 0; 3318 start_i = 0; 3319 qmat = s->q_inter_matrix[qscale]; 3320 length = s->inter_ac_vlc_length; 3321 last_length= s->inter_ac_vlc_last_length; 3322 } 3323 last_non_zero = s->block_last_index[n]; 3324 3325#ifdef REFINE_STATS 3326{START_TIMER 3327#endif 3328 dc += (1<<(RECON_SHIFT-1)); 3329 for(i=0; i<64; i++){ 3330 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[] 3331 } 3332#ifdef REFINE_STATS 3333STOP_TIMER("memset rem[]")} 3334#endif 3335 sum=0; 3336 for(i=0; i<64; i++){ 3337 int one= 36; 3338 int qns=4; 3339 int w; 3340 3341 w= FFABS(weight[i]) + qns*one; 3342 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63 3343 3344 weight[i] = w; 3345// w=weight[i] = (63*qns + (w/2)) / w; 3346 3347 assert(w>0); 3348 assert(w<(1<<6)); 3349 sum += w*w; 3350 } 3351 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6); 3352#ifdef REFINE_STATS 3353{START_TIMER 3354#endif 3355 run=0; 3356 rle_index=0; 3357 for(i=start_i; i<=last_non_zero; i++){ 3358 int j= perm_scantable[i]; 3359 const int level= block[j]; 3360 int coeff; 3361 3362 if(level){ 3363 if(level<0) coeff= qmul*level - qadd; 3364 else coeff= qmul*level + qadd; 3365 run_tab[rle_index++]=run; 3366 run=0; 3367 3368 s->dsp.add_8x8basis(rem, basis[j], coeff); 3369 }else{ 3370 run++; 3371 } 3372 } 3373#ifdef REFINE_STATS 3374if(last_non_zero>0){ 3375STOP_TIMER("init rem[]") 3376} 3377} 3378 3379{START_TIMER 3380#endif 3381 for(;;){ 3382 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0); 3383 int best_coeff=0; 3384 int best_change=0; 3385 int run2, best_unquant_change=0, analyze_gradient; 3386#ifdef REFINE_STATS 3387{START_TIMER 3388#endif 3389 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3; 3390 3391 if(analyze_gradient){ 3392#ifdef REFINE_STATS 3393{START_TIMER 3394#endif 3395 for(i=0; i<64; i++){ 3396 int w= weight[i]; 3397 3398 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12); 3399 } 3400#ifdef REFINE_STATS 3401STOP_TIMER("rem*w*w")} 3402{START_TIMER 3403#endif 3404 s->dsp.fdct(d1); 3405#ifdef REFINE_STATS 3406STOP_TIMER("dct")} 3407#endif 3408 } 3409 3410 if(start_i){ 3411 const int level= block[0]; 3412 int change, old_coeff; 3413 3414 assert(s->mb_intra); 3415 3416 old_coeff= q*level; 3417 3418 for(change=-1; change<=1; change+=2){ 3419 int new_level= level + change; 3420 int score, new_coeff; 3421 3422 new_coeff= q*new_level; 3423 if(new_coeff >= 2048 || new_coeff < 0) 3424 continue; 3425 3426 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff); 3427 if(score<best_score){ 3428 best_score= score; 3429 best_coeff= 0; 3430 best_change= change; 3431 best_unquant_change= new_coeff - old_coeff; 3432 } 3433 } 3434 } 3435 3436 run=0; 3437 rle_index=0; 3438 run2= run_tab[rle_index++]; 3439 prev_level=0; 3440 prev_run=0; 3441 3442 for(i=start_i; i<64; i++){ 3443 int j= perm_scantable[i]; 3444 const int level= block[j]; 3445 int change, old_coeff; 3446 3447 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1) 3448 break; 3449 3450 if(level){ 3451 if(level<0) old_coeff= qmul*level - qadd; 3452 else old_coeff= qmul*level + qadd; 3453 run2= run_tab[rle_index++]; //FIXME ! maybe after last 3454 }else{ 3455 old_coeff=0; 3456 run2--; 3457 assert(run2>=0 || i >= last_non_zero ); 3458 } 3459 3460 for(change=-1; change<=1; change+=2){ 3461 int new_level= level + change; 3462 int score, new_coeff, unquant_change; 3463 3464 score=0; 3465 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level)) 3466 continue; 3467 3468 if(new_level){ 3469 if(new_level<0) new_coeff= qmul*new_level - qadd; 3470 else new_coeff= qmul*new_level + qadd; 3471 if(new_coeff >= 2048 || new_coeff <= -2048) 3472 continue; 3473 //FIXME check for overflow 3474 3475 if(level){ 3476 if(level < 63 && level > -63){ 3477 if(i < last_non_zero) 3478 score += length[UNI_AC_ENC_INDEX(run, new_level+64)] 3479 - length[UNI_AC_ENC_INDEX(run, level+64)]; 3480 else 3481 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)] 3482 - last_length[UNI_AC_ENC_INDEX(run, level+64)]; 3483 } 3484 }else{ 3485 assert(FFABS(new_level)==1); 3486 3487 if(analyze_gradient){ 3488 int g= d1[ scantable[i] ]; 3489 if(g && (g^new_level) >= 0) 3490 continue; 3491 } 3492 3493 if(i < last_non_zero){ 3494 int next_i= i + run2 + 1; 3495 int next_level= block[ perm_scantable[next_i] ] + 64; 3496 3497 if(next_level&(~127)) 3498 next_level= 0; 3499 3500 if(next_i < last_non_zero) 3501 score += length[UNI_AC_ENC_INDEX(run, 65)] 3502 + length[UNI_AC_ENC_INDEX(run2, next_level)] 3503 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; 3504 else 3505 score += length[UNI_AC_ENC_INDEX(run, 65)] 3506 + last_length[UNI_AC_ENC_INDEX(run2, next_level)] 3507 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]; 3508 }else{ 3509 score += last_length[UNI_AC_ENC_INDEX(run, 65)]; 3510 if(prev_level){ 3511 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)] 3512 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; 3513 } 3514 } 3515 } 3516 }else{ 3517 new_coeff=0; 3518 assert(FFABS(level)==1); 3519 3520 if(i < last_non_zero){ 3521 int next_i= i + run2 + 1; 3522 int next_level= block[ perm_scantable[next_i] ] + 64; 3523 3524 if(next_level&(~127)) 3525 next_level= 0; 3526 3527 if(next_i < last_non_zero) 3528 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] 3529 - length[UNI_AC_ENC_INDEX(run2, next_level)] 3530 - length[UNI_AC_ENC_INDEX(run, 65)]; 3531 else 3532 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)] 3533 - last_length[UNI_AC_ENC_INDEX(run2, next_level)] 3534 - length[UNI_AC_ENC_INDEX(run, 65)]; 3535 }else{ 3536 score += -last_length[UNI_AC_ENC_INDEX(run, 65)]; 3537 if(prev_level){ 3538 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)] 3539 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)]; 3540 } 3541 } 3542 } 3543 3544 score *= lambda; 3545 3546 unquant_change= new_coeff - old_coeff; 3547 assert((score < 100*lambda && score > -100*lambda) || lambda==0); 3548 3549 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change); 3550 if(score<best_score){ 3551 best_score= score; 3552 best_coeff= i; 3553 best_change= change; 3554 best_unquant_change= unquant_change; 3555 } 3556 } 3557 if(level){ 3558 prev_level= level + 64; 3559 if(prev_level&(~127)) 3560 prev_level= 0; 3561 prev_run= run; 3562 run=0; 3563 }else{ 3564 run++; 3565 } 3566 } 3567#ifdef REFINE_STATS 3568STOP_TIMER("iterative step")} 3569#endif 3570 3571 if(best_change){ 3572 int j= perm_scantable[ best_coeff ]; 3573 3574 block[j] += best_change; 3575 3576 if(best_coeff > last_non_zero){ 3577 last_non_zero= best_coeff; 3578 assert(block[j]); 3579#ifdef REFINE_STATS 3580after_last++; 3581#endif 3582 }else{ 3583#ifdef REFINE_STATS 3584if(block[j]){ 3585 if(block[j] - best_change){ 3586 if(FFABS(block[j]) > FFABS(block[j] - best_change)){ 3587 raise++; 3588 }else{ 3589 lower++; 3590 } 3591 }else{ 3592 from_zero++; 3593 } 3594}else{ 3595 to_zero++; 3596} 3597#endif 3598 for(; last_non_zero>=start_i; last_non_zero--){ 3599 if(block[perm_scantable[last_non_zero]]) 3600 break; 3601 } 3602 } 3603#ifdef REFINE_STATS 3604count++; 3605if(256*256*256*64 % count == 0){ 3606 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number); 3607} 3608#endif 3609 run=0; 3610 rle_index=0; 3611 for(i=start_i; i<=last_non_zero; i++){ 3612 int j= perm_scantable[i]; 3613 const int level= block[j]; 3614 3615 if(level){ 3616 run_tab[rle_index++]=run; 3617 run=0; 3618 }else{ 3619 run++; 3620 } 3621 } 3622 3623 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change); 3624 }else{ 3625 break; 3626 } 3627 } 3628#ifdef REFINE_STATS 3629if(last_non_zero>0){ 3630STOP_TIMER("iterative search") 3631} 3632} 3633#endif 3634 3635 return last_non_zero; 3636} 3637 3638int dct_quantize_c(MpegEncContext *s, 3639 DCTELEM *block, int n, 3640 int qscale, int *overflow) 3641{ 3642 int i, j, level, last_non_zero, q, start_i; 3643 const int *qmat; 3644 const uint8_t *scantable= s->intra_scantable.scantable; 3645 int bias; 3646 int max=0; 3647 unsigned int threshold1, threshold2; 3648 3649 s->dsp.fdct (block); 3650 3651 if(s->dct_error_sum) 3652 s->denoise_dct(s, block); 3653 3654 if (s->mb_intra) { 3655 if (!s->h263_aic) { 3656 if (n < 4) 3657 q = s->y_dc_scale; 3658 else 3659 q = s->c_dc_scale; 3660 q = q << 3; 3661 } else 3662 /* For AIC we skip quant/dequant of INTRADC */ 3663 q = 1 << 3; 3664 3665 /* note: block[0] is assumed to be positive */ 3666 block[0] = (block[0] + (q >> 1)) / q; 3667 start_i = 1; 3668 last_non_zero = 0; 3669 qmat = s->q_intra_matrix[qscale]; 3670 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); 3671 } else { 3672 start_i = 0; 3673 last_non_zero = -1; 3674 qmat = s->q_inter_matrix[qscale]; 3675 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT); 3676 } 3677 threshold1= (1<<QMAT_SHIFT) - bias - 1; 3678 threshold2= (threshold1<<1); 3679 for(i=63;i>=start_i;i--) { 3680 j = scantable[i]; 3681 level = block[j] * qmat[j]; 3682 3683 if(((unsigned)(level+threshold1))>threshold2){ 3684 last_non_zero = i; 3685 break; 3686 }else{ 3687 block[j]=0; 3688 } 3689 } 3690 for(i=start_i; i<=last_non_zero; i++) { 3691 j = scantable[i]; 3692 level = block[j] * qmat[j]; 3693 3694// if( bias+level >= (1<<QMAT_SHIFT) 3695// || bias-level >= (1<<QMAT_SHIFT)){ 3696 if(((unsigned)(level+threshold1))>threshold2){ 3697 if(level>0){ 3698 level= (bias + level)>>QMAT_SHIFT; 3699 block[j]= level; 3700 }else{ 3701 level= (bias - level)>>QMAT_SHIFT; 3702 block[j]= -level; 3703 } 3704 max |=level; 3705 }else{ 3706 block[j]=0; 3707 } 3708 } 3709 *overflow= s->max_qcoeff < max; //overflow might have happened 3710 3711 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ 3712 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM) 3713 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero); 3714 3715 return last_non_zero; 3716} 3717 3718AVCodec h263_encoder = { 3719 "h263", 3720 CODEC_TYPE_VIDEO, 3721 CODEC_ID_H263, 3722 sizeof(MpegEncContext), 3723 MPV_encode_init, 3724 MPV_encode_picture, 3725 MPV_encode_end, 3726 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3727 .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"), 3728}; 3729 3730AVCodec h263p_encoder = { 3731 "h263p", 3732 CODEC_TYPE_VIDEO, 3733 CODEC_ID_H263P, 3734 sizeof(MpegEncContext), 3735 MPV_encode_init, 3736 MPV_encode_picture, 3737 MPV_encode_end, 3738 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3739 .long_name= NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"), 3740}; 3741 3742AVCodec flv_encoder = { 3743 "flv", 3744 CODEC_TYPE_VIDEO, 3745 CODEC_ID_FLV1, 3746 sizeof(MpegEncContext), 3747 MPV_encode_init, 3748 MPV_encode_picture, 3749 MPV_encode_end, 3750 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3751 .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV)"), 3752}; 3753 3754AVCodec rv10_encoder = { 3755 "rv10", 3756 CODEC_TYPE_VIDEO, 3757 CODEC_ID_RV10, 3758 sizeof(MpegEncContext), 3759 MPV_encode_init, 3760 MPV_encode_picture, 3761 MPV_encode_end, 3762 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3763 .long_name= NULL_IF_CONFIG_SMALL("RealVideo 1.0"), 3764}; 3765 3766AVCodec rv20_encoder = { 3767 "rv20", 3768 CODEC_TYPE_VIDEO, 3769 CODEC_ID_RV20, 3770 sizeof(MpegEncContext), 3771 MPV_encode_init, 3772 MPV_encode_picture, 3773 MPV_encode_end, 3774 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3775 .long_name= NULL_IF_CONFIG_SMALL("RealVideo 2.0"), 3776}; 3777 3778AVCodec mpeg4_encoder = { 3779 "mpeg4", 3780 CODEC_TYPE_VIDEO, 3781 CODEC_ID_MPEG4, 3782 sizeof(MpegEncContext), 3783 MPV_encode_init, 3784 MPV_encode_picture, 3785 MPV_encode_end, 3786 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3787 .capabilities= CODEC_CAP_DELAY, 3788 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"), 3789}; 3790 3791AVCodec msmpeg4v1_encoder = { 3792 "msmpeg4v1", 3793 CODEC_TYPE_VIDEO, 3794 CODEC_ID_MSMPEG4V1, 3795 sizeof(MpegEncContext), 3796 MPV_encode_init, 3797 MPV_encode_picture, 3798 MPV_encode_end, 3799 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3800 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), 3801}; 3802 3803AVCodec msmpeg4v2_encoder = { 3804 "msmpeg4v2", 3805 CODEC_TYPE_VIDEO, 3806 CODEC_ID_MSMPEG4V2, 3807 sizeof(MpegEncContext), 3808 MPV_encode_init, 3809 MPV_encode_picture, 3810 MPV_encode_end, 3811 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3812 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), 3813}; 3814 3815AVCodec msmpeg4v3_encoder = { 3816 "msmpeg4", 3817 CODEC_TYPE_VIDEO, 3818 CODEC_ID_MSMPEG4V3, 3819 sizeof(MpegEncContext), 3820 MPV_encode_init, 3821 MPV_encode_picture, 3822 MPV_encode_end, 3823 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3824 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), 3825}; 3826 3827AVCodec wmv1_encoder = { 3828 "wmv1", 3829 CODEC_TYPE_VIDEO, 3830 CODEC_ID_WMV1, 3831 sizeof(MpegEncContext), 3832 MPV_encode_init, 3833 MPV_encode_picture, 3834 MPV_encode_end, 3835 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, 3836 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"), 3837}; 3838