00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00030 #include "avcodec.h"
00031 #include "dsputil.h"
00032 #include "mpegvideo.h"
00033 #include "mpegvideo_common.h"
00034 #include "mjpegenc.h"
00035 #include "msmpeg4.h"
00036 #include "h263.h"
00037 #include "faandct.h"
00038 #include <limits.h>
00039
00040
00041
00042
00043 static int encode_picture(MpegEncContext *s, int picture_number);
00044 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
00045 static int sse_mb(MpegEncContext *s);
00046
00047
00048
00049
00050
00051
00052 static const uint16_t aanscales[64] = {
00053
00054 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
00055 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
00056 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
00057 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
00058 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
00059 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
00060 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
00061 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
00062 };
00063
00064 static uint8_t default_mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
00065 static uint8_t default_fcode_tab[MAX_MV*2+1];
00066
00067 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
00068 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
00069 {
00070 int qscale;
00071 int shift=0;
00072
00073 for(qscale=qmin; qscale<=qmax; qscale++){
00074 int i;
00075 if (dsp->fdct == ff_jpeg_fdct_islow
00076 #ifdef FAAN_POSTSCALE
00077 || dsp->fdct == ff_faandct
00078 #endif
00079 ) {
00080 for(i=0;i<64;i++) {
00081 const int j= dsp->idct_permutation[i];
00082
00083
00084
00085
00086
00087 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
00088 (qscale * quant_matrix[j]));
00089 }
00090 } else if (dsp->fdct == fdct_ifast
00091 #ifndef FAAN_POSTSCALE
00092 || dsp->fdct == ff_faandct
00093 #endif
00094 ) {
00095 for(i=0;i<64;i++) {
00096 const int j= dsp->idct_permutation[i];
00097
00098
00099
00100
00101
00102 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
00103 (aanscales[i] * qscale * quant_matrix[j]));
00104 }
00105 } else {
00106 for(i=0;i<64;i++) {
00107 const int j= dsp->idct_permutation[i];
00108
00109
00110
00111
00112
00113 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
00114
00115 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
00116
00117 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
00118 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
00119 }
00120 }
00121
00122 for(i=intra; i<64; i++){
00123 int64_t max= 8191;
00124 if (dsp->fdct == fdct_ifast
00125 #ifndef FAAN_POSTSCALE
00126 || dsp->fdct == ff_faandct
00127 #endif
00128 ) {
00129 max= (8191LL*aanscales[i]) >> 14;
00130 }
00131 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
00132 shift++;
00133 }
00134 }
00135 }
00136 if(shift){
00137 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
00138 }
00139 }
00140
00141 static inline void update_qscale(MpegEncContext *s){
00142 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
00143 s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
00144
00145 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
00146 }
00147
00148 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
00149 int i;
00150
00151 if(matrix){
00152 put_bits(pb, 1, 1);
00153 for(i=0;i<64;i++) {
00154 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
00155 }
00156 }else
00157 put_bits(pb, 1, 0);
00158 }
00159
00160 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
00161 int i;
00162
00163 dst->pict_type = src->pict_type;
00164 dst->quality = src->quality;
00165 dst->coded_picture_number = src->coded_picture_number;
00166 dst->display_picture_number = src->display_picture_number;
00167
00168 dst->pts = src->pts;
00169 dst->interlaced_frame = src->interlaced_frame;
00170 dst->top_field_first = src->top_field_first;
00171
00172 if(s->avctx->me_threshold){
00173 if(!src->motion_val[0])
00174 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
00175 if(!src->mb_type)
00176 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
00177 if(!src->ref_index[0])
00178 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
00179 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
00180 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
00181 src->motion_subsample_log2, dst->motion_subsample_log2);
00182
00183 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
00184
00185 for(i=0; i<2; i++){
00186 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
00187 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
00188
00189 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
00190 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
00191 }
00192 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
00193 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
00194 }
00195 }
00196 }
00197 }
00198
00199 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
00200 #define COPY(a) dst->a= src->a
00201 COPY(pict_type);
00202 COPY(current_picture);
00203 COPY(f_code);
00204 COPY(b_code);
00205 COPY(qscale);
00206 COPY(lambda);
00207 COPY(lambda2);
00208 COPY(picture_in_gop_number);
00209 COPY(gop_picture_number);
00210 COPY(frame_pred_frame_dct);
00211 COPY(progressive_frame);
00212 COPY(partitioned_frame);
00213 #undef COPY
00214 }
00215
00220 static void MPV_encode_defaults(MpegEncContext *s){
00221 int i;
00222 MPV_common_defaults(s);
00223
00224 for(i=-16; i<16; i++){
00225 default_fcode_tab[i + MAX_MV]= 1;
00226 }
00227 s->me.mv_penalty= default_mv_penalty;
00228 s->fcode_tab= default_fcode_tab;
00229 }
00230
00231
00232 int MPV_encode_init(AVCodecContext *avctx)
00233 {
00234 MpegEncContext *s = avctx->priv_data;
00235 int i;
00236 int chroma_h_shift, chroma_v_shift;
00237
00238 MPV_encode_defaults(s);
00239
00240 switch (avctx->codec_id) {
00241 case CODEC_ID_MPEG2VIDEO:
00242 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
00243 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
00244 return -1;
00245 }
00246 break;
00247 case CODEC_ID_LJPEG:
00248 case CODEC_ID_MJPEG:
00249 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
00250 ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
00251 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
00252 return -1;
00253 }
00254 break;
00255 default:
00256 if(avctx->pix_fmt != PIX_FMT_YUV420P){
00257 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
00258 return -1;
00259 }
00260 }
00261
00262 switch (avctx->pix_fmt) {
00263 case PIX_FMT_YUVJ422P:
00264 case PIX_FMT_YUV422P:
00265 s->chroma_format = CHROMA_422;
00266 break;
00267 case PIX_FMT_YUVJ420P:
00268 case PIX_FMT_YUV420P:
00269 default:
00270 s->chroma_format = CHROMA_420;
00271 break;
00272 }
00273
00274 s->bit_rate = avctx->bit_rate;
00275 s->width = avctx->width;
00276 s->height = avctx->height;
00277 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
00278 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
00279 avctx->gop_size=600;
00280 }
00281 s->gop_size = avctx->gop_size;
00282 s->avctx = avctx;
00283 s->flags= avctx->flags;
00284 s->flags2= avctx->flags2;
00285 s->max_b_frames= avctx->max_b_frames;
00286 s->codec_id= avctx->codec->id;
00287 s->luma_elim_threshold = avctx->luma_elim_threshold;
00288 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
00289 s->strict_std_compliance= avctx->strict_std_compliance;
00290 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
00291 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
00292 s->mpeg_quant= avctx->mpeg_quant;
00293 s->rtp_mode= !!avctx->rtp_payload_size;
00294 s->intra_dc_precision= avctx->intra_dc_precision;
00295 s->user_specified_pts = AV_NOPTS_VALUE;
00296
00297 if (s->gop_size <= 1) {
00298 s->intra_only = 1;
00299 s->gop_size = 12;
00300 } else {
00301 s->intra_only = 0;
00302 }
00303
00304 s->me_method = avctx->me_method;
00305
00306
00307 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
00308
00309 s->adaptive_quant= ( s->avctx->lumi_masking
00310 || s->avctx->dark_masking
00311 || s->avctx->temporal_cplx_masking
00312 || s->avctx->spatial_cplx_masking
00313 || s->avctx->p_masking
00314 || s->avctx->border_masking
00315 || (s->flags&CODEC_FLAG_QP_RD))
00316 && !s->fixed_qscale;
00317
00318 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
00319 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
00320 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
00321 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
00322 s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
00323
00324 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
00325 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
00326 return -1;
00327 }
00328
00329 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
00330 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
00331 }
00332
00333 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
00334 av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
00335 return -1;
00336 }
00337
00338 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
00339 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
00340 return -1;
00341 }
00342
00343 if(avctx->rc_max_rate && avctx->rc_max_rate == avctx->bit_rate && avctx->rc_max_rate != avctx->rc_min_rate){
00344 av_log(avctx, AV_LOG_INFO, "impossible bitrate constraints, this will fail\n");
00345 }
00346
00347 if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){
00348 av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
00349 return -1;
00350 }
00351
00352 if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){
00353 av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n");
00354 return -1;
00355 }
00356
00357 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
00358 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
00359 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
00360
00361 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");
00362 }
00363
00364 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
00365 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
00366 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
00367 return -1;
00368 }
00369
00370 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
00371 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
00372 return -1;
00373 }
00374
00375 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
00376 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
00377 return -1;
00378 }
00379
00380 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
00381 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
00382 return -1;
00383 }
00384
00385 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
00386 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
00387 return -1;
00388 }
00389
00390 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
00391 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
00392 return -1;
00393 }
00394
00395 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
00396 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
00397 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
00398 return -1;
00399 }
00400
00401 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){
00402 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
00403 return -1;
00404 }
00405
00406 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
00407 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
00408 return -1;
00409 }
00410
00411 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
00412 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
00413 return -1;
00414 }
00415
00416 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
00417 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
00418 return -1;
00419 }
00420
00421 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
00422 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
00423 return -1;
00424 }
00425
00426 if(s->flags & CODEC_FLAG_LOW_DELAY){
00427 if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
00428 av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
00429 return -1;
00430 }
00431 if (s->max_b_frames != 0){
00432 av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
00433 return -1;
00434 }
00435 }
00436
00437 if(s->q_scale_type == 1){
00438 if(s->codec_id != CODEC_ID_MPEG2VIDEO){
00439 av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
00440 return -1;
00441 }
00442 if(avctx->qmax > 12){
00443 av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
00444 return -1;
00445 }
00446 }
00447
00448 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
00449 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
00450 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
00451 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
00452 return -1;
00453 }
00454
00455 if(s->avctx->thread_count > 1)
00456 s->rtp_mode= 1;
00457
00458 if(!avctx->time_base.den || !avctx->time_base.num){
00459 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
00460 return -1;
00461 }
00462
00463 i= (INT_MAX/2+128)>>8;
00464 if(avctx->me_threshold >= i){
00465 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
00466 return -1;
00467 }
00468 if(avctx->mb_threshold >= i){
00469 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
00470 return -1;
00471 }
00472
00473 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
00474 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
00475 avctx->b_frame_strategy = 0;
00476 }
00477
00478 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
00479 if(i > 1){
00480 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
00481 avctx->time_base.den /= i;
00482 avctx->time_base.num /= i;
00483
00484 }
00485
00486 if(s->codec_id==CODEC_ID_MJPEG){
00487 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1);
00488 s->inter_quant_bias= 0;
00489 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
00490 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3);
00491 s->inter_quant_bias= 0;
00492 }else{
00493 s->intra_quant_bias=0;
00494 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2));
00495 }
00496
00497 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
00498 s->intra_quant_bias= avctx->intra_quant_bias;
00499 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
00500 s->inter_quant_bias= avctx->inter_quant_bias;
00501
00502 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
00503
00504 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
00505 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
00506 return -1;
00507 }
00508 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
00509
00510 switch(avctx->codec->id) {
00511 case CODEC_ID_MPEG1VIDEO:
00512 s->out_format = FMT_MPEG1;
00513 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
00514 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
00515 break;
00516 case CODEC_ID_MPEG2VIDEO:
00517 s->out_format = FMT_MPEG1;
00518 s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
00519 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
00520 s->rtp_mode= 1;
00521 break;
00522 case CODEC_ID_LJPEG:
00523 case CODEC_ID_MJPEG:
00524 s->out_format = FMT_MJPEG;
00525 s->intra_only = 1;
00526 s->mjpeg_vsample[0] = 2;
00527 s->mjpeg_vsample[1] = 2>>chroma_v_shift;
00528 s->mjpeg_vsample[2] = 2>>chroma_v_shift;
00529 s->mjpeg_hsample[0] = 2;
00530 s->mjpeg_hsample[1] = 2>>chroma_h_shift;
00531 s->mjpeg_hsample[2] = 2>>chroma_h_shift;
00532 if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER)
00533 || ff_mjpeg_encode_init(s) < 0)
00534 return -1;
00535 avctx->delay=0;
00536 s->low_delay=1;
00537 break;
00538 case CODEC_ID_H261:
00539 if (!ENABLE_H261_ENCODER) return -1;
00540 if (ff_h261_get_picture_format(s->width, s->height) < 0) {
00541 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);
00542 return -1;
00543 }
00544 s->out_format = FMT_H261;
00545 avctx->delay=0;
00546 s->low_delay=1;
00547 break;
00548 case CODEC_ID_H263:
00549 if (!ENABLE_H263_ENCODER) return -1;
00550 if (h263_get_picture_format(s->width, s->height) == 7) {
00551 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);
00552 return -1;
00553 }
00554 s->out_format = FMT_H263;
00555 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
00556 avctx->delay=0;
00557 s->low_delay=1;
00558 break;
00559 case CODEC_ID_H263P:
00560 s->out_format = FMT_H263;
00561 s->h263_plus = 1;
00562
00563 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
00564 s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
00565 s->modified_quant= s->h263_aic;
00566 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
00567 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
00568 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
00569 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
00570 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
00571
00572
00573
00574 avctx->delay=0;
00575 s->low_delay=1;
00576 break;
00577 case CODEC_ID_FLV1:
00578 s->out_format = FMT_H263;
00579 s->h263_flv = 2;
00580 s->unrestricted_mv = 1;
00581 s->rtp_mode=0;
00582 avctx->delay=0;
00583 s->low_delay=1;
00584 break;
00585 case CODEC_ID_RV10:
00586 s->out_format = FMT_H263;
00587 avctx->delay=0;
00588 s->low_delay=1;
00589 break;
00590 case CODEC_ID_RV20:
00591 s->out_format = FMT_H263;
00592 avctx->delay=0;
00593 s->low_delay=1;
00594 s->modified_quant=1;
00595 s->h263_aic=1;
00596 s->h263_plus=1;
00597 s->loop_filter=1;
00598 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
00599 break;
00600 case CODEC_ID_MPEG4:
00601 s->out_format = FMT_H263;
00602 s->h263_pred = 1;
00603 s->unrestricted_mv = 1;
00604 s->low_delay= s->max_b_frames ? 0 : 1;
00605 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
00606 break;
00607 case CODEC_ID_MSMPEG4V1:
00608 s->out_format = FMT_H263;
00609 s->h263_msmpeg4 = 1;
00610 s->h263_pred = 1;
00611 s->unrestricted_mv = 1;
00612 s->msmpeg4_version= 1;
00613 avctx->delay=0;
00614 s->low_delay=1;
00615 break;
00616 case CODEC_ID_MSMPEG4V2:
00617 s->out_format = FMT_H263;
00618 s->h263_msmpeg4 = 1;
00619 s->h263_pred = 1;
00620 s->unrestricted_mv = 1;
00621 s->msmpeg4_version= 2;
00622 avctx->delay=0;
00623 s->low_delay=1;
00624 break;
00625 case CODEC_ID_MSMPEG4V3:
00626 s->out_format = FMT_H263;
00627 s->h263_msmpeg4 = 1;
00628 s->h263_pred = 1;
00629 s->unrestricted_mv = 1;
00630 s->msmpeg4_version= 3;
00631 s->flipflop_rounding=1;
00632 avctx->delay=0;
00633 s->low_delay=1;
00634 break;
00635 case CODEC_ID_WMV1:
00636 s->out_format = FMT_H263;
00637 s->h263_msmpeg4 = 1;
00638 s->h263_pred = 1;
00639 s->unrestricted_mv = 1;
00640 s->msmpeg4_version= 4;
00641 s->flipflop_rounding=1;
00642 avctx->delay=0;
00643 s->low_delay=1;
00644 break;
00645 case CODEC_ID_WMV2:
00646 s->out_format = FMT_H263;
00647 s->h263_msmpeg4 = 1;
00648 s->h263_pred = 1;
00649 s->unrestricted_mv = 1;
00650 s->msmpeg4_version= 5;
00651 s->flipflop_rounding=1;
00652 avctx->delay=0;
00653 s->low_delay=1;
00654 break;
00655 default:
00656 return -1;
00657 }
00658
00659 avctx->has_b_frames= !s->low_delay;
00660
00661 s->encoding = 1;
00662
00663
00664 if (MPV_common_init(s) < 0)
00665 return -1;
00666
00667 if(!s->dct_quantize)
00668 s->dct_quantize = dct_quantize_c;
00669 if(!s->denoise_dct)
00670 s->denoise_dct = denoise_dct_c;
00671 s->fast_dct_quantize = s->dct_quantize;
00672 if(s->flags & CODEC_FLAG_TRELLIS_QUANT)
00673 s->dct_quantize = dct_quantize_trellis_c;
00674
00675 if((ENABLE_H263P_ENCODER || ENABLE_RV20_ENCODER) && s->modified_quant)
00676 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00677 s->progressive_frame=
00678 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
00679 s->quant_precision=5;
00680
00681 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
00682 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
00683
00684 if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
00685 ff_h261_encode_init(s);
00686 if (ENABLE_ANY_H263_ENCODER && s->out_format == FMT_H263)
00687 h263_encode_init(s);
00688 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
00689 ff_msmpeg4_encode_init(s);
00690 if ((ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER)
00691 && s->out_format == FMT_MPEG1)
00692 ff_mpeg1_encode_init(s);
00693
00694
00695 for(i=0;i<64;i++) {
00696 int j= s->dsp.idct_permutation[i];
00697 if(ENABLE_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
00698 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
00699 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
00700 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
00701 s->intra_matrix[j] =
00702 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
00703 }else
00704 {
00705 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
00706 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
00707 }
00708 if(s->avctx->intra_matrix)
00709 s->intra_matrix[j] = s->avctx->intra_matrix[i];
00710 if(s->avctx->inter_matrix)
00711 s->inter_matrix[j] = s->avctx->inter_matrix[i];
00712 }
00713
00714
00715
00716 if (s->out_format != FMT_MJPEG) {
00717 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
00718 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
00719 ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
00720 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
00721 }
00722
00723 if(ff_rate_control_init(s) < 0)
00724 return -1;
00725
00726 return 0;
00727 }
00728
00729 int MPV_encode_end(AVCodecContext *avctx)
00730 {
00731 MpegEncContext *s = avctx->priv_data;
00732
00733 ff_rate_control_uninit(s);
00734
00735 MPV_common_end(s);
00736 if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG)
00737 ff_mjpeg_encode_close(s);
00738
00739 av_freep(&avctx->extradata);
00740
00741 return 0;
00742 }
00743
00744 static int get_sae(uint8_t *src, int ref, int stride){
00745 int x,y;
00746 int acc=0;
00747
00748 for(y=0; y<16; y++){
00749 for(x=0; x<16; x++){
00750 acc+= FFABS(src[x+y*stride] - ref);
00751 }
00752 }
00753
00754 return acc;
00755 }
00756
00757 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
00758 int x, y, w, h;
00759 int acc=0;
00760
00761 w= s->width &~15;
00762 h= s->height&~15;
00763
00764 for(y=0; y<h; y+=16){
00765 for(x=0; x<w; x+=16){
00766 int offset= x + y*stride;
00767 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
00768 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
00769 int sae = get_sae(src + offset, mean, stride);
00770
00771 acc+= sae + 500 < sad;
00772 }
00773 }
00774 return acc;
00775 }
00776
00777
00778 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
00779 AVFrame *pic=NULL;
00780 int64_t pts;
00781 int i;
00782 const int encoding_delay= s->max_b_frames;
00783 int direct=1;
00784
00785 if(pic_arg){
00786 pts= pic_arg->pts;
00787 pic_arg->display_picture_number= s->input_picture_number++;
00788
00789 if(pts != AV_NOPTS_VALUE){
00790 if(s->user_specified_pts != AV_NOPTS_VALUE){
00791 int64_t time= pts;
00792 int64_t last= s->user_specified_pts;
00793
00794 if(time <= last){
00795 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
00796 return -1;
00797 }
00798 }
00799 s->user_specified_pts= pts;
00800 }else{
00801 if(s->user_specified_pts != AV_NOPTS_VALUE){
00802 s->user_specified_pts=
00803 pts= s->user_specified_pts + 1;
00804 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
00805 }else{
00806 pts= pic_arg->display_picture_number;
00807 }
00808 }
00809 }
00810
00811 if(pic_arg){
00812 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
00813 if(pic_arg->linesize[0] != s->linesize) direct=0;
00814 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
00815 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
00816
00817
00818
00819 if(direct){
00820 i= ff_find_unused_picture(s, 1);
00821
00822 pic= (AVFrame*)&s->picture[i];
00823 pic->reference= 3;
00824
00825 for(i=0; i<4; i++){
00826 pic->data[i]= pic_arg->data[i];
00827 pic->linesize[i]= pic_arg->linesize[i];
00828 }
00829 alloc_picture(s, (Picture*)pic, 1);
00830 }else{
00831 i= ff_find_unused_picture(s, 0);
00832
00833 pic= (AVFrame*)&s->picture[i];
00834 pic->reference= 3;
00835
00836 alloc_picture(s, (Picture*)pic, 0);
00837
00838 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
00839 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
00840 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
00841
00842 }else{
00843 int h_chroma_shift, v_chroma_shift;
00844 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
00845
00846 for(i=0; i<3; i++){
00847 int src_stride= pic_arg->linesize[i];
00848 int dst_stride= i ? s->uvlinesize : s->linesize;
00849 int h_shift= i ? h_chroma_shift : 0;
00850 int v_shift= i ? v_chroma_shift : 0;
00851 int w= s->width >>h_shift;
00852 int h= s->height>>v_shift;
00853 uint8_t *src= pic_arg->data[i];
00854 uint8_t *dst= pic->data[i];
00855
00856 if(!s->avctx->rc_buffer_size)
00857 dst +=INPLACE_OFFSET;
00858
00859 if(src_stride==dst_stride)
00860 memcpy(dst, src, src_stride*h);
00861 else{
00862 while(h--){
00863 memcpy(dst, src, w);
00864 dst += dst_stride;
00865 src += src_stride;
00866 }
00867 }
00868 }
00869 }
00870 }
00871 copy_picture_attributes(s, pic, pic_arg);
00872 pic->pts= pts;
00873 }
00874
00875
00876 for(i=1; i<MAX_PICTURE_COUNT ; i++)
00877 s->input_picture[i-1]= s->input_picture[i];
00878
00879 s->input_picture[encoding_delay]= (Picture*)pic;
00880
00881 return 0;
00882 }
00883
00884 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
00885 int x, y, plane;
00886 int score=0;
00887 int64_t score64=0;
00888
00889 for(plane=0; plane<3; plane++){
00890 const int stride= p->linesize[plane];
00891 const int bw= plane ? 1 : 2;
00892 for(y=0; y<s->mb_height*bw; y++){
00893 for(x=0; x<s->mb_width*bw; x++){
00894 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
00895 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);
00896
00897 switch(s->avctx->frame_skip_exp){
00898 case 0: score= FFMAX(score, v); break;
00899 case 1: score+= FFABS(v);break;
00900 case 2: score+= v*v;break;
00901 case 3: score64+= FFABS(v*v*(int64_t)v);break;
00902 case 4: score64+= v*v*(int64_t)(v*v);break;
00903 }
00904 }
00905 }
00906 }
00907
00908 if(score) score64= score;
00909
00910 if(score64 < s->avctx->frame_skip_threshold)
00911 return 1;
00912 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
00913 return 1;
00914 return 0;
00915 }
00916
00917 static int estimate_best_b_count(MpegEncContext *s){
00918 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
00919 AVCodecContext *c= avcodec_alloc_context();
00920 AVFrame input[FF_MAX_B_FRAMES+2];
00921 const int scale= s->avctx->brd_scale;
00922 int i, j, out_size, p_lambda, b_lambda, lambda2;
00923 int outbuf_size= s->width * s->height;
00924 uint8_t *outbuf= av_malloc(outbuf_size);
00925 int64_t best_rd= INT64_MAX;
00926 int best_b_count= -1;
00927
00928 assert(scale>=0 && scale <=3);
00929
00930
00931 p_lambda= s->last_lambda_for[P_TYPE];
00932 b_lambda= s->last_lambda_for[B_TYPE];
00933 if(!b_lambda) b_lambda= p_lambda;
00934 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
00935
00936 c->width = s->width >> scale;
00937 c->height= s->height>> scale;
00938 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED ;
00939 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
00940 c->mb_decision= s->avctx->mb_decision;
00941 c->me_cmp= s->avctx->me_cmp;
00942 c->mb_cmp= s->avctx->mb_cmp;
00943 c->me_sub_cmp= s->avctx->me_sub_cmp;
00944 c->pix_fmt = PIX_FMT_YUV420P;
00945 c->time_base= s->avctx->time_base;
00946 c->max_b_frames= s->max_b_frames;
00947
00948 if (avcodec_open(c, codec) < 0)
00949 return -1;
00950
00951 for(i=0; i<s->max_b_frames+2; i++){
00952 int ysize= c->width*c->height;
00953 int csize= (c->width/2)*(c->height/2);
00954 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
00955
00956 avcodec_get_frame_defaults(&input[i]);
00957 input[i].data[0]= av_malloc(ysize + 2*csize);
00958 input[i].data[1]= input[i].data[0] + ysize;
00959 input[i].data[2]= input[i].data[1] + csize;
00960 input[i].linesize[0]= c->width;
00961 input[i].linesize[1]=
00962 input[i].linesize[2]= c->width/2;
00963
00964 if(pre_input_ptr && (!i || s->input_picture[i-1])) {
00965 pre_input= *pre_input_ptr;
00966
00967 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
00968 pre_input.data[0]+=INPLACE_OFFSET;
00969 pre_input.data[1]+=INPLACE_OFFSET;
00970 pre_input.data[2]+=INPLACE_OFFSET;
00971 }
00972
00973 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
00974 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);
00975 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);
00976 }
00977 }
00978
00979 for(j=0; j<s->max_b_frames+1; j++){
00980 int64_t rd=0;
00981
00982 if(!s->input_picture[j])
00983 break;
00984
00985 c->error[0]= c->error[1]= c->error[2]= 0;
00986
00987 input[0].pict_type= I_TYPE;
00988 input[0].quality= 1 * FF_QP2LAMBDA;
00989 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
00990
00991
00992 for(i=0; i<s->max_b_frames+1; i++){
00993 int is_p= i % (j+1) == j || i==s->max_b_frames;
00994
00995 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
00996 input[i+1].quality= is_p ? p_lambda : b_lambda;
00997 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
00998 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
00999 }
01000
01001
01002 while(out_size){
01003 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
01004 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
01005 }
01006
01007 rd += c->error[0] + c->error[1] + c->error[2];
01008
01009 if(rd < best_rd){
01010 best_rd= rd;
01011 best_b_count= j;
01012 }
01013 }
01014
01015 av_freep(&outbuf);
01016 avcodec_close(c);
01017 av_freep(&c);
01018
01019 for(i=0; i<s->max_b_frames+2; i++){
01020 av_freep(&input[i].data[0]);
01021 }
01022
01023 return best_b_count;
01024 }
01025
01026 static void select_input_picture(MpegEncContext *s){
01027 int i;
01028
01029 for(i=1; i<MAX_PICTURE_COUNT; i++)
01030 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
01031 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
01032
01033
01034 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
01035 if( s->next_picture_ptr==NULL || s->intra_only){
01036 s->reordered_input_picture[0]= s->input_picture[0];
01037 s->reordered_input_picture[0]->pict_type= I_TYPE;
01038 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
01039 }else{
01040 int b_frames;
01041
01042 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
01043 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
01044
01045
01046
01047 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
01048 for(i=0; i<4; i++)
01049 s->input_picture[0]->data[i]= NULL;
01050 s->input_picture[0]->type= 0;
01051 }else{
01052 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
01053 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
01054
01055 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
01056 }
01057
01058 emms_c();
01059 ff_vbv_update(s, 0);
01060
01061 goto no_output_pic;
01062 }
01063 }
01064
01065 if(s->flags&CODEC_FLAG_PASS2){
01066 for(i=0; i<s->max_b_frames+1; i++){
01067 int pict_num= s->input_picture[0]->display_picture_number + i;
01068
01069 if(pict_num >= s->rc_context.num_entries)
01070 break;
01071 if(!s->input_picture[i]){
01072 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
01073 break;
01074 }
01075
01076 s->input_picture[i]->pict_type=
01077 s->rc_context.entry[pict_num].new_pict_type;
01078 }
01079 }
01080
01081 if(s->avctx->b_frame_strategy==0){
01082 b_frames= s->max_b_frames;
01083 while(b_frames && !s->input_picture[b_frames]) b_frames--;
01084 }else if(s->avctx->b_frame_strategy==1){
01085 for(i=1; i<s->max_b_frames+1; i++){
01086 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
01087 s->input_picture[i]->b_frame_score=
01088 get_intra_count(s, s->input_picture[i ]->data[0],
01089 s->input_picture[i-1]->data[0], s->linesize) + 1;
01090 }
01091 }
01092 for(i=0; i<s->max_b_frames+1; i++){
01093 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
01094 }
01095
01096 b_frames= FFMAX(0, i-1);
01097
01098
01099 for(i=0; i<b_frames+1; i++){
01100 s->input_picture[i]->b_frame_score=0;
01101 }
01102 }else if(s->avctx->b_frame_strategy==2){
01103 b_frames= estimate_best_b_count(s);
01104 }else{
01105 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
01106 b_frames=0;
01107 }
01108
01109 emms_c();
01110
01111
01112
01113
01114 for(i= b_frames - 1; i>=0; i--){
01115 int type= s->input_picture[i]->pict_type;
01116 if(type && type != B_TYPE)
01117 b_frames= i;
01118 }
01119 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
01120 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
01121 }
01122
01123 if(s->picture_in_gop_number + b_frames >= s->gop_size){
01124 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
01125 b_frames= s->gop_size - s->picture_in_gop_number - 1;
01126 }else{
01127 if(s->flags & CODEC_FLAG_CLOSED_GOP)
01128 b_frames=0;
01129 s->input_picture[b_frames]->pict_type= I_TYPE;
01130 }
01131 }
01132
01133 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
01134 && b_frames
01135 && s->input_picture[b_frames]->pict_type== I_TYPE)
01136 b_frames--;
01137
01138 s->reordered_input_picture[0]= s->input_picture[b_frames];
01139 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
01140 s->reordered_input_picture[0]->pict_type= P_TYPE;
01141 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
01142 for(i=0; i<b_frames; i++){
01143 s->reordered_input_picture[i+1]= s->input_picture[i];
01144 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
01145 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
01146 }
01147 }
01148 }
01149 no_output_pic:
01150 if(s->reordered_input_picture[0]){
01151 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
01152
01153 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
01154
01155 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
01156
01157
01158 int i= ff_find_unused_picture(s, 0);
01159 Picture *pic= &s->picture[i];
01160
01161 pic->reference = s->reordered_input_picture[0]->reference;
01162 alloc_picture(s, pic, 0);
01163
01164
01165 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
01166 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
01167 for(i=0; i<4; i++)
01168 s->reordered_input_picture[0]->data[i]= NULL;
01169 s->reordered_input_picture[0]->type= 0;
01170
01171 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
01172
01173 s->current_picture_ptr= pic;
01174 }else{
01175
01176
01177 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
01178 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
01179
01180 s->current_picture_ptr= s->reordered_input_picture[0];
01181 for(i=0; i<4; i++){
01182 s->new_picture.data[i]+= INPLACE_OFFSET;
01183 }
01184 }
01185 copy_picture(&s->current_picture, s->current_picture_ptr);
01186
01187 s->picture_number= s->new_picture.display_picture_number;
01188
01189 }else{
01190 memset(&s->new_picture, 0, sizeof(Picture));
01191 }
01192 }
01193
01194 int MPV_encode_picture(AVCodecContext *avctx,
01195 unsigned char *buf, int buf_size, void *data)
01196 {
01197 MpegEncContext *s = avctx->priv_data;
01198 AVFrame *pic_arg = data;
01199 int i, stuffing_count;
01200
01201 for(i=0; i<avctx->thread_count; i++){
01202 int start_y= s->thread_context[i]->start_mb_y;
01203 int end_y= s->thread_context[i]-> end_mb_y;
01204 int h= s->mb_height;
01205 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
01206 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
01207
01208 init_put_bits(&s->thread_context[i]->pb, start, end - start);
01209 }
01210
01211 s->picture_in_gop_number++;
01212
01213 if(load_input_picture(s, pic_arg) < 0)
01214 return -1;
01215
01216 select_input_picture(s);
01217
01218
01219 if(s->new_picture.data[0]){
01220 s->pict_type= s->new_picture.pict_type;
01221
01222
01223 MPV_frame_start(s, avctx);
01224 vbv_retry:
01225 if (encode_picture(s, s->picture_number) < 0)
01226 return -1;
01227
01228 avctx->real_pict_num = s->picture_number;
01229 avctx->header_bits = s->header_bits;
01230 avctx->mv_bits = s->mv_bits;
01231 avctx->misc_bits = s->misc_bits;
01232 avctx->i_tex_bits = s->i_tex_bits;
01233 avctx->p_tex_bits = s->p_tex_bits;
01234 avctx->i_count = s->i_count;
01235 avctx->p_count = s->mb_num - s->i_count - s->skip_count;
01236 avctx->skip_count = s->skip_count;
01237
01238 MPV_frame_end(s);
01239
01240 if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
01241 ff_mjpeg_encode_picture_trailer(s);
01242
01243 if(avctx->rc_buffer_size){
01244 RateControlContext *rcc= &s->rc_context;
01245 int max_size= rcc->buffer_index/3;
01246
01247 if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
01248 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
01249 if(s->adaptive_quant){
01250 int i;
01251 for(i=0; i<s->mb_height*s->mb_stride; i++)
01252 s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
01253 }
01254 s->mb_skipped = 0;
01255 if(s->pict_type==P_TYPE){
01256 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
01257 s->no_rounding ^= 1;
01258 }
01259 if(s->pict_type!=B_TYPE){
01260 s->time_base= s->last_time_base;
01261 s->last_non_b_time= s->time - s->pp_time;
01262 }
01263
01264 for(i=0; i<avctx->thread_count; i++){
01265 PutBitContext *pb= &s->thread_context[i]->pb;
01266 init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
01267 }
01268 goto vbv_retry;
01269 }
01270
01271 assert(s->avctx->rc_max_rate);
01272 }
01273
01274 if(s->flags&CODEC_FLAG_PASS1)
01275 ff_write_pass1_stats(s);
01276
01277 for(i=0; i<4; i++){
01278 s->current_picture_ptr->error[i]= s->current_picture.error[i];
01279 avctx->error[i] += s->current_picture_ptr->error[i];
01280 }
01281
01282 if(s->flags&CODEC_FLAG_PASS1)
01283 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
01284 flush_put_bits(&s->pb);
01285 s->frame_bits = put_bits_count(&s->pb);
01286
01287 stuffing_count= ff_vbv_update(s, s->frame_bits);
01288 if(stuffing_count){
01289 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
01290 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
01291 return -1;
01292 }
01293
01294 switch(s->codec_id){
01295 case CODEC_ID_MPEG1VIDEO:
01296 case CODEC_ID_MPEG2VIDEO:
01297 while(stuffing_count--){
01298 put_bits(&s->pb, 8, 0);
01299 }
01300 break;
01301 case CODEC_ID_MPEG4:
01302 put_bits(&s->pb, 16, 0);
01303 put_bits(&s->pb, 16, 0x1C3);
01304 stuffing_count -= 4;
01305 while(stuffing_count--){
01306 put_bits(&s->pb, 8, 0xFF);
01307 }
01308 break;
01309 default:
01310 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
01311 }
01312 flush_put_bits(&s->pb);
01313 s->frame_bits = put_bits_count(&s->pb);
01314 }
01315
01316
01317 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
01318 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
01319 int vbv_delay;
01320
01321 assert(s->repeat_first_field==0);
01322
01323 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
01324 assert(vbv_delay < 0xFFFF);
01325
01326 s->vbv_delay_ptr[0] &= 0xF8;
01327 s->vbv_delay_ptr[0] |= vbv_delay>>13;
01328 s->vbv_delay_ptr[1] = vbv_delay>>5;
01329 s->vbv_delay_ptr[2] &= 0x07;
01330 s->vbv_delay_ptr[2] |= vbv_delay<<3;
01331 }
01332 s->total_bits += s->frame_bits;
01333 avctx->frame_bits = s->frame_bits;
01334 }else{
01335 assert((pbBufPtr(&s->pb) == s->pb.buf));
01336 s->frame_bits=0;
01337 }
01338 assert((s->frame_bits&7)==0);
01339
01340 return s->frame_bits/8;
01341 }
01342
01343 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
01344 {
01345 static const char tab[64]=
01346 {3,2,2,1,1,1,1,1,
01347 1,1,1,1,1,1,1,1,
01348 1,1,1,1,1,1,1,1,
01349 0,0,0,0,0,0,0,0,
01350 0,0,0,0,0,0,0,0,
01351 0,0,0,0,0,0,0,0,
01352 0,0,0,0,0,0,0,0,
01353 0,0,0,0,0,0,0,0};
01354 int score=0;
01355 int run=0;
01356 int i;
01357 DCTELEM *block= s->block[n];
01358 const int last_index= s->block_last_index[n];
01359 int skip_dc;
01360
01361 if(threshold<0){
01362 skip_dc=0;
01363 threshold= -threshold;
01364 }else
01365 skip_dc=1;
01366
01367
01368 if(last_index<=skip_dc - 1) return;
01369
01370 for(i=0; i<=last_index; i++){
01371 const int j = s->intra_scantable.permutated[i];
01372 const int level = FFABS(block[j]);
01373 if(level==1){
01374 if(skip_dc && i==0) continue;
01375 score+= tab[run];
01376 run=0;
01377 }else if(level>1){
01378 return;
01379 }else{
01380 run++;
01381 }
01382 }
01383 if(score >= threshold) return;
01384 for(i=skip_dc; i<=last_index; i++){
01385 const int j = s->intra_scantable.permutated[i];
01386 block[j]=0;
01387 }
01388 if(block[0]) s->block_last_index[n]= 0;
01389 else s->block_last_index[n]= -1;
01390 }
01391
01392 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
01393 {
01394 int i;
01395 const int maxlevel= s->max_qcoeff;
01396 const int minlevel= s->min_qcoeff;
01397 int overflow=0;
01398
01399 if(s->mb_intra){
01400 i=1;
01401 }else
01402 i=0;
01403
01404 for(;i<=last_index; i++){
01405 const int j= s->intra_scantable.permutated[i];
01406 int level = block[j];
01407
01408 if (level>maxlevel){
01409 level=maxlevel;
01410 overflow++;
01411 }else if(level<minlevel){
01412 level=minlevel;
01413 overflow++;
01414 }
01415
01416 block[j]= level;
01417 }
01418
01419 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
01420 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
01421 }
01422
01423 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride){
01424 int x, y;
01425
01426 for(y=0; y<8; y++){
01427 for(x=0; x<8; x++){
01428 int x2, y2;
01429 int sum=0;
01430 int sqr=0;
01431 int count=0;
01432
01433 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
01434 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
01435 int v= ptr[x2 + y2*stride];
01436 sum += v;
01437 sqr += v*v;
01438 count++;
01439 }
01440 }
01441 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
01442 }
01443 }
01444 }
01445
01446 static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
01447 {
01448 int16_t weight[8][64];
01449 DCTELEM orig[8][64];
01450 const int mb_x= s->mb_x;
01451 const int mb_y= s->mb_y;
01452 int i;
01453 int skip_dct[8];
01454 int dct_offset = s->linesize*8;
01455 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
01456 int wrap_y, wrap_c;
01457
01458 for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct;
01459
01460 if(s->adaptive_quant){
01461 const int last_qp= s->qscale;
01462 const int mb_xy= mb_x + mb_y*s->mb_stride;
01463
01464 s->lambda= s->lambda_table[mb_xy];
01465 update_qscale(s);
01466
01467 if(!(s->flags&CODEC_FLAG_QP_RD)){
01468 s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
01469 s->dquant= s->qscale - last_qp;
01470
01471 if(s->out_format==FMT_H263){
01472 s->dquant= av_clip(s->dquant, -2, 2);
01473
01474 if(s->codec_id==CODEC_ID_MPEG4){
01475 if(!s->mb_intra){
01476 if(s->pict_type == B_TYPE){
01477 if(s->dquant&1 || s->mv_dir&MV_DIRECT)
01478 s->dquant= 0;
01479 }
01480 if(s->mv_type==MV_TYPE_8X8)
01481 s->dquant=0;
01482 }
01483 }
01484 }
01485 }
01486 ff_set_qscale(s, last_qp + s->dquant);
01487 }else if(s->flags&CODEC_FLAG_QP_RD)
01488 ff_set_qscale(s, s->qscale + s->dquant);
01489
01490 wrap_y = s->linesize;
01491 wrap_c = s->uvlinesize;
01492 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
01493 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
01494 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
01495
01496 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
01497 uint8_t *ebuf= s->edge_emu_buffer + 32;
01498 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
01499 ptr_y= ebuf;
01500 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);
01501 ptr_cb= ebuf+18*wrap_y;
01502 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);
01503 ptr_cr= ebuf+18*wrap_y+8;
01504 }
01505
01506 if (s->mb_intra) {
01507 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
01508 int progressive_score, interlaced_score;
01509
01510 s->interlaced_dct=0;
01511 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
01512 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
01513
01514 if(progressive_score > 0){
01515 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
01516 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
01517 if(progressive_score > interlaced_score){
01518 s->interlaced_dct=1;
01519
01520 dct_offset= wrap_y;
01521 wrap_y<<=1;
01522 if (s->chroma_format == CHROMA_422)
01523 wrap_c<<=1;
01524 }
01525 }
01526 }
01527
01528 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
01529 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
01530 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
01531 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
01532
01533 if(s->flags&CODEC_FLAG_GRAY){
01534 skip_dct[4]= 1;
01535 skip_dct[5]= 1;
01536 }else{
01537 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
01538 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
01539 if(!s->chroma_y_shift){
01540 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
01541 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
01542 }
01543 }
01544 }else{
01545 op_pixels_func (*op_pix)[4];
01546 qpel_mc_func (*op_qpix)[16];
01547 uint8_t *dest_y, *dest_cb, *dest_cr;
01548
01549 dest_y = s->dest[0];
01550 dest_cb = s->dest[1];
01551 dest_cr = s->dest[2];
01552
01553 if ((!s->no_rounding) || s->pict_type==B_TYPE){
01554 op_pix = s->dsp.put_pixels_tab;
01555 op_qpix= s->dsp.put_qpel_pixels_tab;
01556 }else{
01557 op_pix = s->dsp.put_no_rnd_pixels_tab;
01558 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
01559 }
01560
01561 if (s->mv_dir & MV_DIR_FORWARD) {
01562 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
01563 op_pix = s->dsp.avg_pixels_tab;
01564 op_qpix= s->dsp.avg_qpel_pixels_tab;
01565 }
01566 if (s->mv_dir & MV_DIR_BACKWARD) {
01567 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
01568 }
01569
01570 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
01571 int progressive_score, interlaced_score;
01572
01573 s->interlaced_dct=0;
01574 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
01575 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
01576
01577 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
01578
01579 if(progressive_score>0){
01580 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
01581 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
01582
01583 if(progressive_score > interlaced_score){
01584 s->interlaced_dct=1;
01585
01586 dct_offset= wrap_y;
01587 wrap_y<<=1;
01588 if (s->chroma_format == CHROMA_422)
01589 wrap_c<<=1;
01590 }
01591 }
01592 }
01593
01594 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
01595 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
01596 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
01597 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
01598
01599 if(s->flags&CODEC_FLAG_GRAY){
01600 skip_dct[4]= 1;
01601 skip_dct[5]= 1;
01602 }else{
01603 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
01604 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
01605 if(!s->chroma_y_shift){
01606 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
01607 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
01608 }
01609 }
01610
01611 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
01612
01613 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
01614 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
01615 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
01616 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;
01617 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
01618 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
01619 if(!s->chroma_y_shift){
01620 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;
01621 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;
01622 }
01623 }
01624 }
01625
01626 if(s->avctx->quantizer_noise_shaping){
01627 if(!skip_dct[0]) get_visual_weight(weight[0], ptr_y , wrap_y);
01628 if(!skip_dct[1]) get_visual_weight(weight[1], ptr_y + 8, wrap_y);
01629 if(!skip_dct[2]) get_visual_weight(weight[2], ptr_y + dct_offset , wrap_y);
01630 if(!skip_dct[3]) get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
01631 if(!skip_dct[4]) get_visual_weight(weight[4], ptr_cb , wrap_c);
01632 if(!skip_dct[5]) get_visual_weight(weight[5], ptr_cr , wrap_c);
01633 if(!s->chroma_y_shift){
01634 if(!skip_dct[6]) get_visual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
01635 if(!skip_dct[7]) get_visual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
01636 }
01637 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
01638 }
01639
01640
01641 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
01642 {
01643 for(i=0;i<mb_block_count;i++) {
01644 if(!skip_dct[i]){
01645 int overflow;
01646 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
01647
01648
01649
01650 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
01651 }else
01652 s->block_last_index[i]= -1;
01653 }
01654 if(s->avctx->quantizer_noise_shaping){
01655 for(i=0;i<mb_block_count;i++) {
01656 if(!skip_dct[i]){
01657 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
01658 }
01659 }
01660 }
01661
01662 if(s->luma_elim_threshold && !s->mb_intra)
01663 for(i=0; i<4; i++)
01664 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
01665 if(s->chroma_elim_threshold && !s->mb_intra)
01666 for(i=4; i<mb_block_count; i++)
01667 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
01668
01669 if(s->flags & CODEC_FLAG_CBP_RD){
01670 for(i=0;i<mb_block_count;i++) {
01671 if(s->block_last_index[i] == -1)
01672 s->coded_score[i]= INT_MAX/256;
01673 }
01674 }
01675 }
01676
01677 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
01678 s->block_last_index[4]=
01679 s->block_last_index[5]= 0;
01680 s->block[4][0]=
01681 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
01682 }
01683
01684
01685 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
01686 for(i=0; i<mb_block_count; i++){
01687 int j;
01688 if(s->block_last_index[i]>0){
01689 for(j=63; j>0; j--){
01690 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
01691 }
01692 s->block_last_index[i]= j;
01693 }
01694 }
01695 }
01696
01697
01698 switch(s->codec_id){
01699 case CODEC_ID_MPEG1VIDEO:
01700 case CODEC_ID_MPEG2VIDEO:
01701 if (ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER)
01702 mpeg1_encode_mb(s, s->block, motion_x, motion_y);
01703 break;
01704 case CODEC_ID_MPEG4:
01705 if (ENABLE_MPEG4_ENCODER)
01706 mpeg4_encode_mb(s, s->block, motion_x, motion_y);
01707 break;
01708 case CODEC_ID_MSMPEG4V2:
01709 case CODEC_ID_MSMPEG4V3:
01710 case CODEC_ID_WMV1:
01711 if (ENABLE_MSMPEG4_ENCODER)
01712 msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
01713 break;
01714 case CODEC_ID_WMV2:
01715 if (ENABLE_WMV2_ENCODER)
01716 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
01717 break;
01718 case CODEC_ID_H261:
01719 if (ENABLE_H261_ENCODER)
01720 ff_h261_encode_mb(s, s->block, motion_x, motion_y);
01721 break;
01722 case CODEC_ID_H263:
01723 case CODEC_ID_H263P:
01724 case CODEC_ID_FLV1:
01725 case CODEC_ID_RV10:
01726 case CODEC_ID_RV20:
01727 if (ENABLE_H263_ENCODER || ENABLE_H263P_ENCODER ||
01728 ENABLE_FLV_ENCODER || ENABLE_RV10_ENCODER || ENABLE_RV20_ENCODER)
01729 h263_encode_mb(s, s->block, motion_x, motion_y);
01730 break;
01731 case CODEC_ID_MJPEG:
01732 if (ENABLE_MJPEG_ENCODER)
01733 ff_mjpeg_encode_mb(s, s->block);
01734 break;
01735 default:
01736 assert(0);
01737 }
01738 }
01739
01740 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
01741 {
01742 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
01743 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
01744 }
01745
01746 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
01747 int i;
01748
01749 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int));
01750
01751
01752 d->mb_skip_run= s->mb_skip_run;
01753 for(i=0; i<3; i++)
01754 d->last_dc[i]= s->last_dc[i];
01755
01756
01757 d->mv_bits= s->mv_bits;
01758 d->i_tex_bits= s->i_tex_bits;
01759 d->p_tex_bits= s->p_tex_bits;
01760 d->i_count= s->i_count;
01761 d->f_count= s->f_count;
01762 d->b_count= s->b_count;
01763 d->skip_count= s->skip_count;
01764 d->misc_bits= s->misc_bits;
01765 d->last_bits= 0;
01766
01767 d->mb_skipped= 0;
01768 d->qscale= s->qscale;
01769 d->dquant= s->dquant;
01770
01771 d->esc3_level_length= s->esc3_level_length;
01772 }
01773
01774 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
01775 int i;
01776
01777 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
01778 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int));
01779
01780
01781 d->mb_skip_run= s->mb_skip_run;
01782 for(i=0; i<3; i++)
01783 d->last_dc[i]= s->last_dc[i];
01784
01785
01786 d->mv_bits= s->mv_bits;
01787 d->i_tex_bits= s->i_tex_bits;
01788 d->p_tex_bits= s->p_tex_bits;
01789 d->i_count= s->i_count;
01790 d->f_count= s->f_count;
01791 d->b_count= s->b_count;
01792 d->skip_count= s->skip_count;
01793 d->misc_bits= s->misc_bits;
01794
01795 d->mb_intra= s->mb_intra;
01796 d->mb_skipped= s->mb_skipped;
01797 d->mv_type= s->mv_type;
01798 d->mv_dir= s->mv_dir;
01799 d->pb= s->pb;
01800 if(s->data_partitioning){
01801 d->pb2= s->pb2;
01802 d->tex_pb= s->tex_pb;
01803 }
01804 d->block= s->block;
01805 for(i=0; i<8; i++)
01806 d->block_last_index[i]= s->block_last_index[i];
01807 d->interlaced_dct= s->interlaced_dct;
01808 d->qscale= s->qscale;
01809
01810 d->esc3_level_length= s->esc3_level_length;
01811 }
01812
01813 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
01814 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
01815 int *dmin, int *next_block, int motion_x, int motion_y)
01816 {
01817 int score;
01818 uint8_t *dest_backup[3];
01819
01820 copy_context_before_encode(s, backup, type);
01821
01822 s->block= s->blocks[*next_block];
01823 s->pb= pb[*next_block];
01824 if(s->data_partitioning){
01825 s->pb2 = pb2 [*next_block];
01826 s->tex_pb= tex_pb[*next_block];
01827 }
01828
01829 if(*next_block){
01830 memcpy(dest_backup, s->dest, sizeof(s->dest));
01831 s->dest[0] = s->rd_scratchpad;
01832 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
01833 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
01834 assert(s->linesize >= 32);
01835 }
01836
01837 encode_mb(s, motion_x, motion_y);
01838
01839 score= put_bits_count(&s->pb);
01840 if(s->data_partitioning){
01841 score+= put_bits_count(&s->pb2);
01842 score+= put_bits_count(&s->tex_pb);
01843 }
01844
01845 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
01846 MPV_decode_mb(s, s->block);
01847
01848 score *= s->lambda2;
01849 score += sse_mb(s) << FF_LAMBDA_SHIFT;
01850 }
01851
01852 if(*next_block){
01853 memcpy(s->dest, dest_backup, sizeof(s->dest));
01854 }
01855
01856 if(score<*dmin){
01857 *dmin= score;
01858 *next_block^=1;
01859
01860 copy_context_after_encode(best, s, type);
01861 }
01862 }
01863
01864 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
01865 uint32_t *sq = ff_squareTbl + 256;
01866 int acc=0;
01867 int x,y;
01868
01869 if(w==16 && h==16)
01870 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
01871 else if(w==8 && h==8)
01872 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
01873
01874 for(y=0; y<h; y++){
01875 for(x=0; x<w; x++){
01876 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
01877 }
01878 }
01879
01880 assert(acc>=0);
01881
01882 return acc;
01883 }
01884
01885 static int sse_mb(MpegEncContext *s){
01886 int w= 16;
01887 int h= 16;
01888
01889 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
01890 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
01891
01892 if(w==16 && h==16)
01893 if(s->avctx->mb_cmp == FF_CMP_NSSE){
01894 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)
01895 +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)
01896 +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);
01897 }else{
01898 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)
01899 +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)
01900 +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);
01901 }
01902 else
01903 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)
01904 +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)
01905 +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);
01906 }
01907
01908 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
01909 MpegEncContext *s= arg;
01910
01911
01912 s->me.pre_pass=1;
01913 s->me.dia_size= s->avctx->pre_dia_size;
01914 s->first_slice_line=1;
01915 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
01916 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
01917 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
01918 }
01919 s->first_slice_line=0;
01920 }
01921
01922 s->me.pre_pass=0;
01923
01924 return 0;
01925 }
01926
01927 static int estimate_motion_thread(AVCodecContext *c, void *arg){
01928 MpegEncContext *s= arg;
01929
01930 ff_check_alignment();
01931
01932 s->me.dia_size= s->avctx->dia_size;
01933 s->first_slice_line=1;
01934 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
01935 s->mb_x=0;
01936 ff_init_block_index(s);
01937 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
01938 s->block_index[0]+=2;
01939 s->block_index[1]+=2;
01940 s->block_index[2]+=2;
01941 s->block_index[3]+=2;
01942
01943
01944 if(s->pict_type==B_TYPE)
01945 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
01946 else
01947 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
01948 }
01949 s->first_slice_line=0;
01950 }
01951 return 0;
01952 }
01953
01954 static int mb_var_thread(AVCodecContext *c, void *arg){
01955 MpegEncContext *s= arg;
01956 int mb_x, mb_y;
01957
01958 ff_check_alignment();
01959
01960 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
01961 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
01962 int xx = mb_x * 16;
01963 int yy = mb_y * 16;
01964 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
01965 int varc;
01966 int sum = s->dsp.pix_sum(pix, s->linesize);
01967
01968 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
01969
01970 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
01971 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
01972 s->me.mb_var_sum_temp += varc;
01973 }
01974 }
01975 return 0;
01976 }
01977
01978 static void write_slice_end(MpegEncContext *s){
01979 if(ENABLE_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
01980 if(s->partitioned_frame){
01981 ff_mpeg4_merge_partitions(s);
01982 }
01983
01984 ff_mpeg4_stuffing(&s->pb);
01985 }else if(ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
01986 ff_mjpeg_encode_stuffing(&s->pb);
01987 }
01988
01989 align_put_bits(&s->pb);
01990 flush_put_bits(&s->pb);
01991
01992 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
01993 s->misc_bits+= get_bits_diff(s);
01994 }
01995
01996 static int encode_thread(AVCodecContext *c, void *arg){
01997 MpegEncContext *s= arg;
01998 int mb_x, mb_y, pdif = 0;
01999 int i, j;
02000 MpegEncContext best_s, backup_s;
02001 uint8_t bit_buf[2][MAX_MB_BYTES];
02002 uint8_t bit_buf2[2][MAX_MB_BYTES];
02003 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
02004 PutBitContext pb[2], pb2[2], tex_pb[2];
02005
02006
02007 ff_check_alignment();
02008
02009 for(i=0; i<2; i++){
02010 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
02011 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
02012 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
02013 }
02014
02015 s->last_bits= put_bits_count(&s->pb);
02016 s->mv_bits=0;
02017 s->misc_bits=0;
02018 s->i_tex_bits=0;
02019 s->p_tex_bits=0;
02020 s->i_count=0;
02021 s->f_count=0;
02022 s->b_count=0;
02023 s->skip_count=0;
02024
02025 for(i=0; i<3; i++){
02026
02027
02028 s->last_dc[i] = 128 << s->intra_dc_precision;
02029
02030 s->current_picture.error[i] = 0;
02031 }
02032 s->mb_skip_run = 0;
02033 memset(s->last_mv, 0, sizeof(s->last_mv));
02034
02035 s->last_mv_dir = 0;
02036
02037 switch(s->codec_id){
02038 case CODEC_ID_H263:
02039 case CODEC_ID_H263P:
02040 case CODEC_ID_FLV1:
02041 if (ENABLE_H263_ENCODER || ENABLE_H263P_ENCODER || ENABLE_FLV_ENCODER)
02042 s->gob_index = ff_h263_get_gob_height(s);
02043 break;
02044 case CODEC_ID_MPEG4:
02045 if(ENABLE_MPEG4_ENCODER && s->partitioned_frame)
02046 ff_mpeg4_init_partitions(s);
02047 break;
02048 }
02049
02050 s->resync_mb_x=0;
02051 s->resync_mb_y=0;
02052 s->first_slice_line = 1;
02053 s->ptr_lastgob = s->pb.buf;
02054 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
02055
02056 s->mb_x=0;
02057 s->mb_y= mb_y;
02058
02059 ff_set_qscale(s, s->qscale);
02060 ff_init_block_index(s);
02061
02062 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
02063 int xy= mb_y*s->mb_stride + mb_x;
02064 int mb_type= s->mb_type[xy];
02065
02066 int dmin= INT_MAX;
02067 int dir;
02068
02069 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
02070 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
02071 return -1;
02072 }
02073 if(s->data_partitioning){
02074 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
02075 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
02076 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
02077 return -1;
02078 }
02079 }
02080
02081 s->mb_x = mb_x;
02082 s->mb_y = mb_y;
02083 ff_update_block_index(s);
02084
02085 if(ENABLE_H261_ENCODER && s->codec_id == CODEC_ID_H261){
02086 ff_h261_reorder_mb_index(s);
02087 xy= s->mb_y*s->mb_stride + s->mb_x;
02088 mb_type= s->mb_type[xy];
02089 }
02090
02091
02092 if(s->rtp_mode){
02093 int current_packet_size, is_gob_start;
02094
02095 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
02096
02097 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
02098
02099 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
02100
02101 switch(s->codec_id){
02102 case CODEC_ID_H263:
02103 case CODEC_ID_H263P:
02104 if(!s->h263_slice_structured)
02105 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
02106 break;
02107 case CODEC_ID_MPEG2VIDEO:
02108 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
02109 case CODEC_ID_MPEG1VIDEO:
02110 if(s->mb_skip_run) is_gob_start=0;
02111 break;
02112 }
02113
02114 if(is_gob_start){
02115 if(s->start_mb_y != mb_y || mb_x!=0){
02116 write_slice_end(s);
02117
02118 if(ENABLE_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
02119 ff_mpeg4_init_partitions(s);
02120 }
02121 }
02122
02123 assert((put_bits_count(&s->pb)&7) == 0);
02124 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
02125
02126 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
02127 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
02128 int d= 100 / s->avctx->error_rate;
02129 if(r % d == 0){
02130 current_packet_size=0;
02131 #ifndef ALT_BITSTREAM_WRITER
02132 s->pb.buf_ptr= s->ptr_lastgob;
02133 #endif
02134 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
02135 }
02136 }
02137
02138 if (s->avctx->rtp_callback){
02139 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
02140 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
02141 }
02142
02143 switch(s->codec_id){
02144 case CODEC_ID_MPEG4:
02145 if (ENABLE_MPEG4_ENCODER) {
02146 ff_mpeg4_encode_video_packet_header(s);
02147 ff_mpeg4_clean_buffers(s);
02148 }
02149 break;
02150 case CODEC_ID_MPEG1VIDEO:
02151 case CODEC_ID_MPEG2VIDEO:
02152 if (ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER) {
02153 ff_mpeg1_encode_slice_header(s);
02154 ff_mpeg1_clean_buffers(s);
02155 }
02156 break;
02157 case CODEC_ID_H263:
02158 case CODEC_ID_H263P:
02159 if (ENABLE_H263_ENCODER || ENABLE_H263P_ENCODER)
02160 h263_encode_gob_header(s, mb_y);
02161 break;
02162 }
02163
02164 if(s->flags&CODEC_FLAG_PASS1){
02165 int bits= put_bits_count(&s->pb);
02166 s->misc_bits+= bits - s->last_bits;
02167 s->last_bits= bits;
02168 }
02169
02170 s->ptr_lastgob += current_packet_size;
02171 s->first_slice_line=1;
02172 s->resync_mb_x=mb_x;
02173 s->resync_mb_y=mb_y;
02174 }
02175 }
02176
02177 if( (s->resync_mb_x == s->mb_x)
02178 && s->resync_mb_y+1 == s->mb_y){
02179 s->first_slice_line=0;
02180 }
02181
02182 s->mb_skipped=0;
02183 s->dquant=0;
02184
02185 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){
02186 int next_block=0;
02187 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
02188
02189 copy_context_before_encode(&backup_s, s, -1);
02190 backup_s.pb= s->pb;
02191 best_s.data_partitioning= s->data_partitioning;
02192 best_s.partitioned_frame= s->partitioned_frame;
02193 if(s->data_partitioning){
02194 backup_s.pb2= s->pb2;
02195 backup_s.tex_pb= s->tex_pb;
02196 }
02197
02198 if(mb_type&CANDIDATE_MB_TYPE_INTER){
02199 s->mv_dir = MV_DIR_FORWARD;
02200 s->mv_type = MV_TYPE_16X16;
02201 s->mb_intra= 0;
02202 s->mv[0][0][0] = s->p_mv_table[xy][0];
02203 s->mv[0][0][1] = s->p_mv_table[xy][1];
02204 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
02205 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
02206 }
02207 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
02208 s->mv_dir = MV_DIR_FORWARD;
02209 s->mv_type = MV_TYPE_FIELD;
02210 s->mb_intra= 0;
02211 for(i=0; i<2; i++){
02212 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
02213 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
02214 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
02215 }
02216 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
02217 &dmin, &next_block, 0, 0);
02218 }
02219 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
02220 s->mv_dir = MV_DIR_FORWARD;
02221 s->mv_type = MV_TYPE_16X16;
02222 s->mb_intra= 0;
02223 s->mv[0][0][0] = 0;
02224 s->mv[0][0][1] = 0;
02225 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
02226 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
02227 }
02228 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
02229 s->mv_dir = MV_DIR_FORWARD;
02230 s->mv_type = MV_TYPE_8X8;
02231 s->mb_intra= 0;
02232 for(i=0; i<4; i++){
02233 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
02234 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
02235 }
02236 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
02237 &dmin, &next_block, 0, 0);
02238 }
02239 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
02240 s->mv_dir = MV_DIR_FORWARD;
02241 s->mv_type = MV_TYPE_16X16;
02242 s->mb_intra= 0;
02243 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
02244 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
02245 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
02246 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
02247 }
02248 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
02249 s->mv_dir = MV_DIR_BACKWARD;
02250 s->mv_type = MV_TYPE_16X16;
02251 s->mb_intra= 0;
02252 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
02253 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
02254 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
02255 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
02256 }
02257 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
02258 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02259 s->mv_type = MV_TYPE_16X16;
02260 s->mb_intra= 0;
02261 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
02262 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
02263 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
02264 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
02265 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
02266 &dmin, &next_block, 0, 0);
02267 }
02268 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
02269 s->mv_dir = MV_DIR_FORWARD;
02270 s->mv_type = MV_TYPE_FIELD;
02271 s->mb_intra= 0;
02272 for(i=0; i<2; i++){
02273 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
02274 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
02275 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
02276 }
02277 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
02278 &dmin, &next_block, 0, 0);
02279 }
02280 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
02281 s->mv_dir = MV_DIR_BACKWARD;
02282 s->mv_type = MV_TYPE_FIELD;
02283 s->mb_intra= 0;
02284 for(i=0; i<2; i++){
02285 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
02286 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
02287 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
02288 }
02289 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
02290 &dmin, &next_block, 0, 0);
02291 }
02292 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
02293 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02294 s->mv_type = MV_TYPE_FIELD;
02295 s->mb_intra= 0;
02296 for(dir=0; dir<2; dir++){
02297 for(i=0; i<2; i++){
02298 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
02299 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
02300 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
02301 }
02302 }
02303 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
02304 &dmin, &next_block, 0, 0);
02305 }
02306 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
02307 s->mv_dir = 0;
02308 s->mv_type = MV_TYPE_16X16;
02309 s->mb_intra= 1;
02310 s->mv[0][0][0] = 0;
02311 s->mv[0][0][1] = 0;
02312 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
02313 &dmin, &next_block, 0, 0);
02314 if(s->h263_pred || s->h263_aic){
02315 if(best_s.mb_intra)
02316 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
02317 else
02318 ff_clean_intra_table_entries(s);
02319 }
02320 }
02321
02322 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
02323 if(best_s.mv_type==MV_TYPE_16X16){
02324 const int last_qp= backup_s.qscale;
02325 int qpi, qp, dc[6];
02326 DCTELEM ac[6][16];
02327 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
02328 static const int dquant_tab[4]={-1,1,-2,2};
02329
02330 assert(backup_s.dquant == 0);
02331
02332
02333 s->mv_dir= best_s.mv_dir;
02334 s->mv_type = MV_TYPE_16X16;
02335 s->mb_intra= best_s.mb_intra;
02336 s->mv[0][0][0] = best_s.mv[0][0][0];
02337 s->mv[0][0][1] = best_s.mv[0][0][1];
02338 s->mv[1][0][0] = best_s.mv[1][0][0];
02339 s->mv[1][0][1] = best_s.mv[1][0][1];
02340
02341 qpi = s->pict_type == B_TYPE ? 2 : 0;
02342 for(; qpi<4; qpi++){
02343 int dquant= dquant_tab[qpi];
02344 qp= last_qp + dquant;
02345 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
02346 continue;
02347 backup_s.dquant= dquant;
02348 if(s->mb_intra && s->dc_val[0]){
02349 for(i=0; i<6; i++){
02350 dc[i]= s->dc_val[0][ s->block_index[i] ];
02351 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
02352 }
02353 }
02354
02355 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
02356 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
02357 if(best_s.qscale != qp){
02358 if(s->mb_intra && s->dc_val[0]){
02359 for(i=0; i<6; i++){
02360 s->dc_val[0][ s->block_index[i] ]= dc[i];
02361 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
02362 }
02363 }
02364 }
02365 }
02366 }
02367 }
02368 if(ENABLE_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
02369 int mx= s->b_direct_mv_table[xy][0];
02370 int my= s->b_direct_mv_table[xy][1];
02371
02372 backup_s.dquant = 0;
02373 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
02374 s->mb_intra= 0;
02375 ff_mpeg4_set_direct_mv(s, mx, my);
02376 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
02377 &dmin, &next_block, mx, my);
02378 }
02379 if(ENABLE_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
02380 backup_s.dquant = 0;
02381 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
02382 s->mb_intra= 0;
02383 ff_mpeg4_set_direct_mv(s, 0, 0);
02384 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
02385 &dmin, &next_block, 0, 0);
02386 }
02387 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
02388 int coded=0;
02389 for(i=0; i<6; i++)
02390 coded |= s->block_last_index[i];
02391 if(coded){
02392 int mx,my;
02393 memcpy(s->mv, best_s.mv, sizeof(s->mv));
02394 if(ENABLE_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
02395 mx=my=0;
02396 ff_mpeg4_set_direct_mv(s, mx, my);
02397 }else if(best_s.mv_dir&MV_DIR_BACKWARD){
02398 mx= s->mv[1][0][0];
02399 my= s->mv[1][0][1];
02400 }else{
02401 mx= s->mv[0][0][0];
02402 my= s->mv[0][0][1];
02403 }
02404
02405 s->mv_dir= best_s.mv_dir;
02406 s->mv_type = best_s.mv_type;
02407 s->mb_intra= 0;
02408
02409
02410
02411
02412 backup_s.dquant= 0;
02413 s->skipdct=1;
02414 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER , pb, pb2, tex_pb,
02415 &dmin, &next_block, mx, my);
02416 s->skipdct=0;
02417 }
02418 }
02419
02420 s->current_picture.qscale_table[xy]= best_s.qscale;
02421
02422 copy_context_after_encode(s, &best_s, -1);
02423
02424 pb_bits_count= put_bits_count(&s->pb);
02425 flush_put_bits(&s->pb);
02426 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
02427 s->pb= backup_s.pb;
02428
02429 if(s->data_partitioning){
02430 pb2_bits_count= put_bits_count(&s->pb2);
02431 flush_put_bits(&s->pb2);
02432 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
02433 s->pb2= backup_s.pb2;
02434
02435 tex_pb_bits_count= put_bits_count(&s->tex_pb);
02436 flush_put_bits(&s->tex_pb);
02437 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
02438 s->tex_pb= backup_s.tex_pb;
02439 }
02440 s->last_bits= put_bits_count(&s->pb);
02441
02442 if (ENABLE_ANY_H263_ENCODER &&
02443 s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
02444 ff_h263_update_motion_val(s);
02445
02446 if(next_block==0){
02447 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
02448 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
02449 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
02450 }
02451
02452 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
02453 MPV_decode_mb(s, s->block);
02454 } else {
02455 int motion_x = 0, motion_y = 0;
02456 s->mv_type=MV_TYPE_16X16;
02457
02458
02459 switch(mb_type){
02460 case CANDIDATE_MB_TYPE_INTRA:
02461 s->mv_dir = 0;
02462 s->mb_intra= 1;
02463 motion_x= s->mv[0][0][0] = 0;
02464 motion_y= s->mv[0][0][1] = 0;
02465 break;
02466 case CANDIDATE_MB_TYPE_INTER:
02467 s->mv_dir = MV_DIR_FORWARD;
02468 s->mb_intra= 0;
02469 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
02470 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
02471 break;
02472 case CANDIDATE_MB_TYPE_INTER_I:
02473 s->mv_dir = MV_DIR_FORWARD;
02474 s->mv_type = MV_TYPE_FIELD;
02475 s->mb_intra= 0;
02476 for(i=0; i<2; i++){
02477 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
02478 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
02479 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
02480 }
02481 break;
02482 case CANDIDATE_MB_TYPE_INTER4V:
02483 s->mv_dir = MV_DIR_FORWARD;
02484 s->mv_type = MV_TYPE_8X8;
02485 s->mb_intra= 0;
02486 for(i=0; i<4; i++){
02487 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
02488 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
02489 }
02490 break;
02491 case CANDIDATE_MB_TYPE_DIRECT:
02492 if (ENABLE_MPEG4_ENCODER) {
02493 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
02494 s->mb_intra= 0;
02495 motion_x=s->b_direct_mv_table[xy][0];
02496 motion_y=s->b_direct_mv_table[xy][1];
02497 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
02498 }
02499 break;
02500 case CANDIDATE_MB_TYPE_DIRECT0:
02501 if (ENABLE_MPEG4_ENCODER) {
02502 s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
02503 s->mb_intra= 0;
02504 ff_mpeg4_set_direct_mv(s, 0, 0);
02505 }
02506 break;
02507 case CANDIDATE_MB_TYPE_BIDIR:
02508 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02509 s->mb_intra= 0;
02510 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
02511 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
02512 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
02513 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
02514 break;
02515 case CANDIDATE_MB_TYPE_BACKWARD:
02516 s->mv_dir = MV_DIR_BACKWARD;
02517 s->mb_intra= 0;
02518 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
02519 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
02520 break;
02521 case CANDIDATE_MB_TYPE_FORWARD:
02522 s->mv_dir = MV_DIR_FORWARD;
02523 s->mb_intra= 0;
02524 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
02525 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
02526
02527 break;
02528 case CANDIDATE_MB_TYPE_FORWARD_I:
02529 s->mv_dir = MV_DIR_FORWARD;
02530 s->mv_type = MV_TYPE_FIELD;
02531 s->mb_intra= 0;
02532 for(i=0; i<2; i++){
02533 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
02534 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
02535 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
02536 }
02537 break;
02538 case CANDIDATE_MB_TYPE_BACKWARD_I:
02539 s->mv_dir = MV_DIR_BACKWARD;
02540 s->mv_type = MV_TYPE_FIELD;
02541 s->mb_intra= 0;
02542 for(i=0; i<2; i++){
02543 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
02544 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
02545 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
02546 }
02547 break;
02548 case CANDIDATE_MB_TYPE_BIDIR_I:
02549 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02550 s->mv_type = MV_TYPE_FIELD;
02551 s->mb_intra= 0;
02552 for(dir=0; dir<2; dir++){
02553 for(i=0; i<2; i++){
02554 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
02555 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
02556 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
02557 }
02558 }
02559 break;
02560 default:
02561 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
02562 }
02563
02564 encode_mb(s, motion_x, motion_y);
02565
02566
02567 s->last_mv_dir = s->mv_dir;
02568
02569 if (ENABLE_ANY_H263_ENCODER &&
02570 s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
02571 ff_h263_update_motion_val(s);
02572
02573 MPV_decode_mb(s, s->block);
02574 }
02575
02576
02577 if(s->mb_intra ){
02578 s->p_mv_table[xy][0]=0;
02579 s->p_mv_table[xy][1]=0;
02580 }
02581
02582 if(s->flags&CODEC_FLAG_PSNR){
02583 int w= 16;
02584 int h= 16;
02585
02586 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
02587 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
02588
02589 s->current_picture.error[0] += sse(
02590 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
02591 s->dest[0], w, h, s->linesize);
02592 s->current_picture.error[1] += sse(
02593 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
02594 s->dest[1], w>>1, h>>1, s->uvlinesize);
02595 s->current_picture.error[2] += sse(
02596 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
02597 s->dest[2], w>>1, h>>1, s->uvlinesize);
02598 }
02599 if(s->loop_filter){
02600 if(ENABLE_ANY_H263_ENCODER && s->out_format == FMT_H263)
02601 ff_h263_loop_filter(s);
02602 }
02603
02604 }
02605 }
02606
02607
02608 if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
02609 msmpeg4_encode_ext_header(s);
02610
02611 write_slice_end(s);
02612
02613
02614 if (s->avctx->rtp_callback) {
02615 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
02616 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
02617
02618 emms_c();
02619 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
02620 }
02621
02622 return 0;
02623 }
02624
02625 #define MERGE(field) dst->field += src->field; src->field=0
02626 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
02627 MERGE(me.scene_change_score);
02628 MERGE(me.mc_mb_var_sum_temp);
02629 MERGE(me.mb_var_sum_temp);
02630 }
02631
02632 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
02633 int i;
02634
02635 MERGE(dct_count[0]);
02636 MERGE(dct_count[1]);
02637 MERGE(mv_bits);
02638 MERGE(i_tex_bits);
02639 MERGE(p_tex_bits);
02640 MERGE(i_count);
02641 MERGE(f_count);
02642 MERGE(b_count);
02643 MERGE(skip_count);
02644 MERGE(misc_bits);
02645 MERGE(error_count);
02646 MERGE(padding_bug_score);
02647 MERGE(current_picture.error[0]);
02648 MERGE(current_picture.error[1]);
02649 MERGE(current_picture.error[2]);
02650
02651 if(dst->avctx->noise_reduction){
02652 for(i=0; i<64; i++){
02653 MERGE(dct_error_sum[0][i]);
02654 MERGE(dct_error_sum[1][i]);
02655 }
02656 }
02657
02658 assert(put_bits_count(&src->pb) % 8 ==0);
02659 assert(put_bits_count(&dst->pb) % 8 ==0);
02660 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
02661 flush_put_bits(&dst->pb);
02662 }
02663
02664 static int estimate_qp(MpegEncContext *s, int dry_run){
02665 if (s->next_lambda){
02666 s->current_picture_ptr->quality=
02667 s->current_picture.quality = s->next_lambda;
02668 if(!dry_run) s->next_lambda= 0;
02669 } else if (!s->fixed_qscale) {
02670 s->current_picture_ptr->quality=
02671 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
02672 if (s->current_picture.quality < 0)
02673 return -1;
02674 }
02675
02676 if(s->adaptive_quant){
02677 switch(s->codec_id){
02678 case CODEC_ID_MPEG4:
02679 if (ENABLE_MPEG4_ENCODER)
02680 ff_clean_mpeg4_qscales(s);
02681 break;
02682 case CODEC_ID_H263:
02683 case CODEC_ID_H263P:
02684 case CODEC_ID_FLV1:
02685 if (ENABLE_H263_ENCODER||ENABLE_H263P_ENCODER||ENABLE_FLV_ENCODER)
02686 ff_clean_h263_qscales(s);
02687 break;
02688 }
02689
02690 s->lambda= s->lambda_table[0];
02691
02692 }else
02693 s->lambda= s->current_picture.quality;
02694
02695 update_qscale(s);
02696 return 0;
02697 }
02698
02699
02700 static void set_frame_distances(MpegEncContext * s){
02701 assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
02702 s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
02703
02704 if(s->pict_type==B_TYPE){
02705 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
02706 assert(s->pb_time > 0 && s->pb_time < s->pp_time);
02707 }else{
02708 s->pp_time= s->time - s->last_non_b_time;
02709 s->last_non_b_time= s->time;
02710 assert(s->picture_number==0 || s->pp_time > 0);
02711 }
02712 }
02713
02714 static int encode_picture(MpegEncContext *s, int picture_number)
02715 {
02716 int i;
02717 int bits;
02718
02719 s->picture_number = picture_number;
02720
02721
02722 s->me.mb_var_sum_temp =
02723 s->me.mc_mb_var_sum_temp = 0;
02724
02725
02726
02727 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
02728 set_frame_distances(s);
02729 if(ENABLE_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
02730 ff_set_mpeg4_time(s);
02731
02732 s->me.scene_change_score=0;
02733
02734
02735
02736 if(s->pict_type==I_TYPE){
02737 if(s->msmpeg4_version >= 3) s->no_rounding=1;
02738 else s->no_rounding=0;
02739 }else if(s->pict_type!=B_TYPE){
02740 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
02741 s->no_rounding ^= 1;
02742 }
02743
02744 if(s->flags & CODEC_FLAG_PASS2){
02745 if (estimate_qp(s,1) < 0)
02746 return -1;
02747 ff_get_2pass_fcode(s);
02748 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
02749 if(s->pict_type==B_TYPE)
02750 s->lambda= s->last_lambda_for[s->pict_type];
02751 else
02752 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
02753 update_qscale(s);
02754 }
02755
02756 s->mb_intra=0;
02757 for(i=1; i<s->avctx->thread_count; i++){
02758 ff_update_duplicate_context(s->thread_context[i], s);
02759 }
02760
02761 ff_init_me(s);
02762
02763
02764 if(s->pict_type != I_TYPE){
02765 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
02766 s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
02767 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
02768 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
02769 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
02770 }
02771 }
02772
02773 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
02774 }else {
02775
02776 for(i=0; i<s->mb_stride*s->mb_height; i++)
02777 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
02778
02779 if(!s->fixed_qscale){
02780
02781 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
02782 }
02783 }
02784 for(i=1; i<s->avctx->thread_count; i++){
02785 merge_context_after_me(s, s->thread_context[i]);
02786 }
02787 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
02788 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
02789 emms_c();
02790
02791 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
02792 s->pict_type= I_TYPE;
02793 for(i=0; i<s->mb_stride*s->mb_height; i++)
02794 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
02795
02796 }
02797
02798 if(!s->umvplus){
02799 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
02800 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
02801
02802 if(s->flags & CODEC_FLAG_INTERLACED_ME){
02803 int a,b;
02804 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I);
02805 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
02806 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
02807 }
02808
02809 ff_fix_long_p_mvs(s);
02810 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
02811 if(s->flags & CODEC_FLAG_INTERLACED_ME){
02812 int j;
02813 for(i=0; i<2; i++){
02814 for(j=0; j<2; j++)
02815 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
02816 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
02817 }
02818 }
02819 }
02820
02821 if(s->pict_type==B_TYPE){
02822 int a, b;
02823
02824 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
02825 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
02826 s->f_code = FFMAX(a, b);
02827
02828 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
02829 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
02830 s->b_code = FFMAX(a, b);
02831
02832 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
02833 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
02834 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
02835 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
02836 if(s->flags & CODEC_FLAG_INTERLACED_ME){
02837 int dir, j;
02838 for(dir=0; dir<2; dir++){
02839 for(i=0; i<2; i++){
02840 for(j=0; j<2; j++){
02841 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
02842 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
02843 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
02844 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
02845 }
02846 }
02847 }
02848 }
02849 }
02850 }
02851
02852 if (estimate_qp(s, 0) < 0)
02853 return -1;
02854
02855 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
02856 s->qscale= 3;
02857
02858 if (s->out_format == FMT_MJPEG) {
02859
02860 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
02861 for(i=1;i<64;i++){
02862 int j= s->dsp.idct_permutation[i];
02863
02864 s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
02865 }
02866 ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
02867 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
02868 s->qscale= 8;
02869 }
02870
02871
02872 s->current_picture_ptr->key_frame=
02873 s->current_picture.key_frame= s->pict_type == I_TYPE;
02874 s->current_picture_ptr->pict_type=
02875 s->current_picture.pict_type= s->pict_type;
02876
02877 if(s->current_picture.key_frame)
02878 s->picture_in_gop_number=0;
02879
02880 s->last_bits= put_bits_count(&s->pb);
02881 switch(s->out_format) {
02882 case FMT_MJPEG:
02883 if (ENABLE_MJPEG_ENCODER)
02884 ff_mjpeg_encode_picture_header(s);
02885 break;
02886 case FMT_H261:
02887 if (ENABLE_H261_ENCODER)
02888 ff_h261_encode_picture_header(s, picture_number);
02889 break;
02890 case FMT_H263:
02891 if (ENABLE_WMV2_ENCODER && s->codec_id == CODEC_ID_WMV2)
02892 ff_wmv2_encode_picture_header(s, picture_number);
02893 else if (ENABLE_MSMPEG4_ENCODER && s->h263_msmpeg4)
02894 msmpeg4_encode_picture_header(s, picture_number);
02895 else if (ENABLE_MPEG4_ENCODER && s->h263_pred)
02896 mpeg4_encode_picture_header(s, picture_number);
02897 else if (ENABLE_RV10_ENCODER && s->codec_id == CODEC_ID_RV10)
02898 rv10_encode_picture_header(s, picture_number);
02899 else if (ENABLE_RV20_ENCODER && s->codec_id == CODEC_ID_RV20)
02900 rv20_encode_picture_header(s, picture_number);
02901 else if (ENABLE_FLV_ENCODER && s->codec_id == CODEC_ID_FLV1)
02902 ff_flv_encode_picture_header(s, picture_number);
02903 else if (ENABLE_ANY_H263_ENCODER)
02904 h263_encode_picture_header(s, picture_number);
02905 break;
02906 case FMT_MPEG1:
02907 if (ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER)
02908 mpeg1_encode_picture_header(s, picture_number);
02909 break;
02910 case FMT_H264:
02911 break;
02912 default:
02913 assert(0);
02914 }
02915 bits= put_bits_count(&s->pb);
02916 s->header_bits= bits - s->last_bits;
02917
02918 for(i=1; i<s->avctx->thread_count; i++){
02919 update_duplicate_context_after_me(s->thread_context[i], s);
02920 }
02921 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
02922 for(i=1; i<s->avctx->thread_count; i++){
02923 merge_context_after_encode(s, s->thread_context[i]);
02924 }
02925 emms_c();
02926 return 0;
02927 }
02928
02929 void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
02930 const int intra= s->mb_intra;
02931 int i;
02932
02933 s->dct_count[intra]++;
02934
02935 for(i=0; i<64; i++){
02936 int level= block[i];
02937
02938 if(level){
02939 if(level>0){
02940 s->dct_error_sum[intra][i] += level;
02941 level -= s->dct_offset[intra][i];
02942 if(level<0) level=0;
02943 }else{
02944 s->dct_error_sum[intra][i] -= level;
02945 level += s->dct_offset[intra][i];
02946 if(level>0) level=0;
02947 }
02948 block[i]= level;
02949 }
02950 }
02951 }
02952
02953 int dct_quantize_trellis_c(MpegEncContext *s,
02954 DCTELEM *block, int n,
02955 int qscale, int *overflow){
02956 const int *qmat;
02957 const uint8_t *scantable= s->intra_scantable.scantable;
02958 const uint8_t *perm_scantable= s->intra_scantable.permutated;
02959 int max=0;
02960 unsigned int threshold1, threshold2;
02961 int bias=0;
02962 int run_tab[65];
02963 int level_tab[65];
02964 int score_tab[65];
02965 int survivor[65];
02966 int survivor_count;
02967 int last_run=0;
02968 int last_level=0;
02969 int last_score= 0;
02970 int last_i;
02971 int coeff[2][64];
02972 int coeff_count[64];
02973 int qmul, qadd, start_i, last_non_zero, i, dc;
02974 const int esc_length= s->ac_esc_length;
02975 uint8_t * length;
02976 uint8_t * last_length;
02977 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
02978
02979 s->dsp.fdct (block);
02980
02981 if(s->dct_error_sum)
02982 s->denoise_dct(s, block);
02983 qmul= qscale*16;
02984 qadd= ((qscale-1)|1)*8;
02985
02986 if (s->mb_intra) {
02987 int q;
02988 if (!s->h263_aic) {
02989 if (n < 4)
02990 q = s->y_dc_scale;
02991 else
02992 q = s->c_dc_scale;
02993 q = q << 3;
02994 } else{
02995
02996 q = 1 << 3;
02997 qadd=0;
02998 }
02999
03000
03001 block[0] = (block[0] + (q >> 1)) / q;
03002 start_i = 1;
03003 last_non_zero = 0;
03004 qmat = s->q_intra_matrix[qscale];
03005 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
03006 bias= 1<<(QMAT_SHIFT-1);
03007 length = s->intra_ac_vlc_length;
03008 last_length= s->intra_ac_vlc_last_length;
03009 } else {
03010 start_i = 0;
03011 last_non_zero = -1;
03012 qmat = s->q_inter_matrix[qscale];
03013 length = s->inter_ac_vlc_length;
03014 last_length= s->inter_ac_vlc_last_length;
03015 }
03016 last_i= start_i;
03017
03018 threshold1= (1<<QMAT_SHIFT) - bias - 1;
03019 threshold2= (threshold1<<1);
03020
03021 for(i=63; i>=start_i; i--) {
03022 const int j = scantable[i];
03023 int level = block[j] * qmat[j];
03024
03025 if(((unsigned)(level+threshold1))>threshold2){
03026 last_non_zero = i;
03027 break;
03028 }
03029 }
03030
03031 for(i=start_i; i<=last_non_zero; i++) {
03032 const int j = scantable[i];
03033 int level = block[j] * qmat[j];
03034
03035
03036
03037 if(((unsigned)(level+threshold1))>threshold2){
03038 if(level>0){
03039 level= (bias + level)>>QMAT_SHIFT;
03040 coeff[0][i]= level;
03041 coeff[1][i]= level-1;
03042
03043 }else{
03044 level= (bias - level)>>QMAT_SHIFT;
03045 coeff[0][i]= -level;
03046 coeff[1][i]= -level+1;
03047
03048 }
03049 coeff_count[i]= FFMIN(level, 2);
03050 assert(coeff_count[i]);
03051 max |=level;
03052 }else{
03053 coeff[0][i]= (level>>31)|1;
03054 coeff_count[i]= 1;
03055 }
03056 }
03057
03058 *overflow= s->max_qcoeff < max;
03059
03060 if(last_non_zero < start_i){
03061 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
03062 return last_non_zero;
03063 }
03064
03065 score_tab[start_i]= 0;
03066 survivor[0]= start_i;
03067 survivor_count= 1;
03068
03069 for(i=start_i; i<=last_non_zero; i++){
03070 int level_index, j;
03071 const int dct_coeff= FFABS(block[ scantable[i] ]);
03072 const int zero_distoration= dct_coeff*dct_coeff;
03073 int best_score=256*256*256*120;
03074 for(level_index=0; level_index < coeff_count[i]; level_index++){
03075 int distoration;
03076 int level= coeff[level_index][i];
03077 const int alevel= FFABS(level);
03078 int unquant_coeff;
03079
03080 assert(level);
03081
03082 if(s->out_format == FMT_H263){
03083 unquant_coeff= alevel*qmul + qadd;
03084 }else{
03085 j= s->dsp.idct_permutation[ scantable[i] ];
03086 if(s->mb_intra){
03087 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
03088 unquant_coeff = (unquant_coeff - 1) | 1;
03089 }else{
03090 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
03091 unquant_coeff = (unquant_coeff - 1) | 1;
03092 }
03093 unquant_coeff<<= 3;
03094 }
03095
03096 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
03097 level+=64;
03098 if((level&(~127)) == 0){
03099 for(j=survivor_count-1; j>=0; j--){
03100 int run= i - survivor[j];
03101 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
03102 score += score_tab[i-run];
03103
03104 if(score < best_score){
03105 best_score= score;
03106 run_tab[i+1]= run;
03107 level_tab[i+1]= level-64;
03108 }
03109 }
03110
03111 if(s->out_format == FMT_H263){
03112 for(j=survivor_count-1; j>=0; j--){
03113 int run= i - survivor[j];
03114 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
03115 score += score_tab[i-run];
03116 if(score < last_score){
03117 last_score= score;
03118 last_run= run;
03119 last_level= level-64;
03120 last_i= i+1;
03121 }
03122 }
03123 }
03124 }else{
03125 distoration += esc_length*lambda;
03126 for(j=survivor_count-1; j>=0; j--){
03127 int run= i - survivor[j];
03128 int score= distoration + score_tab[i-run];
03129
03130 if(score < best_score){
03131 best_score= score;
03132 run_tab[i+1]= run;
03133 level_tab[i+1]= level-64;
03134 }
03135 }
03136
03137 if(s->out_format == FMT_H263){
03138 for(j=survivor_count-1; j>=0; j--){
03139 int run= i - survivor[j];
03140 int score= distoration + score_tab[i-run];
03141 if(score < last_score){
03142 last_score= score;
03143 last_run= run;
03144 last_level= level-64;
03145 last_i= i+1;
03146 }
03147 }
03148 }
03149 }
03150 }
03151
03152 score_tab[i+1]= best_score;
03153
03154
03155 if(last_non_zero <= 27){
03156 for(; survivor_count; survivor_count--){
03157 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
03158 break;
03159 }
03160 }else{
03161 for(; survivor_count; survivor_count--){
03162 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
03163 break;
03164 }
03165 }
03166
03167 survivor[ survivor_count++ ]= i+1;
03168 }
03169
03170 if(s->out_format != FMT_H263){
03171 last_score= 256*256*256*120;
03172 for(i= survivor[0]; i<=last_non_zero + 1; i++){
03173 int score= score_tab[i];
03174 if(i) score += lambda*2;
03175
03176 if(score < last_score){
03177 last_score= score;
03178 last_i= i;
03179 last_level= level_tab[i];
03180 last_run= run_tab[i];
03181 }
03182 }
03183 }
03184
03185 s->coded_score[n] = last_score;
03186
03187 dc= FFABS(block[0]);
03188 last_non_zero= last_i - 1;
03189 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
03190
03191 if(last_non_zero < start_i)
03192 return last_non_zero;
03193
03194 if(last_non_zero == 0 && start_i == 0){
03195 int best_level= 0;
03196 int best_score= dc * dc;
03197
03198 for(i=0; i<coeff_count[0]; i++){
03199 int level= coeff[i][0];
03200 int alevel= FFABS(level);
03201 int unquant_coeff, score, distortion;
03202
03203 if(s->out_format == FMT_H263){
03204 unquant_coeff= (alevel*qmul + qadd)>>3;
03205 }else{
03206 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
03207 unquant_coeff = (unquant_coeff - 1) | 1;
03208 }
03209 unquant_coeff = (unquant_coeff + 4) >> 3;
03210 unquant_coeff<<= 3 + 3;
03211
03212 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
03213 level+=64;
03214 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
03215 else score= distortion + esc_length*lambda;
03216
03217 if(score < best_score){
03218 best_score= score;
03219 best_level= level - 64;
03220 }
03221 }
03222 block[0]= best_level;
03223 s->coded_score[n] = best_score - dc*dc;
03224 if(best_level == 0) return -1;
03225 else return last_non_zero;
03226 }
03227
03228 i= last_i;
03229 assert(last_level);
03230
03231 block[ perm_scantable[last_non_zero] ]= last_level;
03232 i -= last_run + 1;
03233
03234 for(; i>start_i; i -= run_tab[i] + 1){
03235 block[ perm_scantable[i-1] ]= level_tab[i];
03236 }
03237
03238 return last_non_zero;
03239 }
03240
03241
03242 static int16_t basis[64][64];
03243
03244 static void build_basis(uint8_t *perm){
03245 int i, j, x, y;
03246 emms_c();
03247 for(i=0; i<8; i++){
03248 for(j=0; j<8; j++){
03249 for(y=0; y<8; y++){
03250 for(x=0; x<8; x++){
03251 double s= 0.25*(1<<BASIS_SHIFT);
03252 int index= 8*i + j;
03253 int perm_index= perm[index];
03254 if(i==0) s*= sqrt(0.5);
03255 if(j==0) s*= sqrt(0.5);
03256 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)));
03257 }
03258 }
03259 }
03260 }
03261 }
03262
03263 static int dct_quantize_refine(MpegEncContext *s,
03264 DCTELEM *block, int16_t *weight, DCTELEM *orig,
03265 int n, int qscale){
03266 int16_t rem[64];
03267 DECLARE_ALIGNED_16(DCTELEM, d1[64]);
03268 const int *qmat;
03269 const uint8_t *scantable= s->intra_scantable.scantable;
03270 const uint8_t *perm_scantable= s->intra_scantable.permutated;
03271
03272
03273 int run_tab[65];
03274 int prev_run=0;
03275 int prev_level=0;
03276 int qmul, qadd, start_i, last_non_zero, i, dc;
03277 uint8_t * length;
03278 uint8_t * last_length;
03279 int lambda;
03280 int rle_index, run, q = 1, sum;
03281 #ifdef REFINE_STATS
03282 static int count=0;
03283 static int after_last=0;
03284 static int to_zero=0;
03285 static int from_zero=0;
03286 static int raise=0;
03287 static int lower=0;
03288 static int messed_sign=0;
03289 #endif
03290
03291 if(basis[0][0] == 0)
03292 build_basis(s->dsp.idct_permutation);
03293
03294 qmul= qscale*2;
03295 qadd= (qscale-1)|1;
03296 if (s->mb_intra) {
03297 if (!s->h263_aic) {
03298 if (n < 4)
03299 q = s->y_dc_scale;
03300 else
03301 q = s->c_dc_scale;
03302 } else{
03303
03304 q = 1;
03305 qadd=0;
03306 }
03307 q <<= RECON_SHIFT-3;
03308
03309 dc= block[0]*q;
03310
03311 start_i = 1;
03312 qmat = s->q_intra_matrix[qscale];
03313
03314
03315 length = s->intra_ac_vlc_length;
03316 last_length= s->intra_ac_vlc_last_length;
03317 } else {
03318 dc= 0;
03319 start_i = 0;
03320 qmat = s->q_inter_matrix[qscale];
03321 length = s->inter_ac_vlc_length;
03322 last_length= s->inter_ac_vlc_last_length;
03323 }
03324 last_non_zero = s->block_last_index[n];
03325
03326 #ifdef REFINE_STATS
03327 {START_TIMER
03328 #endif
03329 dc += (1<<(RECON_SHIFT-1));
03330 for(i=0; i<64; i++){
03331 rem[i]= dc - (orig[i]<<RECON_SHIFT);
03332 }
03333 #ifdef REFINE_STATS
03334 STOP_TIMER("memset rem[]")}
03335 #endif
03336 sum=0;
03337 for(i=0; i<64; i++){
03338 int one= 36;
03339 int qns=4;
03340 int w;
03341
03342 w= FFABS(weight[i]) + qns*one;
03343 w= 15 + (48*qns*one + w/2)/w;
03344
03345 weight[i] = w;
03346
03347
03348 assert(w>0);
03349 assert(w<(1<<6));
03350 sum += w*w;
03351 }
03352 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
03353 #ifdef REFINE_STATS
03354 {START_TIMER
03355 #endif
03356 run=0;
03357 rle_index=0;
03358 for(i=start_i; i<=last_non_zero; i++){
03359 int j= perm_scantable[i];
03360 const int level= block[j];
03361 int coeff;
03362
03363 if(level){
03364 if(level<0) coeff= qmul*level - qadd;
03365 else coeff= qmul*level + qadd;
03366 run_tab[rle_index++]=run;
03367 run=0;
03368
03369 s->dsp.add_8x8basis(rem, basis[j], coeff);
03370 }else{
03371 run++;
03372 }
03373 }
03374 #ifdef REFINE_STATS
03375 if(last_non_zero>0){
03376 STOP_TIMER("init rem[]")
03377 }
03378 }
03379
03380 {START_TIMER
03381 #endif
03382 for(;;){
03383 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
03384 int best_coeff=0;
03385 int best_change=0;
03386 int run2, best_unquant_change=0, analyze_gradient;
03387 #ifdef REFINE_STATS
03388 {START_TIMER
03389 #endif
03390 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
03391
03392 if(analyze_gradient){
03393 #ifdef REFINE_STATS
03394 {START_TIMER
03395 #endif
03396 for(i=0; i<64; i++){
03397 int w= weight[i];
03398
03399 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
03400 }
03401 #ifdef REFINE_STATS
03402 STOP_TIMER("rem*w*w")}
03403 {START_TIMER
03404 #endif
03405 s->dsp.fdct(d1);
03406 #ifdef REFINE_STATS
03407 STOP_TIMER("dct")}
03408 #endif
03409 }
03410
03411 if(start_i){
03412 const int level= block[0];
03413 int change, old_coeff;
03414
03415 assert(s->mb_intra);
03416
03417 old_coeff= q*level;
03418
03419 for(change=-1; change<=1; change+=2){
03420 int new_level= level + change;
03421 int score, new_coeff;
03422
03423 new_coeff= q*new_level;
03424 if(new_coeff >= 2048 || new_coeff < 0)
03425 continue;
03426
03427 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
03428 if(score<best_score){
03429 best_score= score;
03430 best_coeff= 0;
03431 best_change= change;
03432 best_unquant_change= new_coeff - old_coeff;
03433 }
03434 }
03435 }
03436
03437 run=0;
03438 rle_index=0;
03439 run2= run_tab[rle_index++];
03440 prev_level=0;
03441 prev_run=0;
03442
03443 for(i=start_i; i<64; i++){
03444 int j= perm_scantable[i];
03445 const int level= block[j];
03446 int change, old_coeff;
03447
03448 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
03449 break;
03450
03451 if(level){
03452 if(level<0) old_coeff= qmul*level - qadd;
03453 else old_coeff= qmul*level + qadd;
03454 run2= run_tab[rle_index++];
03455 }else{
03456 old_coeff=0;
03457 run2--;
03458 assert(run2>=0 || i >= last_non_zero );
03459 }
03460
03461 for(change=-1; change<=1; change+=2){
03462 int new_level= level + change;
03463 int score, new_coeff, unquant_change;
03464
03465 score=0;
03466 if(s->avctx->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
03467 continue;
03468
03469 if(new_level){
03470 if(new_level<0) new_coeff= qmul*new_level - qadd;
03471 else new_coeff= qmul*new_level + qadd;
03472 if(new_coeff >= 2048 || new_coeff <= -2048)
03473 continue;
03474
03475
03476 if(level){
03477 if(level < 63 && level > -63){
03478 if(i < last_non_zero)
03479 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
03480 - length[UNI_AC_ENC_INDEX(run, level+64)];
03481 else
03482 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
03483 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
03484 }
03485 }else{
03486 assert(FFABS(new_level)==1);
03487
03488 if(analyze_gradient){
03489 int g= d1[ scantable[i] ];
03490 if(g && (g^new_level) >= 0)
03491 continue;
03492 }
03493
03494 if(i < last_non_zero){
03495 int next_i= i + run2 + 1;
03496 int next_level= block[ perm_scantable[next_i] ] + 64;
03497
03498 if(next_level&(~127))
03499 next_level= 0;
03500
03501 if(next_i < last_non_zero)
03502 score += length[UNI_AC_ENC_INDEX(run, 65)]
03503 + length[UNI_AC_ENC_INDEX(run2, next_level)]
03504 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
03505 else
03506 score += length[UNI_AC_ENC_INDEX(run, 65)]
03507 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
03508 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
03509 }else{
03510 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
03511 if(prev_level){
03512 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
03513 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
03514 }
03515 }
03516 }
03517 }else{
03518 new_coeff=0;
03519 assert(FFABS(level)==1);
03520
03521 if(i < last_non_zero){
03522 int next_i= i + run2 + 1;
03523 int next_level= block[ perm_scantable[next_i] ] + 64;
03524
03525 if(next_level&(~127))
03526 next_level= 0;
03527
03528 if(next_i < last_non_zero)
03529 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
03530 - length[UNI_AC_ENC_INDEX(run2, next_level)]
03531 - length[UNI_AC_ENC_INDEX(run, 65)];
03532 else
03533 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
03534 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
03535 - length[UNI_AC_ENC_INDEX(run, 65)];
03536 }else{
03537 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
03538 if(prev_level){
03539 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
03540 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
03541 }
03542 }
03543 }
03544
03545 score *= lambda;
03546
03547 unquant_change= new_coeff - old_coeff;
03548 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
03549
03550 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
03551 if(score<best_score){
03552 best_score= score;
03553 best_coeff= i;
03554 best_change= change;
03555 best_unquant_change= unquant_change;
03556 }
03557 }
03558 if(level){
03559 prev_level= level + 64;
03560 if(prev_level&(~127))
03561 prev_level= 0;
03562 prev_run= run;
03563 run=0;
03564 }else{
03565 run++;
03566 }
03567 }
03568 #ifdef REFINE_STATS
03569 STOP_TIMER("iterative step")}
03570 #endif
03571
03572 if(best_change){
03573 int j= perm_scantable[ best_coeff ];
03574
03575 block[j] += best_change;
03576
03577 if(best_coeff > last_non_zero){
03578 last_non_zero= best_coeff;
03579 assert(block[j]);
03580 #ifdef REFINE_STATS
03581 after_last++;
03582 #endif
03583 }else{
03584 #ifdef REFINE_STATS
03585 if(block[j]){
03586 if(block[j] - best_change){
03587 if(FFABS(block[j]) > FFABS(block[j] - best_change)){
03588 raise++;
03589 }else{
03590 lower++;
03591 }
03592 }else{
03593 from_zero++;
03594 }
03595 }else{
03596 to_zero++;
03597 }
03598 #endif
03599 for(; last_non_zero>=start_i; last_non_zero--){
03600 if(block[perm_scantable[last_non_zero]])
03601 break;
03602 }
03603 }
03604 #ifdef REFINE_STATS
03605 count++;
03606 if(256*256*256*64 % count == 0){
03607 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);
03608 }
03609 #endif
03610 run=0;
03611 rle_index=0;
03612 for(i=start_i; i<=last_non_zero; i++){
03613 int j= perm_scantable[i];
03614 const int level= block[j];
03615
03616 if(level){
03617 run_tab[rle_index++]=run;
03618 run=0;
03619 }else{
03620 run++;
03621 }
03622 }
03623
03624 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
03625 }else{
03626 break;
03627 }
03628 }
03629 #ifdef REFINE_STATS
03630 if(last_non_zero>0){
03631 STOP_TIMER("iterative search")
03632 }
03633 }
03634 #endif
03635
03636 return last_non_zero;
03637 }
03638
03639 int dct_quantize_c(MpegEncContext *s,
03640 DCTELEM *block, int n,
03641 int qscale, int *overflow)
03642 {
03643 int i, j, level, last_non_zero, q, start_i;
03644 const int *qmat;
03645 const uint8_t *scantable= s->intra_scantable.scantable;
03646 int bias;
03647 int max=0;
03648 unsigned int threshold1, threshold2;
03649
03650 s->dsp.fdct (block);
03651
03652 if(s->dct_error_sum)
03653 s->denoise_dct(s, block);
03654
03655 if (s->mb_intra) {
03656 if (!s->h263_aic) {
03657 if (n < 4)
03658 q = s->y_dc_scale;
03659 else
03660 q = s->c_dc_scale;
03661 q = q << 3;
03662 } else
03663
03664 q = 1 << 3;
03665
03666
03667 block[0] = (block[0] + (q >> 1)) / q;
03668 start_i = 1;
03669 last_non_zero = 0;
03670 qmat = s->q_intra_matrix[qscale];
03671 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
03672 } else {
03673 start_i = 0;
03674 last_non_zero = -1;
03675 qmat = s->q_inter_matrix[qscale];
03676 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
03677 }
03678 threshold1= (1<<QMAT_SHIFT) - bias - 1;
03679 threshold2= (threshold1<<1);
03680 for(i=63;i>=start_i;i--) {
03681 j = scantable[i];
03682 level = block[j] * qmat[j];
03683
03684 if(((unsigned)(level+threshold1))>threshold2){
03685 last_non_zero = i;
03686 break;
03687 }else{
03688 block[j]=0;
03689 }
03690 }
03691 for(i=start_i; i<=last_non_zero; i++) {
03692 j = scantable[i];
03693 level = block[j] * qmat[j];
03694
03695
03696
03697 if(((unsigned)(level+threshold1))>threshold2){
03698 if(level>0){
03699 level= (bias + level)>>QMAT_SHIFT;
03700 block[j]= level;
03701 }else{
03702 level= (bias - level)>>QMAT_SHIFT;
03703 block[j]= -level;
03704 }
03705 max |=level;
03706 }else{
03707 block[j]=0;
03708 }
03709 }
03710 *overflow= s->max_qcoeff < max;
03711
03712
03713 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
03714 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
03715
03716 return last_non_zero;
03717 }
03718
03719
03720
03721 AVCodec flv_encoder = {
03722 "flv",
03723 CODEC_TYPE_VIDEO,
03724 CODEC_ID_FLV1,
03725 sizeof(MpegEncContext),
03726 MPV_encode_init,
03727 MPV_encode_picture,
03728 MPV_encode_end,
03729 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
03730 };
03731
03732 AVCodec rv10_encoder = {
03733 "rv10",
03734 CODEC_TYPE_VIDEO,
03735 CODEC_ID_RV10,
03736 sizeof(MpegEncContext),
03737 MPV_encode_init,
03738 MPV_encode_picture,
03739 MPV_encode_end,
03740 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
03741 };
03742
03743 AVCodec rv20_encoder = {
03744 "rv20",
03745 CODEC_TYPE_VIDEO,
03746 CODEC_ID_RV20,
03747 sizeof(MpegEncContext),
03748 MPV_encode_init,
03749 MPV_encode_picture,
03750 MPV_encode_end,
03751 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
03752 };
03753
03754
03755
03756
03757
03758 AVCodec wmv1_encoder = {
03759 "wmv1",
03760 CODEC_TYPE_VIDEO,
03761 CODEC_ID_WMV1,
03762 sizeof(MpegEncContext),
03763 MPV_encode_init,
03764 MPV_encode_picture,
03765 MPV_encode_end,
03766 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
03767 };