MythTV: mpegvideo_enc.c Source File

00001 /*
00002  * The simplest mpeg encoder (well, it was the simplest!)
00003  * Copyright (c) 2000,2001 Fabrice Bellard.
00004  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
00005  *
00006  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
00007  *
00008  * This file is part of FFmpeg.
00009  *
00010  * FFmpeg is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free Software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  *
00015  * FFmpeg is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with FFmpeg; if not, write to the Free Software
00022  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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 //#undef NDEBUG
00041 //#include <assert.h>
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 /* enable all paranoid tests for rounding, overflows, etc... */
00048 //#define PARANOID
00049 
00050 //#define DEBUG
00051 
00052 static const uint16_t aanscales[64] = {
00053     /* precomputed values scaled up by 14 bits */
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 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
00068 
00069 void ff_convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
00070                            const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
00071 {
00072     int qscale;
00073     int shift=0;
00074 
00075     for(qscale=qmin; qscale<=qmax; qscale++){
00076         int i;
00077         if (dsp->fdct == ff_jpeg_fdct_islow
00078 #ifdef FAAN_POSTSCALE
00079             || dsp->fdct == ff_faandct
00080 #endif
00081             ) {
00082             for(i=0;i<64;i++) {
00083                 const int j= dsp->idct_permutation[i];
00084                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
00085                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
00086                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
00087                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
00088 
00089                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) /
00090                                 (qscale * quant_matrix[j]));
00091             }
00092         } else if (dsp->fdct == fdct_ifast
00093 #ifndef FAAN_POSTSCALE
00094                    || dsp->fdct == ff_faandct
00095 #endif
00096                    ) {
00097             for(i=0;i<64;i++) {
00098                 const int j= dsp->idct_permutation[i];
00099                 /* 16 <= qscale * quant_matrix[i] <= 7905 */
00100                 /* 19952         <= aanscales[i] * qscale * quant_matrix[i]           <= 249205026 */
00101                 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
00102                 /* 3444240       >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
00103 
00104                 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) /
00105                                 (aanscales[i] * qscale * quant_matrix[j]));
00106             }
00107         } else {
00108             for(i=0;i<64;i++) {
00109                 const int j= dsp->idct_permutation[i];
00110                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
00111                    So 16           <= qscale * quant_matrix[i]             <= 7905
00112                    so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
00113                    so 32768        >= (1<<19) / (qscale * quant_matrix[i]) >= 67
00114                 */
00115                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
00116 //                qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
00117                 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
00118 
00119                 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
00120                 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
00121             }
00122         }
00123 
00124         for(i=intra; i<64; i++){
00125             int64_t max= 8191;
00126             if (dsp->fdct == fdct_ifast
00127 #ifndef FAAN_POSTSCALE
00128                    || dsp->fdct == ff_faandct
00129 #endif
00130                    ) {
00131                 max= (8191LL*aanscales[i]) >> 14;
00132             }
00133             while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
00134                 shift++;
00135             }
00136         }
00137     }
00138     if(shift){
00139         av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger than %d, overflows possible\n", QMAT_SHIFT - shift);
00140     }
00141 }
00142 
00143 static inline void update_qscale(MpegEncContext *s){
00144     s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
00145     s->qscale= av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
00146 
00147     s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
00148 }
00149 
00150 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
00151     int i;
00152 
00153     if(matrix){
00154         put_bits(pb, 1, 1);
00155         for(i=0;i<64;i++) {
00156             put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
00157         }
00158     }else
00159         put_bits(pb, 1, 0);
00160 }
00161 
00162 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
00163     int i;
00164 
00165     dst->pict_type              = src->pict_type;
00166     dst->quality                = src->quality;
00167     dst->coded_picture_number   = src->coded_picture_number;
00168     dst->display_picture_number = src->display_picture_number;
00169 //    dst->reference              = src->reference;
00170     dst->pts                    = src->pts;
00171     dst->interlaced_frame       = src->interlaced_frame;
00172     dst->top_field_first        = src->top_field_first;
00173 
00174     if(s->avctx->me_threshold){
00175         if(!src->motion_val[0])
00176             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
00177         if(!src->mb_type)
00178             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
00179         if(!src->ref_index[0])
00180             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
00181         if(src->motion_subsample_log2 != dst->motion_subsample_log2)
00182             av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
00183             src->motion_subsample_log2, dst->motion_subsample_log2);
00184 
00185         memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
00186 
00187         for(i=0; i<2; i++){
00188             int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
00189             int height= ((16*s->mb_height)>>src->motion_subsample_log2);
00190 
00191             if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
00192                 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
00193             }
00194             if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
00195                 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
00196             }
00197         }
00198     }
00199 }
00200 
00201 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
00202 #define COPY(a) dst->a= src->a
00203     COPY(pict_type);
00204     COPY(current_picture);
00205     COPY(f_code);
00206     COPY(b_code);
00207     COPY(qscale);
00208     COPY(lambda);
00209     COPY(lambda2);
00210     COPY(picture_in_gop_number);
00211     COPY(gop_picture_number);
00212     COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
00213     COPY(progressive_frame); //FIXME don't set in encode_header
00214     COPY(partitioned_frame); //FIXME don't set in encode_header
00215 #undef COPY
00216 }
00217 
00222 static void MPV_encode_defaults(MpegEncContext *s){
00223     int i;
00224     MPV_common_defaults(s);
00225 
00226     for(i=-16; i<16; i++){
00227         default_fcode_tab[i + MAX_MV]= 1;
00228     }
00229     s->me.mv_penalty= default_mv_penalty;
00230     s->fcode_tab= default_fcode_tab;
00231 }
00232 
00233 /* init video encoder */
00234 int MPV_encode_init(AVCodecContext *avctx)
00235 {
00236     MpegEncContext *s = avctx->priv_data;
00237     int i;
00238     int chroma_h_shift, chroma_v_shift;
00239 
00240     MPV_encode_defaults(s);
00241 
00242     switch (avctx->codec_id) {
00243     case CODEC_ID_MPEG2VIDEO:
00244         if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
00245             av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
00246             return -1;
00247         }
00248         break;
00249     case CODEC_ID_LJPEG:
00250     case CODEC_ID_MJPEG:
00251         if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUVJ422P &&
00252            ((avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P) || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
00253             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
00254             return -1;
00255         }
00256         break;
00257     default:
00258         if(avctx->pix_fmt != PIX_FMT_YUV420P){
00259             av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
00260             return -1;
00261         }
00262     }
00263 
00264     switch (avctx->pix_fmt) {
00265     case PIX_FMT_YUVJ422P:
00266     case PIX_FMT_YUV422P:
00267         s->chroma_format = CHROMA_422;
00268         break;
00269     case PIX_FMT_YUVJ420P:
00270     case PIX_FMT_YUV420P:
00271     default:
00272         s->chroma_format = CHROMA_420;
00273         break;
00274     }
00275 
00276     s->bit_rate = avctx->bit_rate;
00277     s->width = avctx->width;
00278     s->height = avctx->height;
00279     if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
00280         av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
00281         avctx->gop_size=600;
00282     }
00283     s->gop_size = avctx->gop_size;
00284     s->avctx = avctx;
00285     s->flags= avctx->flags;
00286     s->flags2= avctx->flags2;
00287     s->max_b_frames= avctx->max_b_frames;
00288     s->codec_id= avctx->codec->id;
00289     s->luma_elim_threshold  = avctx->luma_elim_threshold;
00290     s->chroma_elim_threshold= avctx->chroma_elim_threshold;
00291     s->strict_std_compliance= avctx->strict_std_compliance;
00292     s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
00293     s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
00294     s->mpeg_quant= avctx->mpeg_quant;
00295     s->rtp_mode= !!avctx->rtp_payload_size;
00296     s->intra_dc_precision= avctx->intra_dc_precision;
00297     s->user_specified_pts = AV_NOPTS_VALUE;
00298 
00299     if (s->gop_size <= 1) {
00300         s->intra_only = 1;
00301         s->gop_size = 12;
00302     } else {
00303         s->intra_only = 0;
00304     }
00305 
00306     s->me_method = avctx->me_method;
00307 
00308     /* Fixed QSCALE */
00309     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
00310 
00311     s->adaptive_quant= (   s->avctx->lumi_masking
00312                         || s->avctx->dark_masking
00313                         || s->avctx->temporal_cplx_masking
00314                         || s->avctx->spatial_cplx_masking
00315                         || s->avctx->p_masking
00316                         || s->avctx->border_masking
00317                         || (s->flags&CODEC_FLAG_QP_RD))
00318                        && !s->fixed_qscale;
00319 
00320     s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
00321     s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
00322     s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
00323     s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
00324     s->q_scale_type= !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
00325 
00326     if(avctx->rc_max_rate && !avctx->rc_buffer_size){
00327         av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
00328         return -1;
00329     }
00330 
00331     if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
00332         av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
00333     }
00334 
00335     if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
00336         av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
00337         return -1;
00338     }
00339 
00340     if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
00341         av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
00342         return -1;
00343     }
00344 
00345     if(avctx->rc_max_rate && avctx->rc_max_rate == avctx->bit_rate && avctx->rc_max_rate != avctx->rc_min_rate){
00346         av_log(avctx, AV_LOG_INFO, "impossible bitrate constraints, this will fail\n");
00347     }
00348 
00349     if(avctx->rc_buffer_size && avctx->bit_rate*av_q2d(avctx->time_base) > avctx->rc_buffer_size){
00350         av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
00351         return -1;
00352     }
00353 
00354     if(avctx->bit_rate*av_q2d(avctx->time_base) > avctx->bit_rate_tolerance){
00355         av_log(avctx, AV_LOG_ERROR, "bitrate tolerance too small for bitrate\n");
00356         return -1;
00357     }
00358 
00359     if(   s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
00360        && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
00361        && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
00362 
00363         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");
00364     }
00365 
00366     if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
00367        && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
00368         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
00369         return -1;
00370     }
00371 
00372     if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
00373         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
00374         return -1;
00375     }
00376 
00377     if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
00378         av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
00379         return -1;
00380     }
00381 
00382     if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
00383         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
00384         return -1;
00385     }
00386 
00387     if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
00388         av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
00389         return -1;
00390     }
00391 
00392     if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
00393         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
00394         return -1;
00395     }
00396 
00397     if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
00398        && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
00399         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
00400         return -1;
00401     }
00402 
00403     if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
00404         av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
00405         return -1;
00406     }
00407 
00408     if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
00409         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
00410         return -1;
00411     }
00412 
00413     if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
00414         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
00415         return -1;
00416     }
00417 
00418     if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
00419         av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet, set threshold to 1000000000\n");
00420         return -1;
00421     }
00422 
00423     if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
00424         av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
00425         return -1;
00426     }
00427 
00428     if(s->flags & CODEC_FLAG_LOW_DELAY){
00429         if (s->codec_id != CODEC_ID_MPEG2VIDEO && s->codec_id != CODEC_ID_MPEG1VIDEO){
00430             av_log(avctx, AV_LOG_ERROR, "low delay forcing is only available for mpeg1/2\n");
00431             return -1;
00432         }
00433         if (s->max_b_frames != 0){
00434             av_log(avctx, AV_LOG_ERROR, "b frames cannot be used with low delay\n");
00435             return -1;
00436         }
00437     }
00438 
00439     if(s->q_scale_type == 1){
00440         if(s->codec_id != CODEC_ID_MPEG2VIDEO){
00441             av_log(avctx, AV_LOG_ERROR, "non linear quant is only available for mpeg2\n");
00442             return -1;
00443         }
00444         if(avctx->qmax > 12){
00445             av_log(avctx, AV_LOG_ERROR, "non linear quant only supports qmax <= 12 currently\n");
00446             return -1;
00447         }
00448     }
00449 
00450     if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
00451        && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
00452        && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
00453         av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
00454         return -1;
00455     }
00456 
00457     if(s->avctx->thread_count > 1)
00458         s->rtp_mode= 1;
00459 
00460     if(!avctx->time_base.den || !avctx->time_base.num){
00461         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
00462         return -1;
00463     }
00464 
00465     i= (INT_MAX/2+128)>>8;
00466     if(avctx->me_threshold >= i){
00467         av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
00468         return -1;
00469     }
00470     if(avctx->mb_threshold >= i){
00471         av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
00472         return -1;
00473     }
00474 
00475     if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
00476         av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
00477         avctx->b_frame_strategy = 0;
00478     }
00479 
00480     i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
00481     if(i > 1){
00482         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
00483         avctx->time_base.den /= i;
00484         avctx->time_base.num /= i;
00485 //        return -1;
00486     }
00487 
00488     if(s->codec_id==CODEC_ID_MJPEG){
00489         s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
00490         s->inter_quant_bias= 0;
00491     }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
00492         s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
00493         s->inter_quant_bias= 0;
00494     }else{
00495         s->intra_quant_bias=0;
00496         s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
00497     }
00498 
00499     if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
00500         s->intra_quant_bias= avctx->intra_quant_bias;
00501     if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
00502         s->inter_quant_bias= avctx->inter_quant_bias;
00503 
00504     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
00505 
00506     if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
00507         av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
00508         return -1;
00509     }
00510     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
00511 
00512     switch(avctx->codec->id) {
00513     case CODEC_ID_MPEG1VIDEO:
00514         s->out_format = FMT_MPEG1;
00515         s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
00516         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
00517         break;
00518     case CODEC_ID_MPEG2VIDEO:
00519         s->out_format = FMT_MPEG1;
00520         s->low_delay= !!(s->flags & CODEC_FLAG_LOW_DELAY);
00521         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
00522         s->rtp_mode= 1;
00523         break;
00524     case CODEC_ID_LJPEG:
00525     case CODEC_ID_MJPEG:
00526         s->out_format = FMT_MJPEG;
00527         s->intra_only = 1; /* force intra only for jpeg */
00528         s->mjpeg_vsample[0] = 2;
00529         s->mjpeg_vsample[1] = 2>>chroma_v_shift;
00530         s->mjpeg_vsample[2] = 2>>chroma_v_shift;
00531         s->mjpeg_hsample[0] = 2;
00532         s->mjpeg_hsample[1] = 2>>chroma_h_shift;
00533         s->mjpeg_hsample[2] = 2>>chroma_h_shift;
00534         if (!(ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER)
00535             || ff_mjpeg_encode_init(s) < 0)
00536             return -1;
00537         avctx->delay=0;
00538         s->low_delay=1;
00539         break;
00540     case CODEC_ID_H261:
00541         if (!ENABLE_H261_ENCODER)  return -1;
00542         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
00543             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);
00544             return -1;
00545         }
00546         s->out_format = FMT_H261;
00547         avctx->delay=0;
00548         s->low_delay=1;
00549         break;
00550     case CODEC_ID_H263:
00551         if (!ENABLE_H263_ENCODER)  return -1;
00552         if (h263_get_picture_format(s->width, s->height) == 7) {
00553             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);
00554             return -1;
00555         }
00556         s->out_format = FMT_H263;
00557         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
00558         avctx->delay=0;
00559         s->low_delay=1;
00560         break;
00561     case CODEC_ID_H263P:
00562         s->out_format = FMT_H263;
00563         s->h263_plus = 1;
00564         /* Fx */
00565         s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
00566         s->h263_aic= (avctx->flags & CODEC_FLAG_AC_PRED) ? 1:0;
00567         s->modified_quant= s->h263_aic;
00568         s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
00569         s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
00570         s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
00571         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
00572         s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
00573 
00574         /* /Fx */
00575         /* These are just to be sure */
00576         avctx->delay=0;
00577         s->low_delay=1;
00578         break;
00579     case CODEC_ID_FLV1:
00580         s->out_format = FMT_H263;
00581         s->h263_flv = 2; /* format = 1; 11-bit codes */
00582         s->unrestricted_mv = 1;
00583         s->rtp_mode=0; /* don't allow GOB */
00584         avctx->delay=0;
00585         s->low_delay=1;
00586         break;
00587     case CODEC_ID_RV10:
00588         s->out_format = FMT_H263;
00589         avctx->delay=0;
00590         s->low_delay=1;
00591         break;
00592     case CODEC_ID_RV20:
00593         s->out_format = FMT_H263;
00594         avctx->delay=0;
00595         s->low_delay=1;
00596         s->modified_quant=1;
00597         s->h263_aic=1;
00598         s->h263_plus=1;
00599         s->loop_filter=1;
00600         s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
00601         break;
00602     case CODEC_ID_MPEG4:
00603         s->out_format = FMT_H263;
00604         s->h263_pred = 1;
00605         s->unrestricted_mv = 1;
00606         s->low_delay= s->max_b_frames ? 0 : 1;
00607         avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
00608         break;
00609     case CODEC_ID_MSMPEG4V1:
00610         s->out_format = FMT_H263;
00611         s->h263_msmpeg4 = 1;
00612         s->h263_pred = 1;
00613         s->unrestricted_mv = 1;
00614         s->msmpeg4_version= 1;
00615         avctx->delay=0;
00616         s->low_delay=1;
00617         break;
00618     case CODEC_ID_MSMPEG4V2:
00619         s->out_format = FMT_H263;
00620         s->h263_msmpeg4 = 1;
00621         s->h263_pred = 1;
00622         s->unrestricted_mv = 1;
00623         s->msmpeg4_version= 2;
00624         avctx->delay=0;
00625         s->low_delay=1;
00626         break;
00627     case CODEC_ID_MSMPEG4V3:
00628         s->out_format = FMT_H263;
00629         s->h263_msmpeg4 = 1;
00630         s->h263_pred = 1;
00631         s->unrestricted_mv = 1;
00632         s->msmpeg4_version= 3;
00633         s->flipflop_rounding=1;
00634         avctx->delay=0;
00635         s->low_delay=1;
00636         break;
00637     case CODEC_ID_WMV1:
00638         s->out_format = FMT_H263;
00639         s->h263_msmpeg4 = 1;
00640         s->h263_pred = 1;
00641         s->unrestricted_mv = 1;
00642         s->msmpeg4_version= 4;
00643         s->flipflop_rounding=1;
00644         avctx->delay=0;
00645         s->low_delay=1;
00646         break;
00647     case CODEC_ID_WMV2:
00648         s->out_format = FMT_H263;
00649         s->h263_msmpeg4 = 1;
00650         s->h263_pred = 1;
00651         s->unrestricted_mv = 1;
00652         s->msmpeg4_version= 5;
00653         s->flipflop_rounding=1;
00654         avctx->delay=0;
00655         s->low_delay=1;
00656         break;
00657     default:
00658         return -1;
00659     }
00660 
00661     avctx->has_b_frames= !s->low_delay;
00662 
00663     s->encoding = 1;
00664 
00665     /* init */
00666     if (MPV_common_init(s) < 0)
00667         return -1;
00668 
00669     if(!s->dct_quantize)
00670         s->dct_quantize = dct_quantize_c;
00671     if(!s->denoise_dct)
00672         s->denoise_dct = denoise_dct_c;
00673     s->fast_dct_quantize = s->dct_quantize;
00674     if(s->flags & CODEC_FLAG_TRELLIS_QUANT)
00675         s->dct_quantize = dct_quantize_trellis_c;
00676 
00677     if((ENABLE_H263P_ENCODER || ENABLE_RV20_ENCODER) && s->modified_quant)
00678         s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00679     s->progressive_frame=
00680     s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN));
00681     s->quant_precision=5;
00682 
00683     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
00684     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
00685 
00686     if (ENABLE_H261_ENCODER && s->out_format == FMT_H261)
00687         ff_h261_encode_init(s);
00688     if (ENABLE_ANY_H263_ENCODER && s->out_format == FMT_H263)
00689         h263_encode_init(s);
00690     if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version)
00691         ff_msmpeg4_encode_init(s);
00692     if ((ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER)
00693         && s->out_format == FMT_MPEG1)
00694         ff_mpeg1_encode_init(s);
00695 
00696     /* init q matrix */
00697     for(i=0;i<64;i++) {
00698         int j= s->dsp.idct_permutation[i];
00699         if(ENABLE_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
00700             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
00701             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
00702         }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
00703             s->intra_matrix[j] =
00704             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
00705         }else
00706         { /* mpeg1/2 */
00707             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
00708             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
00709         }
00710         if(s->avctx->intra_matrix)
00711             s->intra_matrix[j] = s->avctx->intra_matrix[i];
00712         if(s->avctx->inter_matrix)
00713             s->inter_matrix[j] = s->avctx->inter_matrix[i];
00714     }
00715 
00716     /* precompute matrix */
00717     /* for mjpeg, we do include qscale in the matrix */
00718     if (s->out_format != FMT_MJPEG) {
00719         ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
00720                        s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
00721         ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
00722                        s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
00723     }
00724 
00725     if(ff_rate_control_init(s) < 0)
00726         return -1;
00727 
00728     return 0;
00729 }
00730 
00731 int MPV_encode_end(AVCodecContext *avctx)
00732 {
00733     MpegEncContext *s = avctx->priv_data;
00734 
00735     ff_rate_control_uninit(s);
00736 
00737     MPV_common_end(s);
00738     if ((ENABLE_MJPEG_ENCODER || ENABLE_LJPEG_ENCODER) && s->out_format == FMT_MJPEG)
00739         ff_mjpeg_encode_close(s);
00740 
00741     av_freep(&avctx->extradata);
00742 
00743     return 0;
00744 }
00745 
00746 static int get_sae(uint8_t *src, int ref, int stride){
00747     int x,y;
00748     int acc=0;
00749 
00750     for(y=0; y<16; y++){
00751         for(x=0; x<16; x++){
00752             acc+= FFABS(src[x+y*stride] - ref);
00753         }
00754     }
00755 
00756     return acc;
00757 }
00758 
00759 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
00760     int x, y, w, h;
00761     int acc=0;
00762 
00763     w= s->width &~15;
00764     h= s->height&~15;
00765 
00766     for(y=0; y<h; y+=16){
00767         for(x=0; x<w; x+=16){
00768             int offset= x + y*stride;
00769             int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
00770             int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
00771             int sae = get_sae(src + offset, mean, stride);
00772 
00773             acc+= sae + 500 < sad;
00774         }
00775     }
00776     return acc;
00777 }
00778 
00779 
00780 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
00781     AVFrame *pic=NULL;
00782     int64_t pts;
00783     int i;
00784     const int encoding_delay= s->max_b_frames;
00785     int direct=1;
00786 
00787     if(pic_arg){
00788         pts= pic_arg->pts;
00789         pic_arg->display_picture_number= s->input_picture_number++;
00790 
00791         if(pts != AV_NOPTS_VALUE){
00792             if(s->user_specified_pts != AV_NOPTS_VALUE){
00793                 int64_t time= pts;
00794                 int64_t last= s->user_specified_pts;
00795 
00796                 if(time <= last){
00797                     av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
00798                     return -1;
00799                 }
00800             }
00801             s->user_specified_pts= pts;
00802         }else{
00803             if(s->user_specified_pts != AV_NOPTS_VALUE){
00804                 s->user_specified_pts=
00805                 pts= s->user_specified_pts + 1;
00806                 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
00807             }else{
00808                 pts= pic_arg->display_picture_number;
00809             }
00810         }
00811     }
00812 
00813   if(pic_arg){
00814     if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
00815     if(pic_arg->linesize[0] != s->linesize) direct=0;
00816     if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
00817     if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
00818 
00819 //    av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
00820 
00821     if(direct){
00822         i= ff_find_unused_picture(s, 1);
00823 
00824         pic= (AVFrame*)&s->picture[i];
00825         pic->reference= 3;
00826 
00827         for(i=0; i<4; i++){
00828             pic->data[i]= pic_arg->data[i];
00829             pic->linesize[i]= pic_arg->linesize[i];
00830         }
00831         alloc_picture(s, (Picture*)pic, 1);
00832     }else{
00833         i= ff_find_unused_picture(s, 0);
00834 
00835         pic= (AVFrame*)&s->picture[i];
00836         pic->reference= 3;
00837 
00838         alloc_picture(s, (Picture*)pic, 0);
00839 
00840         if(   pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
00841            && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
00842            && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
00843        // empty
00844         }else{
00845             int h_chroma_shift, v_chroma_shift;
00846             avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
00847 
00848             for(i=0; i<3; i++){
00849                 int src_stride= pic_arg->linesize[i];
00850                 int dst_stride= i ? s->uvlinesize : s->linesize;
00851                 int h_shift= i ? h_chroma_shift : 0;
00852                 int v_shift= i ? v_chroma_shift : 0;
00853                 int w= s->width >>h_shift;
00854                 int h= s->height>>v_shift;
00855                 uint8_t *src= pic_arg->data[i];
00856                 uint8_t *dst= pic->data[i];
00857 
00858                 if(!s->avctx->rc_buffer_size)
00859                     dst +=INPLACE_OFFSET;
00860 
00861                 if(src_stride==dst_stride)
00862                     memcpy(dst, src, src_stride*h);
00863                 else{
00864                     while(h--){
00865                         memcpy(dst, src, w);
00866                         dst += dst_stride;
00867                         src += src_stride;
00868                     }
00869                 }
00870             }
00871         }
00872     }
00873     copy_picture_attributes(s, pic, pic_arg);
00874     pic->pts= pts; //we set this here to avoid modifiying pic_arg
00875   }
00876 
00877     /* shift buffer entries */
00878     for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
00879         s->input_picture[i-1]= s->input_picture[i];
00880 
00881     s->input_picture[encoding_delay]= (Picture*)pic;
00882 
00883     return 0;
00884 }
00885 
00886 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
00887     int x, y, plane;
00888     int score=0;
00889     int64_t score64=0;
00890 
00891     for(plane=0; plane<3; plane++){
00892         const int stride= p->linesize[plane];
00893         const int bw= plane ? 1 : 2;
00894         for(y=0; y<s->mb_height*bw; y++){
00895             for(x=0; x<s->mb_width*bw; x++){
00896                 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
00897                 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);
00898 
00899                 switch(s->avctx->frame_skip_exp){
00900                     case 0: score= FFMAX(score, v); break;
00901                     case 1: score+= FFABS(v);break;
00902                     case 2: score+= v*v;break;
00903                     case 3: score64+= FFABS(v*v*(int64_t)v);break;
00904                     case 4: score64+= v*v*(int64_t)(v*v);break;
00905                 }
00906             }
00907         }
00908     }
00909 
00910     if(score) score64= score;
00911 
00912     if(score64 < s->avctx->frame_skip_threshold)
00913         return 1;
00914     if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
00915         return 1;
00916     return 0;
00917 }
00918 
00919 static int estimate_best_b_count(MpegEncContext *s){
00920     AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
00921     AVCodecContext *c= avcodec_alloc_context();
00922     AVFrame input[FF_MAX_B_FRAMES+2];
00923     const int scale= s->avctx->brd_scale;
00924     int i, j, out_size, p_lambda, b_lambda, lambda2;
00925     int outbuf_size= s->width * s->height; //FIXME
00926     uint8_t *outbuf= av_malloc(outbuf_size);
00927     int64_t best_rd= INT64_MAX;
00928     int best_b_count= -1;
00929 
00930     assert(scale>=0 && scale <=3);
00931 
00932 //    emms_c();
00933     p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
00934     b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
00935     if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
00936     lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
00937 
00938     c->width = s->width >> scale;
00939     c->height= s->height>> scale;
00940     c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
00941     c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
00942     c->mb_decision= s->avctx->mb_decision;
00943     c->me_cmp= s->avctx->me_cmp;
00944     c->mb_cmp= s->avctx->mb_cmp;
00945     c->me_sub_cmp= s->avctx->me_sub_cmp;
00946     c->pix_fmt = PIX_FMT_YUV420P;
00947     c->time_base= s->avctx->time_base;
00948     c->max_b_frames= s->max_b_frames;
00949 
00950     if (avcodec_open(c, codec) < 0)
00951         return -1;
00952 
00953     for(i=0; i<s->max_b_frames+2; i++){
00954         int ysize= c->width*c->height;
00955         int csize= (c->width/2)*(c->height/2);
00956         Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
00957 
00958         avcodec_get_frame_defaults(&input[i]);
00959         input[i].data[0]= av_malloc(ysize + 2*csize);
00960         input[i].data[1]= input[i].data[0] + ysize;
00961         input[i].data[2]= input[i].data[1] + csize;
00962         input[i].linesize[0]= c->width;
00963         input[i].linesize[1]=
00964         input[i].linesize[2]= c->width/2;
00965 
00966         if(pre_input_ptr && (!i || s->input_picture[i-1])) {
00967             pre_input= *pre_input_ptr;
00968 
00969             if(pre_input.type != FF_BUFFER_TYPE_SHARED && i) {
00970                 pre_input.data[0]+=INPLACE_OFFSET;
00971                 pre_input.data[1]+=INPLACE_OFFSET;
00972                 pre_input.data[2]+=INPLACE_OFFSET;
00973             }
00974 
00975             s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
00976             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);
00977             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);
00978         }
00979     }
00980 
00981     for(j=0; j<s->max_b_frames+1; j++){
00982         int64_t rd=0;
00983 
00984         if(!s->input_picture[j])
00985             break;
00986 
00987         c->error[0]= c->error[1]= c->error[2]= 0;
00988 
00989         input[0].pict_type= I_TYPE;
00990         input[0].quality= 1 * FF_QP2LAMBDA;
00991         out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
00992 //        rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
00993 
00994         for(i=0; i<s->max_b_frames+1; i++){
00995             int is_p= i % (j+1) == j || i==s->max_b_frames;
00996 
00997             input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
00998             input[i+1].quality= is_p ? p_lambda : b_lambda;
00999             out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
01000             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
01001         }
01002 
01003         /* get the delayed frames */
01004         while(out_size){
01005             out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
01006             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
01007         }
01008 
01009         rd += c->error[0] + c->error[1] + c->error[2];
01010 
01011         if(rd < best_rd){
01012             best_rd= rd;
01013             best_b_count= j;
01014         }
01015     }
01016 
01017     av_freep(&outbuf);
01018     avcodec_close(c);
01019     av_freep(&c);
01020 
01021     for(i=0; i<s->max_b_frames+2; i++){
01022         av_freep(&input[i].data[0]);
01023     }
01024 
01025     return best_b_count;
01026 }
01027 
01028 static void select_input_picture(MpegEncContext *s){
01029     int i;
01030 
01031     for(i=1; i<MAX_PICTURE_COUNT; i++)
01032         s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
01033     s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
01034 
01035     /* set next picture type & ordering */
01036     if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
01037         if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
01038             s->reordered_input_picture[0]= s->input_picture[0];
01039             s->reordered_input_picture[0]->pict_type= I_TYPE;
01040             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
01041         }else{
01042             int b_frames;
01043 
01044             if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
01045                 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
01046                 //FIXME check that te gop check above is +-1 correct
01047 //av_log(NULL, AV_LOG_DEBUG, "skip %p %"PRId64"\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
01048 
01049                     if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
01050                         for(i=0; i<4; i++)
01051                             s->input_picture[0]->data[i]= NULL;
01052                         s->input_picture[0]->type= 0;
01053                     }else{
01054                         assert(   s->input_picture[0]->type==FF_BUFFER_TYPE_USER
01055                                || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
01056 
01057                         s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
01058                     }
01059 
01060                     emms_c();
01061                     ff_vbv_update(s, 0);
01062 
01063                     goto no_output_pic;
01064                 }
01065             }
01066 
01067             if(s->flags&CODEC_FLAG_PASS2){
01068                 for(i=0; i<s->max_b_frames+1; i++){
01069                     int pict_num= s->input_picture[0]->display_picture_number + i;
01070 
01071                     if(pict_num >= s->rc_context.num_entries)
01072                         break;
01073                     if(!s->input_picture[i]){
01074                         s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
01075                         break;
01076                     }
01077 
01078                     s->input_picture[i]->pict_type=
01079                         s->rc_context.entry[pict_num].new_pict_type;
01080                 }
01081             }
01082 
01083             if(s->avctx->b_frame_strategy==0){
01084                 b_frames= s->max_b_frames;
01085                 while(b_frames && !s->input_picture[b_frames]) b_frames--;
01086             }else if(s->avctx->b_frame_strategy==1){
01087                 for(i=1; i<s->max_b_frames+1; i++){
01088                     if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
01089                         s->input_picture[i]->b_frame_score=
01090                             get_intra_count(s, s->input_picture[i  ]->data[0],
01091                                                s->input_picture[i-1]->data[0], s->linesize) + 1;
01092                     }
01093                 }
01094                 for(i=0; i<s->max_b_frames+1; i++){
01095                     if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
01096                 }
01097 
01098                 b_frames= FFMAX(0, i-1);
01099 
01100                 /* reset scores */
01101                 for(i=0; i<b_frames+1; i++){
01102                     s->input_picture[i]->b_frame_score=0;
01103                 }
01104             }else if(s->avctx->b_frame_strategy==2){
01105                 b_frames= estimate_best_b_count(s);
01106             }else{
01107                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
01108                 b_frames=0;
01109             }
01110 
01111             emms_c();
01112 //static int b_count=0;
01113 //b_count+= b_frames;
01114 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
01115 
01116             for(i= b_frames - 1; i>=0; i--){
01117                 int type= s->input_picture[i]->pict_type;
01118                 if(type && type != B_TYPE)
01119                     b_frames= i;
01120             }
01121             if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
01122                 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
01123             }
01124 
01125             if(s->picture_in_gop_number + b_frames >= s->gop_size){
01126               if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
01127                     b_frames= s->gop_size - s->picture_in_gop_number - 1;
01128               }else{
01129                 if(s->flags & CODEC_FLAG_CLOSED_GOP)
01130                     b_frames=0;
01131                 s->input_picture[b_frames]->pict_type= I_TYPE;
01132               }
01133             }
01134 
01135             if(   (s->flags & CODEC_FLAG_CLOSED_GOP)
01136                && b_frames
01137                && s->input_picture[b_frames]->pict_type== I_TYPE)
01138                 b_frames--;
01139 
01140             s->reordered_input_picture[0]= s->input_picture[b_frames];
01141             if(s->reordered_input_picture[0]->pict_type != I_TYPE)
01142                 s->reordered_input_picture[0]->pict_type= P_TYPE;
01143             s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
01144             for(i=0; i<b_frames; i++){
01145                 s->reordered_input_picture[i+1]= s->input_picture[i];
01146                 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
01147                 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
01148             }
01149         }
01150     }
01151 no_output_pic:
01152     if(s->reordered_input_picture[0]){
01153         s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
01154 
01155         copy_picture(&s->new_picture, s->reordered_input_picture[0]);
01156 
01157         if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED || s->avctx->rc_buffer_size){
01158             // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
01159 
01160             int i= ff_find_unused_picture(s, 0);
01161             Picture *pic= &s->picture[i];
01162 
01163             pic->reference              = s->reordered_input_picture[0]->reference;
01164             alloc_picture(s, pic, 0);
01165 
01166             /* mark us unused / free shared pic */
01167             if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_INTERNAL)
01168                 s->avctx->release_buffer(s->avctx, (AVFrame*)s->reordered_input_picture[0]);
01169             for(i=0; i<4; i++)
01170                 s->reordered_input_picture[0]->data[i]= NULL;
01171             s->reordered_input_picture[0]->type= 0;
01172 
01173             copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
01174 
01175             s->current_picture_ptr= pic;
01176         }else{
01177             // input is not a shared pix -> reuse buffer for current_pix
01178 
01179             assert(   s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
01180                    || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
01181 
01182             s->current_picture_ptr= s->reordered_input_picture[0];
01183             for(i=0; i<4; i++){
01184                 s->new_picture.data[i]+= INPLACE_OFFSET;
01185             }
01186         }
01187         copy_picture(&s->current_picture, s->current_picture_ptr);
01188 
01189         s->picture_number= s->new_picture.display_picture_number;
01190 //printf("dpn:%d\n", s->picture_number);
01191     }else{
01192        memset(&s->new_picture, 0, sizeof(Picture));
01193     }
01194 }
01195 
01196 int MPV_encode_picture(AVCodecContext *avctx,
01197                        unsigned char *buf, int buf_size, void *data)
01198 {
01199     MpegEncContext *s = avctx->priv_data;
01200     AVFrame *pic_arg = data;
01201     int i, stuffing_count;
01202 
01203     for(i=0; i<avctx->thread_count; i++){
01204         int start_y= s->thread_context[i]->start_mb_y;
01205         int   end_y= s->thread_context[i]->  end_mb_y;
01206         int h= s->mb_height;
01207         uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
01208         uint8_t *end  = buf + (size_t)(((int64_t) buf_size)*  end_y/h);
01209 
01210         init_put_bits(&s->thread_context[i]->pb, start, end - start);
01211     }
01212 
01213     s->picture_in_gop_number++;
01214 
01215     if(load_input_picture(s, pic_arg) < 0)
01216         return -1;
01217 
01218     select_input_picture(s);
01219 
01220     /* output? */
01221     if(s->new_picture.data[0]){
01222         s->pict_type= s->new_picture.pict_type;
01223 //emms_c();
01224 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
01225         MPV_frame_start(s, avctx);
01226 vbv_retry:
01227         if (encode_picture(s, s->picture_number) < 0)
01228             return -1;
01229 
01230         avctx->real_pict_num  = s->picture_number;
01231         avctx->header_bits = s->header_bits;
01232         avctx->mv_bits     = s->mv_bits;
01233         avctx->misc_bits   = s->misc_bits;
01234         avctx->i_tex_bits  = s->i_tex_bits;
01235         avctx->p_tex_bits  = s->p_tex_bits;
01236         avctx->i_count     = s->i_count;
01237         avctx->p_count     = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
01238         avctx->skip_count  = s->skip_count;
01239 
01240         MPV_frame_end(s);
01241 
01242         if (ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
01243             ff_mjpeg_encode_picture_trailer(s);
01244 
01245         if(avctx->rc_buffer_size){
01246             RateControlContext *rcc= &s->rc_context;
01247             int max_size= rcc->buffer_index/3;
01248 
01249             if(put_bits_count(&s->pb) > max_size && s->lambda < s->avctx->lmax){
01250                 s->next_lambda= FFMAX(s->lambda+1, s->lambda*(s->qscale+1) / s->qscale);
01251                 if(s->adaptive_quant){
01252                     int i;
01253                     for(i=0; i<s->mb_height*s->mb_stride; i++)
01254                         s->lambda_table[i]= FFMAX(s->lambda_table[i]+1, s->lambda_table[i]*(s->qscale+1) / s->qscale);
01255                 }
01256                 s->mb_skipped = 0;        //done in MPV_frame_start()
01257                 if(s->pict_type==P_TYPE){ //done in encode_picture() so we must undo it
01258                     if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
01259                         s->no_rounding ^= 1;
01260                 }
01261                 if(s->pict_type!=B_TYPE){
01262                     s->time_base= s->last_time_base;
01263                     s->last_non_b_time= s->time - s->pp_time;
01264                 }
01265 //                av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
01266                 for(i=0; i<avctx->thread_count; i++){
01267                     PutBitContext *pb= &s->thread_context[i]->pb;
01268                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
01269                 }
01270                 goto vbv_retry;
01271             }
01272 
01273             assert(s->avctx->rc_max_rate);
01274         }
01275 
01276         if(s->flags&CODEC_FLAG_PASS1)
01277             ff_write_pass1_stats(s);
01278 
01279         for(i=0; i<4; i++){
01280             s->current_picture_ptr->error[i]= s->current_picture.error[i];
01281             avctx->error[i] += s->current_picture_ptr->error[i];
01282         }
01283 
01284         if(s->flags&CODEC_FLAG_PASS1)
01285             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
01286         flush_put_bits(&s->pb);
01287         s->frame_bits  = put_bits_count(&s->pb);
01288 
01289         stuffing_count= ff_vbv_update(s, s->frame_bits);
01290         if(stuffing_count){
01291             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
01292                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
01293                 return -1;
01294             }
01295 
01296             switch(s->codec_id){
01297             case CODEC_ID_MPEG1VIDEO:
01298             case CODEC_ID_MPEG2VIDEO:
01299                 while(stuffing_count--){
01300                     put_bits(&s->pb, 8, 0);
01301                 }
01302             break;
01303             case CODEC_ID_MPEG4:
01304                 put_bits(&s->pb, 16, 0);
01305                 put_bits(&s->pb, 16, 0x1C3);
01306                 stuffing_count -= 4;
01307                 while(stuffing_count--){
01308                     put_bits(&s->pb, 8, 0xFF);
01309                 }
01310             break;
01311             default:
01312                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
01313             }
01314             flush_put_bits(&s->pb);
01315             s->frame_bits  = put_bits_count(&s->pb);
01316         }
01317 
01318         /* update mpeg1/2 vbv_delay for CBR */
01319         if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
01320            && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
01321             int vbv_delay;
01322 
01323             assert(s->repeat_first_field==0);
01324 
01325             vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
01326             assert(vbv_delay < 0xFFFF);
01327 
01328             s->vbv_delay_ptr[0] &= 0xF8;
01329             s->vbv_delay_ptr[0] |= vbv_delay>>13;
01330             s->vbv_delay_ptr[1]  = vbv_delay>>5;
01331             s->vbv_delay_ptr[2] &= 0x07;
01332             s->vbv_delay_ptr[2] |= vbv_delay<<3;
01333         }
01334         s->total_bits += s->frame_bits;
01335         avctx->frame_bits  = s->frame_bits;
01336     }else{
01337         assert((pbBufPtr(&s->pb) == s->pb.buf));
01338         s->frame_bits=0;
01339     }
01340     assert((s->frame_bits&7)==0);
01341 
01342     return s->frame_bits/8;
01343 }
01344 
01345 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
01346 {
01347     static const char tab[64]=
01348         {3,2,2,1,1,1,1,1,
01349          1,1,1,1,1,1,1,1,
01350          1,1,1,1,1,1,1,1,
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          0,0,0,0,0,0,0,0,
01355          0,0,0,0,0,0,0,0};
01356     int score=0;
01357     int run=0;
01358     int i;
01359     DCTELEM *block= s->block[n];
01360     const int last_index= s->block_last_index[n];
01361     int skip_dc;
01362 
01363     if(threshold<0){
01364         skip_dc=0;
01365         threshold= -threshold;
01366     }else
01367         skip_dc=1;
01368 
01369     /* are all which we could set to zero are allready zero? */
01370     if(last_index<=skip_dc - 1) return;
01371 
01372     for(i=0; i<=last_index; i++){
01373         const int j = s->intra_scantable.permutated[i];
01374         const int level = FFABS(block[j]);
01375         if(level==1){
01376             if(skip_dc && i==0) continue;
01377             score+= tab[run];
01378             run=0;
01379         }else if(level>1){
01380             return;
01381         }else{
01382             run++;
01383         }
01384     }
01385     if(score >= threshold) return;
01386     for(i=skip_dc; i<=last_index; i++){
01387         const int j = s->intra_scantable.permutated[i];
01388         block[j]=0;
01389     }
01390     if(block[0]) s->block_last_index[n]= 0;
01391     else         s->block_last_index[n]= -1;
01392 }
01393 
01394 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
01395 {
01396     int i;
01397     const int maxlevel= s->max_qcoeff;
01398     const int minlevel= s->min_qcoeff;
01399     int overflow=0;
01400 
01401     if(s->mb_intra){
01402         i=1; //skip clipping of intra dc
01403     }else
01404         i=0;
01405 
01406     for(;i<=last_index; i++){
01407         const int j= s->intra_scantable.permutated[i];
01408         int level = block[j];
01409 
01410         if     (level>maxlevel){
01411             level=maxlevel;
01412             overflow++;
01413         }else if(level<minlevel){
01414             level=minlevel;
01415             overflow++;
01416         }
01417 
01418         block[j]= level;
01419     }
01420 
01421     if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
01422         av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
01423 }
01424 
01425 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride){
01426     int x, y;
01427 //FIXME optimize
01428     for(y=0; y<8; y++){
01429         for(x=0; x<8; x++){
01430             int x2, y2;
01431             int sum=0;
01432             int sqr=0;
01433             int count=0;
01434 
01435             for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
01436                 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
01437                     int v= ptr[x2 + y2*stride];
01438                     sum += v;
01439                     sqr += v*v;
01440                     count++;
01441                 }
01442             }
01443             weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
01444         }
01445     }
01446 }
01447 
01448 static av_always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
01449 {
01450     int16_t weight[8][64];
01451     DCTELEM orig[8][64];
01452     const int mb_x= s->mb_x;
01453     const int mb_y= s->mb_y;
01454     int i;
01455     int skip_dct[8];
01456     int dct_offset   = s->linesize*8; //default for progressive frames
01457     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
01458     int wrap_y, wrap_c;
01459 
01460     for(i=0; i<mb_block_count; i++) skip_dct[i]=s->skipdct;
01461 
01462     if(s->adaptive_quant){
01463         const int last_qp= s->qscale;
01464         const int mb_xy= mb_x + mb_y*s->mb_stride;
01465 
01466         s->lambda= s->lambda_table[mb_xy];
01467         update_qscale(s);
01468 
01469         if(!(s->flags&CODEC_FLAG_QP_RD)){
01470             s->qscale= s->current_picture_ptr->qscale_table[mb_xy];
01471             s->dquant= s->qscale - last_qp;
01472 
01473             if(s->out_format==FMT_H263){
01474                 s->dquant= av_clip(s->dquant, -2, 2);
01475 
01476                 if(s->codec_id==CODEC_ID_MPEG4){
01477                     if(!s->mb_intra){
01478                         if(s->pict_type == B_TYPE){
01479                             if(s->dquant&1 || s->mv_dir&MV_DIRECT)
01480                                 s->dquant= 0;
01481                         }
01482                         if(s->mv_type==MV_TYPE_8X8)
01483                             s->dquant=0;
01484                     }
01485                 }
01486             }
01487         }
01488         ff_set_qscale(s, last_qp + s->dquant);
01489     }else if(s->flags&CODEC_FLAG_QP_RD)
01490         ff_set_qscale(s, s->qscale + s->dquant);
01491 
01492     wrap_y = s->linesize;
01493     wrap_c = s->uvlinesize;
01494     ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
01495     ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
01496     ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
01497 
01498     if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
01499         uint8_t *ebuf= s->edge_emu_buffer + 32;
01500         ff_emulated_edge_mc(ebuf            , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width   , s->height);
01501         ptr_y= ebuf;
01502         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);
01503         ptr_cb= ebuf+18*wrap_y;
01504         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);
01505         ptr_cr= ebuf+18*wrap_y+8;
01506     }
01507 
01508     if (s->mb_intra) {
01509         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
01510             int progressive_score, interlaced_score;
01511 
01512             s->interlaced_dct=0;
01513             progressive_score= s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y, 8)
01514                               +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
01515 
01516             if(progressive_score > 0){
01517                 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y           , NULL, wrap_y*2, 8)
01518                                   +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y  , NULL, wrap_y*2, 8);
01519                 if(progressive_score > interlaced_score){
01520                     s->interlaced_dct=1;
01521 
01522                     dct_offset= wrap_y;
01523                     wrap_y<<=1;
01524                     if (s->chroma_format == CHROMA_422)
01525                         wrap_c<<=1;
01526                 }
01527             }
01528         }
01529 
01530         s->dsp.get_pixels(s->block[0], ptr_y                 , wrap_y);
01531         s->dsp.get_pixels(s->block[1], ptr_y              + 8, wrap_y);
01532         s->dsp.get_pixels(s->block[2], ptr_y + dct_offset    , wrap_y);
01533         s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
01534 
01535         if(s->flags&CODEC_FLAG_GRAY){
01536             skip_dct[4]= 1;
01537             skip_dct[5]= 1;
01538         }else{
01539             s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
01540             s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
01541             if(!s->chroma_y_shift){ /* 422 */
01542                 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
01543                 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
01544             }
01545         }
01546     }else{
01547         op_pixels_func (*op_pix)[4];
01548         qpel_mc_func (*op_qpix)[16];
01549         uint8_t *dest_y, *dest_cb, *dest_cr;
01550 
01551         dest_y  = s->dest[0];
01552         dest_cb = s->dest[1];
01553         dest_cr = s->dest[2];
01554 
01555         if ((!s->no_rounding) || s->pict_type==B_TYPE){
01556             op_pix = s->dsp.put_pixels_tab;
01557             op_qpix= s->dsp.put_qpel_pixels_tab;
01558         }else{
01559             op_pix = s->dsp.put_no_rnd_pixels_tab;
01560             op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
01561         }
01562 
01563         if (s->mv_dir & MV_DIR_FORWARD) {
01564             MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
01565             op_pix = s->dsp.avg_pixels_tab;
01566             op_qpix= s->dsp.avg_qpel_pixels_tab;
01567         }
01568         if (s->mv_dir & MV_DIR_BACKWARD) {
01569             MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
01570         }
01571 
01572         if(s->flags&CODEC_FLAG_INTERLACED_DCT){
01573             int progressive_score, interlaced_score;
01574 
01575             s->interlaced_dct=0;
01576             progressive_score= s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y, 8)
01577                               +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
01578 
01579             if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
01580 
01581             if(progressive_score>0){
01582                 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y           , ptr_y           , wrap_y*2, 8)
01583                                   +s->dsp.ildct_cmp[0](s, dest_y + wrap_y  , ptr_y + wrap_y  , wrap_y*2, 8);
01584 
01585                 if(progressive_score > interlaced_score){
01586                     s->interlaced_dct=1;
01587 
01588                     dct_offset= wrap_y;
01589                     wrap_y<<=1;
01590                     if (s->chroma_format == CHROMA_422)
01591                         wrap_c<<=1;
01592                 }
01593             }
01594         }
01595 
01596         s->dsp.diff_pixels(s->block[0], ptr_y                 , dest_y                 , wrap_y);
01597         s->dsp.diff_pixels(s->block[1], ptr_y              + 8, dest_y              + 8, wrap_y);
01598         s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset    , dest_y + dct_offset    , wrap_y);
01599         s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
01600 
01601         if(s->flags&CODEC_FLAG_GRAY){
01602             skip_dct[4]= 1;
01603             skip_dct[5]= 1;
01604         }else{
01605             s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
01606             s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
01607             if(!s->chroma_y_shift){ /* 422 */
01608                 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
01609                 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
01610             }
01611         }
01612         /* pre quantization */
01613         if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
01614             //FIXME optimize
01615             if(s->dsp.sad[1](NULL, ptr_y               , dest_y               , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
01616             if(s->dsp.sad[1](NULL, ptr_y            + 8, dest_y            + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
01617             if(s->dsp.sad[1](NULL, ptr_y +dct_offset   , dest_y +dct_offset   , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
01618             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;
01619             if(s->dsp.sad[1](NULL, ptr_cb              , dest_cb              , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
01620             if(s->dsp.sad[1](NULL, ptr_cr              , dest_cr              , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
01621             if(!s->chroma_y_shift){ /* 422 */
01622                 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;
01623                 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;
01624             }
01625         }
01626     }
01627 
01628     if(s->avctx->quantizer_noise_shaping){
01629         if(!skip_dct[0]) get_visual_weight(weight[0], ptr_y                 , wrap_y);
01630         if(!skip_dct[1]) get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
01631         if(!skip_dct[2]) get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
01632         if(!skip_dct[3]) get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
01633         if(!skip_dct[4]) get_visual_weight(weight[4], ptr_cb                , wrap_c);
01634         if(!skip_dct[5]) get_visual_weight(weight[5], ptr_cr                , wrap_c);
01635         if(!s->chroma_y_shift){ /* 422 */
01636             if(!skip_dct[6]) get_visual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
01637             if(!skip_dct[7]) get_visual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
01638         }
01639         memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
01640     }
01641 
01642     /* DCT & quantize */
01643     assert(s->out_format!=FMT_MJPEG || s->qscale==8);
01644     {
01645         for(i=0;i<mb_block_count;i++) {
01646             if(!skip_dct[i]){
01647                 int overflow;
01648                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
01649             // FIXME we could decide to change to quantizer instead of clipping
01650             // JS: I don't think that would be a good idea it could lower quality instead
01651             //     of improve it. Just INTRADC clipping deserves changes in quantizer
01652                 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
01653             }else
01654                 s->block_last_index[i]= -1;
01655         }
01656         if(s->avctx->quantizer_noise_shaping){
01657             for(i=0;i<mb_block_count;i++) {
01658                 if(!skip_dct[i]){
01659                     s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
01660                 }
01661             }
01662         }
01663 
01664         if(s->luma_elim_threshold && !s->mb_intra)
01665             for(i=0; i<4; i++)
01666                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
01667         if(s->chroma_elim_threshold && !s->mb_intra)
01668             for(i=4; i<mb_block_count; i++)
01669                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
01670 
01671         if(s->flags & CODEC_FLAG_CBP_RD){
01672             for(i=0;i<mb_block_count;i++) {
01673                 if(s->block_last_index[i] == -1)
01674                     s->coded_score[i]= INT_MAX/256;
01675             }
01676         }
01677     }
01678 
01679     if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
01680         s->block_last_index[4]=
01681         s->block_last_index[5]= 0;
01682         s->block[4][0]=
01683         s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
01684     }
01685 
01686     //non c quantize code returns incorrect block_last_index FIXME
01687     if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
01688         for(i=0; i<mb_block_count; i++){
01689             int j;
01690             if(s->block_last_index[i]>0){
01691                 for(j=63; j>0; j--){
01692                     if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
01693                 }
01694                 s->block_last_index[i]= j;
01695             }
01696         }
01697     }
01698 
01699     /* huffman encode */
01700     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
01701     case CODEC_ID_MPEG1VIDEO:
01702     case CODEC_ID_MPEG2VIDEO:
01703         if (ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER)
01704             mpeg1_encode_mb(s, s->block, motion_x, motion_y);
01705         break;
01706     case CODEC_ID_MPEG4:
01707         if (ENABLE_MPEG4_ENCODER)
01708             mpeg4_encode_mb(s, s->block, motion_x, motion_y);
01709         break;
01710     case CODEC_ID_MSMPEG4V2:
01711     case CODEC_ID_MSMPEG4V3:
01712     case CODEC_ID_WMV1:
01713         if (ENABLE_MSMPEG4_ENCODER)
01714             msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
01715         break;
01716     case CODEC_ID_WMV2:
01717         if (ENABLE_WMV2_ENCODER)
01718             ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
01719         break;
01720     case CODEC_ID_H261:
01721         if (ENABLE_H261_ENCODER)
01722             ff_h261_encode_mb(s, s->block, motion_x, motion_y);
01723         break;
01724     case CODEC_ID_H263:
01725     case CODEC_ID_H263P:
01726     case CODEC_ID_FLV1:
01727     case CODEC_ID_RV10:
01728     case CODEC_ID_RV20:
01729         if (ENABLE_H263_ENCODER || ENABLE_H263P_ENCODER ||
01730             ENABLE_FLV_ENCODER  || ENABLE_RV10_ENCODER  || ENABLE_RV20_ENCODER)
01731             h263_encode_mb(s, s->block, motion_x, motion_y);
01732         break;
01733     case CODEC_ID_MJPEG:
01734         if (ENABLE_MJPEG_ENCODER)
01735             ff_mjpeg_encode_mb(s, s->block);
01736         break;
01737     default:
01738         assert(0);
01739     }
01740 }
01741 
01742 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
01743 {
01744     if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
01745     else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
01746 }
01747 
01748 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
01749     int i;
01750 
01751     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
01752 
01753     /* mpeg1 */
01754     d->mb_skip_run= s->mb_skip_run;
01755     for(i=0; i<3; i++)
01756         d->last_dc[i]= s->last_dc[i];
01757 
01758     /* statistics */
01759     d->mv_bits= s->mv_bits;
01760     d->i_tex_bits= s->i_tex_bits;
01761     d->p_tex_bits= s->p_tex_bits;
01762     d->i_count= s->i_count;
01763     d->f_count= s->f_count;
01764     d->b_count= s->b_count;
01765     d->skip_count= s->skip_count;
01766     d->misc_bits= s->misc_bits;
01767     d->last_bits= 0;
01768 
01769     d->mb_skipped= 0;
01770     d->qscale= s->qscale;
01771     d->dquant= s->dquant;
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)); //FIXME is memcpy faster then a loop?
01779 
01780     /* mpeg1 */
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     /* statistics */
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 
01811 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
01812                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
01813                            int *dmin, int *next_block, int motion_x, int motion_y)
01814 {
01815     int score;
01816     uint8_t *dest_backup[3];
01817 
01818     copy_context_before_encode(s, backup, type);
01819 
01820     s->block= s->blocks[*next_block];
01821     s->pb= pb[*next_block];
01822     if(s->data_partitioning){
01823         s->pb2   = pb2   [*next_block];
01824         s->tex_pb= tex_pb[*next_block];
01825     }
01826 
01827     if(*next_block){
01828         memcpy(dest_backup, s->dest, sizeof(s->dest));
01829         s->dest[0] = s->rd_scratchpad;
01830         s->dest[1] = s->rd_scratchpad + 16*s->linesize;
01831         s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
01832         assert(s->linesize >= 32); //FIXME
01833     }
01834 
01835     encode_mb(s, motion_x, motion_y);
01836 
01837     score= put_bits_count(&s->pb);
01838     if(s->data_partitioning){
01839         score+= put_bits_count(&s->pb2);
01840         score+= put_bits_count(&s->tex_pb);
01841     }
01842 
01843     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
01844         MPV_decode_mb(s, s->block);
01845 
01846         score *= s->lambda2;
01847         score += sse_mb(s) << FF_LAMBDA_SHIFT;
01848     }
01849 
01850     if(*next_block){
01851         memcpy(s->dest, dest_backup, sizeof(s->dest));
01852     }
01853 
01854     if(score<*dmin){
01855         *dmin= score;
01856         *next_block^=1;
01857 
01858         copy_context_after_encode(best, s, type);
01859     }
01860 }
01861 
01862 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
01863     uint32_t *sq = ff_squareTbl + 256;
01864     int acc=0;
01865     int x,y;
01866 
01867     if(w==16 && h==16)
01868         return s->dsp.sse[0](NULL, src1, src2, stride, 16);
01869     else if(w==8 && h==8)
01870         return s->dsp.sse[1](NULL, src1, src2, stride, 8);
01871 
01872     for(y=0; y<h; y++){
01873         for(x=0; x<w; x++){
01874             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
01875         }
01876     }
01877 
01878     assert(acc>=0);
01879 
01880     return acc;
01881 }
01882 
01883 static int sse_mb(MpegEncContext *s){
01884     int w= 16;
01885     int h= 16;
01886 
01887     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
01888     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
01889 
01890     if(w==16 && h==16)
01891       if(s->avctx->mb_cmp == FF_CMP_NSSE){
01892         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)
01893                +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)
01894                +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);
01895       }else{
01896         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)
01897                +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)
01898                +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);
01899       }
01900     else
01901         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)
01902                +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)
01903                +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);
01904 }
01905 
01906 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
01907     MpegEncContext *s= arg;
01908 
01909 
01910     s->me.pre_pass=1;
01911     s->me.dia_size= s->avctx->pre_dia_size;
01912     s->first_slice_line=1;
01913     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
01914         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
01915             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
01916         }
01917         s->first_slice_line=0;
01918     }
01919 
01920     s->me.pre_pass=0;
01921 
01922     return 0;
01923 }
01924 
01925 static int estimate_motion_thread(AVCodecContext *c, void *arg){
01926     MpegEncContext *s= arg;
01927 
01928     ff_check_alignment();
01929 
01930     s->me.dia_size= s->avctx->dia_size;
01931     s->first_slice_line=1;
01932     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
01933         s->mb_x=0; //for block init below
01934         ff_init_block_index(s);
01935         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
01936             s->block_index[0]+=2;
01937             s->block_index[1]+=2;
01938             s->block_index[2]+=2;
01939             s->block_index[3]+=2;
01940 
01941             /* compute motion vector & mb_type and store in context */
01942             if(s->pict_type==B_TYPE)
01943                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
01944             else
01945                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
01946         }
01947         s->first_slice_line=0;
01948     }
01949     return 0;
01950 }
01951 
01952 static int mb_var_thread(AVCodecContext *c, void *arg){
01953     MpegEncContext *s= arg;
01954     int mb_x, mb_y;
01955 
01956     ff_check_alignment();
01957 
01958     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
01959         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
01960             int xx = mb_x * 16;
01961             int yy = mb_y * 16;
01962             uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
01963             int varc;
01964             int sum = s->dsp.pix_sum(pix, s->linesize);
01965 
01966             varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
01967 
01968             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
01969             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
01970             s->me.mb_var_sum_temp    += varc;
01971         }
01972     }
01973     return 0;
01974 }
01975 
01976 static void write_slice_end(MpegEncContext *s){
01977     if(ENABLE_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4){
01978         if(s->partitioned_frame){
01979             ff_mpeg4_merge_partitions(s);
01980         }
01981 
01982         ff_mpeg4_stuffing(&s->pb);
01983     }else if(ENABLE_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
01984         ff_mjpeg_encode_stuffing(&s->pb);
01985     }
01986 
01987     align_put_bits(&s->pb);
01988     flush_put_bits(&s->pb);
01989 
01990     if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
01991         s->misc_bits+= get_bits_diff(s);
01992 }
01993 
01994 static int encode_thread(AVCodecContext *c, void *arg){
01995     MpegEncContext *s= arg;
01996     int mb_x, mb_y, pdif = 0;
01997     int i, j;
01998     MpegEncContext best_s, backup_s;
01999     uint8_t bit_buf[2][MAX_MB_BYTES];
02000     uint8_t bit_buf2[2][MAX_MB_BYTES];
02001     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
02002     PutBitContext pb[2], pb2[2], tex_pb[2];
02003 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
02004 
02005     ff_check_alignment();
02006 
02007     for(i=0; i<2; i++){
02008         init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
02009         init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
02010         init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
02011     }
02012 
02013     s->last_bits= put_bits_count(&s->pb);
02014     s->mv_bits=0;
02015     s->misc_bits=0;
02016     s->i_tex_bits=0;
02017     s->p_tex_bits=0;
02018     s->i_count=0;
02019     s->f_count=0;
02020     s->b_count=0;
02021     s->skip_count=0;
02022 
02023     for(i=0; i<3; i++){
02024         /* init last dc values */
02025         /* note: quant matrix value (8) is implied here */
02026         s->last_dc[i] = 128 << s->intra_dc_precision;
02027 
02028         s->current_picture.error[i] = 0;
02029     }
02030     s->mb_skip_run = 0;
02031     memset(s->last_mv, 0, sizeof(s->last_mv));
02032 
02033     s->last_mv_dir = 0;
02034 
02035     switch(s->codec_id){
02036     case CODEC_ID_H263:
02037     case CODEC_ID_H263P:
02038     case CODEC_ID_FLV1:
02039         if (ENABLE_H263_ENCODER || ENABLE_H263P_ENCODER || ENABLE_FLV_ENCODER)
02040             s->gob_index = ff_h263_get_gob_height(s);
02041         break;
02042     case CODEC_ID_MPEG4:
02043         if(ENABLE_MPEG4_ENCODER && s->partitioned_frame)
02044             ff_mpeg4_init_partitions(s);
02045         break;
02046     }
02047 
02048     s->resync_mb_x=0;
02049     s->resync_mb_y=0;
02050     s->first_slice_line = 1;
02051     s->ptr_lastgob = s->pb.buf;
02052     for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
02053 //    printf("row %d at %X\n", s->mb_y, (int)s);
02054         s->mb_x=0;
02055         s->mb_y= mb_y;
02056 
02057         ff_set_qscale(s, s->qscale);
02058         ff_init_block_index(s);
02059 
02060         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
02061             int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
02062             int mb_type= s->mb_type[xy];
02063 //            int d;
02064             int dmin= INT_MAX;
02065             int dir;
02066 
02067             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
02068                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
02069                 return -1;
02070             }
02071             if(s->data_partitioning){
02072                 if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
02073                    || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
02074                     av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
02075                     return -1;
02076                 }
02077             }
02078 
02079             s->mb_x = mb_x;
02080             s->mb_y = mb_y;  // moved into loop, can get changed by H.261
02081             ff_update_block_index(s);
02082 
02083             if(ENABLE_H261_ENCODER && s->codec_id == CODEC_ID_H261){
02084                 ff_h261_reorder_mb_index(s);
02085                 xy= s->mb_y*s->mb_stride + s->mb_x;
02086                 mb_type= s->mb_type[xy];
02087             }
02088 
02089             /* write gob / video packet header  */
02090             if(s->rtp_mode){
02091                 int current_packet_size, is_gob_start;
02092 
02093                 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
02094 
02095                 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
02096 
02097                 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
02098 
02099                 switch(s->codec_id){
02100                 case CODEC_ID_H263:
02101                 case CODEC_ID_H263P:
02102                     if(!s->h263_slice_structured)
02103                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
02104                     break;
02105                 case CODEC_ID_MPEG2VIDEO:
02106                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
02107                 case CODEC_ID_MPEG1VIDEO:
02108                     if(s->mb_skip_run) is_gob_start=0;
02109                     break;
02110                 }
02111 
02112                 if(is_gob_start){
02113                     if(s->start_mb_y != mb_y || mb_x!=0){
02114                         write_slice_end(s);
02115 
02116                         if(ENABLE_MPEG4_ENCODER && s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
02117                             ff_mpeg4_init_partitions(s);
02118                         }
02119                     }
02120 
02121                     assert((put_bits_count(&s->pb)&7) == 0);
02122                     current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
02123 
02124                     if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
02125                         int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
02126                         int d= 100 / s->avctx->error_rate;
02127                         if(r % d == 0){
02128                             current_packet_size=0;
02129 #ifndef ALT_BITSTREAM_WRITER
02130                             s->pb.buf_ptr= s->ptr_lastgob;
02131 #endif
02132                             assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
02133                         }
02134                     }
02135 
02136                     if (s->avctx->rtp_callback){
02137                         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
02138                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
02139                     }
02140 
02141                     switch(s->codec_id){
02142                     case CODEC_ID_MPEG4:
02143                         if (ENABLE_MPEG4_ENCODER) {
02144                             ff_mpeg4_encode_video_packet_header(s);
02145                             ff_mpeg4_clean_buffers(s);
02146                         }
02147                     break;
02148                     case CODEC_ID_MPEG1VIDEO:
02149                     case CODEC_ID_MPEG2VIDEO:
02150                         if (ENABLE_MPEG1VIDEO_ENCODER || ENABLE_MPEG2VIDEO_ENCODER) {
02151                             ff_mpeg1_encode_slice_header(s);
02152                             ff_mpeg1_clean_buffers(s);
02153                         }
02154                     break;
02155                     case CODEC_ID_H263:
02156                     case CODEC_ID_H263P:
02157                         if (ENABLE_H263_ENCODER || ENABLE_H263P_ENCODER)
02158                             h263_encode_gob_header(s, mb_y);
02159                     break;
02160                     }
02161 
02162                     if(s->flags&CODEC_FLAG_PASS1){
02163                         int bits= put_bits_count(&s->pb);
02164                         s->misc_bits+= bits - s->last_bits;
02165                         s->last_bits= bits;
02166                     }
02167 
02168                     s->ptr_lastgob += current_packet_size;
02169                     s->first_slice_line=1;
02170                     s->resync_mb_x=mb_x;
02171                     s->resync_mb_y=mb_y;
02172                 }
02173             }
02174 
02175             if(  (s->resync_mb_x   == s->mb_x)
02176                && s->resync_mb_y+1 == s->mb_y){
02177                 s->first_slice_line=0;
02178             }
02179 
02180             s->mb_skipped=0;
02181             s->dquant=0; //only for QP_RD
02182 
02183             if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
02184                 int next_block=0;
02185                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
02186 
02187                 copy_context_before_encode(&backup_s, s, -1);
02188                 backup_s.pb= s->pb;
02189                 best_s.data_partitioning= s->data_partitioning;
02190                 best_s.partitioned_frame= s->partitioned_frame;
02191                 if(s->data_partitioning){
02192                     backup_s.pb2= s->pb2;
02193                     backup_s.tex_pb= s->tex_pb;
02194                 }
02195 
02196                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
02197                     s->mv_dir = MV_DIR_FORWARD;
02198                     s->mv_type = MV_TYPE_16X16;
02199                     s->mb_intra= 0;
02200                     s->mv[0][0][0] = s->p_mv_table[xy][0];
02201                     s->mv[0][0][1] = s->p_mv_table[xy][1];
02202                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
02203                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
02204                 }
02205                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
02206                     s->mv_dir = MV_DIR_FORWARD;
02207                     s->mv_type = MV_TYPE_FIELD;
02208                     s->mb_intra= 0;
02209                     for(i=0; i<2; i++){
02210                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
02211                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
02212                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
02213                     }
02214                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
02215                                  &dmin, &next_block, 0, 0);
02216                 }
02217                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
02218                     s->mv_dir = MV_DIR_FORWARD;
02219                     s->mv_type = MV_TYPE_16X16;
02220                     s->mb_intra= 0;
02221                     s->mv[0][0][0] = 0;
02222                     s->mv[0][0][1] = 0;
02223                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
02224                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
02225                 }
02226                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
02227                     s->mv_dir = MV_DIR_FORWARD;
02228                     s->mv_type = MV_TYPE_8X8;
02229                     s->mb_intra= 0;
02230                     for(i=0; i<4; i++){
02231                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
02232                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
02233                     }
02234                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
02235                                  &dmin, &next_block, 0, 0);
02236                 }
02237                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
02238                     s->mv_dir = MV_DIR_FORWARD;
02239                     s->mv_type = MV_TYPE_16X16;
02240                     s->mb_intra= 0;
02241                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
02242                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
02243                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
02244                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
02245                 }
02246                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
02247                     s->mv_dir = MV_DIR_BACKWARD;
02248                     s->mv_type = MV_TYPE_16X16;
02249                     s->mb_intra= 0;
02250                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
02251                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
02252                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
02253                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
02254                 }
02255                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
02256                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02257                     s->mv_type = MV_TYPE_16X16;
02258                     s->mb_intra= 0;
02259                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
02260                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
02261                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
02262                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
02263                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
02264                                  &dmin, &next_block, 0, 0);
02265                 }
02266                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
02267                     s->mv_dir = MV_DIR_FORWARD;
02268                     s->mv_type = MV_TYPE_FIELD;
02269                     s->mb_intra= 0;
02270                     for(i=0; i<2; i++){
02271                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
02272                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
02273                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
02274                     }
02275                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
02276                                  &dmin, &next_block, 0, 0);
02277                 }
02278                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
02279                     s->mv_dir = MV_DIR_BACKWARD;
02280                     s->mv_type = MV_TYPE_FIELD;
02281                     s->mb_intra= 0;
02282                     for(i=0; i<2; i++){
02283                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
02284                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
02285                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
02286                     }
02287                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
02288                                  &dmin, &next_block, 0, 0);
02289                 }
02290                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
02291                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02292                     s->mv_type = MV_TYPE_FIELD;
02293                     s->mb_intra= 0;
02294                     for(dir=0; dir<2; dir++){
02295                         for(i=0; i<2; i++){
02296                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
02297                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
02298                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
02299                         }
02300                     }
02301                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
02302                                  &dmin, &next_block, 0, 0);
02303                 }
02304                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
02305                     s->mv_dir = 0;
02306                     s->mv_type = MV_TYPE_16X16;
02307                     s->mb_intra= 1;
02308                     s->mv[0][0][0] = 0;
02309                     s->mv[0][0][1] = 0;
02310                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
02311                                  &dmin, &next_block, 0, 0);
02312                     if(s->h263_pred || s->h263_aic){
02313                         if(best_s.mb_intra)
02314                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
02315                         else
02316                             ff_clean_intra_table_entries(s); //old mode?
02317                     }
02318                 }
02319 
02320                 if((s->flags & CODEC_FLAG_QP_RD) && dmin < INT_MAX){
02321                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
02322                         const int last_qp= backup_s.qscale;
02323                         int qpi, qp, dc[6];
02324                         DCTELEM ac[6][16];
02325                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
02326                         static const int dquant_tab[4]={-1,1,-2,2};
02327 
02328                         assert(backup_s.dquant == 0);
02329 
02330                         //FIXME intra
02331                         s->mv_dir= best_s.mv_dir;
02332                         s->mv_type = MV_TYPE_16X16;
02333                         s->mb_intra= best_s.mb_intra;
02334                         s->mv[0][0][0] = best_s.mv[0][0][0];
02335                         s->mv[0][0][1] = best_s.mv[0][0][1];
02336                         s->mv[1][0][0] = best_s.mv[1][0][0];
02337                         s->mv[1][0][1] = best_s.mv[1][0][1];
02338 
02339                         qpi = s->pict_type == B_TYPE ? 2 : 0;
02340                         for(; qpi<4; qpi++){
02341                             int dquant= dquant_tab[qpi];
02342                             qp= last_qp + dquant;
02343                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
02344                                 continue;
02345                             backup_s.dquant= dquant;
02346                             if(s->mb_intra && s->dc_val[0]){
02347                                 for(i=0; i<6; i++){
02348                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
02349                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
02350                                 }
02351                             }
02352 
02353                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
02354                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
02355                             if(best_s.qscale != qp){
02356                                 if(s->mb_intra && s->dc_val[0]){
02357                                     for(i=0; i<6; i++){
02358                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
02359                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
02360                                     }
02361                                 }
02362                             }
02363                         }
02364                     }
02365                 }
02366                 if(ENABLE_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
02367                     int mx= s->b_direct_mv_table[xy][0];
02368                     int my= s->b_direct_mv_table[xy][1];
02369 
02370                     backup_s.dquant = 0;
02371                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
02372                     s->mb_intra= 0;
02373                     ff_mpeg4_set_direct_mv(s, mx, my);
02374                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
02375                                  &dmin, &next_block, mx, my);
02376                 }
02377                 if(ENABLE_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
02378                     backup_s.dquant = 0;
02379                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
02380                     s->mb_intra= 0;
02381                     ff_mpeg4_set_direct_mv(s, 0, 0);
02382                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
02383                                  &dmin, &next_block, 0, 0);
02384                 }
02385                 if(!best_s.mb_intra && s->flags2&CODEC_FLAG2_SKIP_RD){
02386                     int coded=0;
02387                     for(i=0; i<6; i++)
02388                         coded |= s->block_last_index[i];
02389                     if(coded){
02390                         int mx,my;
02391                         memcpy(s->mv, best_s.mv, sizeof(s->mv));
02392                         if(ENABLE_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
02393                             mx=my=0; //FIXME find the one we actually used
02394                             ff_mpeg4_set_direct_mv(s, mx, my);
02395                         }else if(best_s.mv_dir&MV_DIR_BACKWARD){
02396                             mx= s->mv[1][0][0];
02397                             my= s->mv[1][0][1];
02398                         }else{
02399                             mx= s->mv[0][0][0];
02400                             my= s->mv[0][0][1];
02401                         }
02402 
02403                         s->mv_dir= best_s.mv_dir;
02404                         s->mv_type = best_s.mv_type;
02405                         s->mb_intra= 0;
02406 /*                        s->mv[0][0][0] = best_s.mv[0][0][0];
02407                         s->mv[0][0][1] = best_s.mv[0][0][1];
02408                         s->mv[1][0][0] = best_s.mv[1][0][0];
02409                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
02410                         backup_s.dquant= 0;
02411                         s->skipdct=1;
02412                         encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
02413                                         &dmin, &next_block, mx, my);
02414                         s->skipdct=0;
02415                     }
02416                 }
02417 
02418                 s->current_picture.qscale_table[xy]= best_s.qscale;
02419 
02420                 copy_context_after_encode(s, &best_s, -1);
02421 
02422                 pb_bits_count= put_bits_count(&s->pb);
02423                 flush_put_bits(&s->pb);
02424                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
02425                 s->pb= backup_s.pb;
02426 
02427                 if(s->data_partitioning){
02428                     pb2_bits_count= put_bits_count(&s->pb2);
02429                     flush_put_bits(&s->pb2);
02430                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
02431                     s->pb2= backup_s.pb2;
02432 
02433                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
02434                     flush_put_bits(&s->tex_pb);
02435                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
02436                     s->tex_pb= backup_s.tex_pb;
02437                 }
02438                 s->last_bits= put_bits_count(&s->pb);
02439 
02440                 if (ENABLE_ANY_H263_ENCODER &&
02441                     s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
02442                     ff_h263_update_motion_val(s);
02443 
02444                 if(next_block==0){ //FIXME 16 vs linesize16
02445                     s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
02446                     s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
02447                     s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
02448                 }
02449 
02450                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
02451                     MPV_decode_mb(s, s->block);
02452             } else {
02453                 int motion_x = 0, motion_y = 0;
02454                 s->mv_type=MV_TYPE_16X16;
02455                 // only one MB-Type possible
02456 
02457                 switch(mb_type){
02458                 case CANDIDATE_MB_TYPE_INTRA:
02459                     s->mv_dir = 0;
02460                     s->mb_intra= 1;
02461                     motion_x= s->mv[0][0][0] = 0;
02462                     motion_y= s->mv[0][0][1] = 0;
02463                     break;
02464                 case CANDIDATE_MB_TYPE_INTER:
02465                     s->mv_dir = MV_DIR_FORWARD;
02466                     s->mb_intra= 0;
02467                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
02468                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
02469                     break;
02470                 case CANDIDATE_MB_TYPE_INTER_I:
02471                     s->mv_dir = MV_DIR_FORWARD;
02472                     s->mv_type = MV_TYPE_FIELD;
02473                     s->mb_intra= 0;
02474                     for(i=0; i<2; i++){
02475                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
02476                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
02477                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
02478                     }
02479                     break;
02480                 case CANDIDATE_MB_TYPE_INTER4V:
02481                     s->mv_dir = MV_DIR_FORWARD;
02482                     s->mv_type = MV_TYPE_8X8;
02483                     s->mb_intra= 0;
02484                     for(i=0; i<4; i++){
02485                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
02486                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
02487                     }
02488                     break;
02489                 case CANDIDATE_MB_TYPE_DIRECT:
02490                     if (ENABLE_MPEG4_ENCODER) {
02491                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
02492                         s->mb_intra= 0;
02493                         motion_x=s->b_direct_mv_table[xy][0];
02494                         motion_y=s->b_direct_mv_table[xy][1];
02495                         ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
02496                     }
02497                     break;
02498                 case CANDIDATE_MB_TYPE_DIRECT0:
02499                     if (ENABLE_MPEG4_ENCODER) {
02500                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
02501                         s->mb_intra= 0;
02502                         ff_mpeg4_set_direct_mv(s, 0, 0);
02503                     }
02504                     break;
02505                 case CANDIDATE_MB_TYPE_BIDIR:
02506                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02507                     s->mb_intra= 0;
02508                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
02509                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
02510                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
02511                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
02512                     break;
02513                 case CANDIDATE_MB_TYPE_BACKWARD:
02514                     s->mv_dir = MV_DIR_BACKWARD;
02515                     s->mb_intra= 0;
02516                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
02517                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
02518                     break;
02519                 case CANDIDATE_MB_TYPE_FORWARD:
02520                     s->mv_dir = MV_DIR_FORWARD;
02521                     s->mb_intra= 0;
02522                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
02523                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
02524 //                    printf(" %d %d ", motion_x, motion_y);
02525                     break;
02526                 case CANDIDATE_MB_TYPE_FORWARD_I:
02527                     s->mv_dir = MV_DIR_FORWARD;
02528                     s->mv_type = MV_TYPE_FIELD;
02529                     s->mb_intra= 0;
02530                     for(i=0; i<2; i++){
02531                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
02532                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
02533                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
02534                     }
02535                     break;
02536                 case CANDIDATE_MB_TYPE_BACKWARD_I:
02537                     s->mv_dir = MV_DIR_BACKWARD;
02538                     s->mv_type = MV_TYPE_FIELD;
02539                     s->mb_intra= 0;
02540                     for(i=0; i<2; i++){
02541                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
02542                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
02543                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
02544                     }
02545                     break;
02546                 case CANDIDATE_MB_TYPE_BIDIR_I:
02547                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
02548                     s->mv_type = MV_TYPE_FIELD;
02549                     s->mb_intra= 0;
02550                     for(dir=0; dir<2; dir++){
02551                         for(i=0; i<2; i++){
02552                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
02553                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
02554                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
02555                         }
02556                     }
02557                     break;
02558                 default:
02559                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
02560                 }
02561 
02562                 encode_mb(s, motion_x, motion_y);
02563 
02564                 // RAL: Update last macroblock type
02565                 s->last_mv_dir = s->mv_dir;
02566 
02567                 if (ENABLE_ANY_H263_ENCODER &&
02568                     s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
02569                     ff_h263_update_motion_val(s);
02570 
02571                 MPV_decode_mb(s, s->block);
02572             }
02573 
02574             /* clean the MV table in IPS frames for direct mode in B frames */
02575             if(s->mb_intra /* && I,P,S_TYPE */){
02576                 s->p_mv_table[xy][0]=0;
02577                 s->p_mv_table[xy][1]=0;
02578             }
02579 
02580             if(s->flags&CODEC_FLAG_PSNR){
02581                 int w= 16;
02582                 int h= 16;
02583 
02584                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
02585                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
02586 
02587                 s->current_picture.error[0] += sse(
02588                     s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
02589                     s->dest[0], w, h, s->linesize);
02590                 s->current_picture.error[1] += sse(
02591                     s, s->new_picture.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
02592                     s->dest[1], w>>1, h>>1, s->uvlinesize);
02593                 s->current_picture.error[2] += sse(
02594                     s, s->new_picture    .data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,
02595                     s->dest[2], w>>1, h>>1, s->uvlinesize);
02596             }
02597             if(s->loop_filter){
02598                 if(ENABLE_ANY_H263_ENCODER && s->out_format == FMT_H263)
02599                     ff_h263_loop_filter(s);
02600             }
02601 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
02602         }
02603     }
02604 
02605     //not beautiful here but we must write it before flushing so it has to be here
02606     if (ENABLE_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
02607         msmpeg4_encode_ext_header(s);
02608 
02609     write_slice_end(s);
02610 
02611     /* Send the last GOB if RTP */
02612     if (s->avctx->rtp_callback) {
02613         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
02614         pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
02615         /* Call the RTP callback to send the last GOB */
02616         emms_c();
02617         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
02618     }
02619 
02620     return 0;
02621 }
02622 
02623 #define MERGE(field) dst->field += src->field; src->field=0
02624 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
02625     MERGE(me.scene_change_score);
02626     MERGE(me.mc_mb_var_sum_temp);
02627     MERGE(me.mb_var_sum_temp);
02628 }
02629 
02630 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
02631     int i;
02632 
02633     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
02634     MERGE(dct_count[1]);
02635     MERGE(mv_bits);
02636     MERGE(i_tex_bits);
02637     MERGE(p_tex_bits);
02638     MERGE(i_count);
02639     MERGE(f_count);
02640     MERGE(b_count);
02641     MERGE(skip_count);
02642     MERGE(misc_bits);
02643     MERGE(error_count);
02644     MERGE(padding_bug_score);
02645     MERGE(current_picture.error[0]);
02646     MERGE(current_picture.error[1]);
02647     MERGE(current_picture.error[2]);
02648 
02649     if(dst->avctx->noise_reduction){
02650         for(i=0; i<64; i++){
02651             MERGE(dct_error_sum[0][i]);
02652             MERGE(dct_error_sum[1][i]);
02653         }
02654     }
02655 
02656     assert(put_bits_count(&src->pb) % 8 ==0);
02657     assert(put_bits_count(&dst->pb) % 8 ==0);
02658     ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
02659     flush_put_bits(&dst->pb);
02660 }
02661 
02662 static int estimate_qp(MpegEncContext *s, int dry_run){
02663     if (s->next_lambda){
02664         s->current_picture_ptr->quality=
02665         s->current_picture.quality = s->next_lambda;
02666         if(!dry_run) s->next_lambda= 0;
02667     } else if (!s->fixed_qscale) {
02668         s->current_picture_ptr->quality=
02669         s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
02670         if (s->current_picture.quality < 0)
02671             return -1;
02672     }
02673 
02674     if(s->adaptive_quant){
02675         switch(s->codec_id){
02676         case CODEC_ID_MPEG4:
02677             if (ENABLE_MPEG4_ENCODER)
02678                 ff_clean_mpeg4_qscales(s);
02679             break;
02680         case CODEC_ID_H263:
02681         case CODEC_ID_H263P:
02682         case CODEC_ID_FLV1:
02683             if (ENABLE_H263_ENCODER||ENABLE_H263P_ENCODER||ENABLE_FLV_ENCODER)
02684                 ff_clean_h263_qscales(s);
02685             break;
02686         }
02687 
02688         s->lambda= s->lambda_table[0];
02689         //FIXME broken
02690     }else
02691         s->lambda= s->current_picture.quality;
02692 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
02693     update_qscale(s);
02694     return 0;
02695 }
02696 
02697 /* must be called before writing the header */
02698 static void set_frame_distances(MpegEncContext * s){
02699     assert(s->current_picture_ptr->pts != AV_NOPTS_VALUE);
02700     s->time= s->current_picture_ptr->pts*s->avctx->time_base.num;
02701 
02702     if(s->pict_type==B_TYPE){
02703         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
02704         assert(s->pb_time > 0 && s->pb_time < s->pp_time);
02705     }else{
02706         s->pp_time= s->time - s->last_non_b_time;
02707         s->last_non_b_time= s->time;
02708         assert(s->picture_number==0 || s->pp_time > 0);
02709     }
02710 }
02711 
02712 static int encode_picture(MpegEncContext *s, int picture_number)
02713 {
02714     int i;
02715     int bits;
02716 
02717     s->picture_number = picture_number;
02718 
02719     /* Reset the average MB variance */
02720     s->me.mb_var_sum_temp    =
02721     s->me.mc_mb_var_sum_temp = 0;
02722 
02723     /* we need to initialize some time vars before we can encode b-frames */
02724     // RAL: Condition added for MPEG1VIDEO
02725     if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
02726         set_frame_distances(s);
02727     if(ENABLE_MPEG4_ENCODER && s->codec_id == CODEC_ID_MPEG4)
02728         ff_set_mpeg4_time(s);
02729 
02730     s->me.scene_change_score=0;
02731 
02732 //    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
02733 
02734     if(s->pict_type==I_TYPE){
02735         if(s->msmpeg4_version >= 3) s->no_rounding=1;
02736         else                        s->no_rounding=0;
02737     }else if(s->pict_type!=B_TYPE){
02738         if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
02739             s->no_rounding ^= 1;
02740     }
02741 
02742     if(s->flags & CODEC_FLAG_PASS2){
02743         if (estimate_qp(s,1) < 0)
02744             return -1;
02745         ff_get_2pass_fcode(s);
02746     }else if(!(s->flags & CODEC_FLAG_QSCALE)){
02747         if(s->pict_type==B_TYPE)
02748             s->lambda= s->last_lambda_for[s->pict_type];
02749         else
02750             s->lambda= s->