ratecontrol: Move Xvid-related functions to the place they are actually used
[ffmpeg.git] / libavcodec / mpegvideo_enc.c
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include <stdint.h>
31
32 #include "libavutil/internal.h"
33 #include "libavutil/intmath.h"
34 #include "libavutil/mathematics.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/timer.h"
38 #include "avcodec.h"
39 #include "dct.h"
40 #include "idctdsp.h"
41 #include "mpeg12.h"
42 #include "mpegvideo.h"
43 #include "mpegvideodata.h"
44 #include "h261.h"
45 #include "h263.h"
46 #include "h263data.h"
47 #include "mjpegenc_common.h"
48 #include "mathops.h"
49 #include "mpegutils.h"
50 #include "mjpegenc.h"
51 #include "msmpeg4.h"
52 #include "pixblockdsp.h"
53 #include "qpeldsp.h"
54 #include "faandct.h"
55 #include "thread.h"
56 #include "aandcttab.h"
57 #include "flv.h"
58 #include "mpeg4video.h"
59 #include "internal.h"
60 #include "bytestream.h"
61 #include "wmv2.h"
62 #include "rv10.h"
63 #include "libxvid.h"
64 #include <limits.h>
65
66 #define QUANT_BIAS_SHIFT 8
67
68 #define QMAT_SHIFT_MMX 16
69 #define QMAT_SHIFT 22
70
71 static int encode_picture(MpegEncContext *s, int picture_number);
72 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
73 static int sse_mb(MpegEncContext *s);
74 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
75 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
76
77 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
78 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
79
80 const AVOption ff_mpv_generic_options[] = {
81     FF_MPV_COMMON_OPTS
82     { NULL },
83 };
84
85 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
86                        uint16_t (*qmat16)[2][64],
87                        const uint16_t *quant_matrix,
88                        int bias, int qmin, int qmax, int intra)
89 {
90     FDCTDSPContext *fdsp = &s->fdsp;
91     int qscale;
92     int shift = 0;
93
94     for (qscale = qmin; qscale <= qmax; qscale++) {
95         int i;
96         if (fdsp->fdct == ff_jpeg_fdct_islow_8  ||
97 #if CONFIG_FAANDCT
98             fdsp->fdct == ff_faandct            ||
99 #endif /* CONFIG_FAANDCT */
100             fdsp->fdct == ff_jpeg_fdct_islow_10) {
101             for (i = 0; i < 64; i++) {
102                 const int j = s->idsp.idct_permutation[i];
103                 int64_t den = (int64_t) qscale * quant_matrix[j];
104                 /* 16 <= qscale * quant_matrix[i] <= 7905
105                  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
106                  *             19952 <=              x  <= 249205026
107                  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
108                  *           3444240 >= (1 << 36) / (x) >= 275 */
109
110                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
111             }
112         } else if (fdsp->fdct == ff_fdct_ifast) {
113             for (i = 0; i < 64; i++) {
114                 const int j = s->idsp.idct_permutation[i];
115                 int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
116                 /* 16 <= qscale * quant_matrix[i] <= 7905
117                  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
118                  *             19952 <=              x  <= 249205026
119                  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
120                  *           3444240 >= (1 << 36) / (x) >= 275 */
121
122                 qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
123             }
124         } else {
125             for (i = 0; i < 64; i++) {
126                 const int j = s->idsp.idct_permutation[i];
127                 int64_t den = (int64_t) qscale * quant_matrix[j];
128                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
129                  * Assume x = qscale * quant_matrix[i]
130                  * So             16 <=              x  <= 7905
131                  * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
132                  * so          32768 >= (1 << 19) / (x) >= 67 */
133                 qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
134                 //qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) /
135                 //                    (qscale * quant_matrix[i]);
136                 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
137
138                 if (qmat16[qscale][0][i] == 0 ||
139                     qmat16[qscale][0][i] == 128 * 256)
140                     qmat16[qscale][0][i] = 128 * 256 - 1;
141                 qmat16[qscale][1][i] =
142                     ROUNDED_DIV(bias << (16 - QUANT_BIAS_SHIFT),
143                                 qmat16[qscale][0][i]);
144             }
145         }
146
147         for (i = intra; i < 64; i++) {
148             int64_t max = 8191;
149             if (fdsp->fdct == ff_fdct_ifast) {
150                 max = (8191LL * ff_aanscales[i]) >> 14;
151             }
152             while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
153                 shift++;
154             }
155         }
156     }
157     if (shift) {
158         av_log(NULL, AV_LOG_INFO,
159                "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
160                QMAT_SHIFT - shift);
161     }
162 }
163
164 static inline void update_qscale(MpegEncContext *s)
165 {
166     s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
167                 (FF_LAMBDA_SHIFT + 7);
168     s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
169
170     s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
171                  FF_LAMBDA_SHIFT;
172 }
173
174 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
175 {
176     int i;
177
178     if (matrix) {
179         put_bits(pb, 1, 1);
180         for (i = 0; i < 64; i++) {
181             put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
182         }
183     } else
184         put_bits(pb, 1, 0);
185 }
186
187 /**
188  * init s->current_picture.qscale_table from s->lambda_table
189  */
190 void ff_init_qscale_tab(MpegEncContext *s)
191 {
192     int8_t * const qscale_table = s->current_picture.qscale_table;
193     int i;
194
195     for (i = 0; i < s->mb_num; i++) {
196         unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
197         int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
198         qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
199                                                   s->avctx->qmax);
200     }
201 }
202
203 static void update_duplicate_context_after_me(MpegEncContext *dst,
204                                               MpegEncContext *src)
205 {
206 #define COPY(a) dst->a= src->a
207     COPY(pict_type);
208     COPY(current_picture);
209     COPY(f_code);
210     COPY(b_code);
211     COPY(qscale);
212     COPY(lambda);
213     COPY(lambda2);
214     COPY(picture_in_gop_number);
215     COPY(gop_picture_number);
216     COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
217     COPY(progressive_frame);    // FIXME don't set in encode_header
218     COPY(partitioned_frame);    // FIXME don't set in encode_header
219 #undef COPY
220 }
221
222 /**
223  * Set the given MpegEncContext to defaults for encoding.
224  * the changed fields will not depend upon the prior state of the MpegEncContext.
225  */
226 static void mpv_encode_defaults(MpegEncContext *s)
227 {
228     int i;
229     ff_mpv_common_defaults(s);
230
231     for (i = -16; i < 16; i++) {
232         default_fcode_tab[i + MAX_MV] = 1;
233     }
234     s->me.mv_penalty = default_mv_penalty;
235     s->fcode_tab     = default_fcode_tab;
236
237     s->input_picture_number  = 0;
238     s->picture_in_gop_number = 0;
239 }
240
241 /* init video encoder */
242 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
243 {
244     MpegEncContext *s = avctx->priv_data;
245     AVCPBProperties *cpb_props;
246     int i, ret, format_supported;
247
248     mpv_encode_defaults(s);
249
250     switch (avctx->codec_id) {
251     case AV_CODEC_ID_MPEG2VIDEO:
252         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
253             avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
254             av_log(avctx, AV_LOG_ERROR,
255                    "only YUV420 and YUV422 are supported\n");
256             return -1;
257         }
258         break;
259     case AV_CODEC_ID_MJPEG:
260         format_supported = 0;
261         /* JPEG color space */
262         if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
263             avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
264             (avctx->color_range == AVCOL_RANGE_JPEG &&
265              (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
266               avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
267             format_supported = 1;
268         /* MPEG color space */
269         else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
270                  (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
271                   avctx->pix_fmt == AV_PIX_FMT_YUV422P))
272             format_supported = 1;
273
274         if (!format_supported) {
275             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
276             return -1;
277         }
278         break;
279     default:
280         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
281             av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
282             return -1;
283         }
284     }
285
286     switch (avctx->pix_fmt) {
287     case AV_PIX_FMT_YUVJ422P:
288     case AV_PIX_FMT_YUV422P:
289         s->chroma_format = CHROMA_422;
290         break;
291     case AV_PIX_FMT_YUVJ420P:
292     case AV_PIX_FMT_YUV420P:
293     default:
294         s->chroma_format = CHROMA_420;
295         break;
296     }
297
298 #if FF_API_PRIVATE_OPT
299 FF_DISABLE_DEPRECATION_WARNINGS
300     if (avctx->rtp_payload_size)
301         s->rtp_payload_size = avctx->rtp_payload_size;
302     if (avctx->me_penalty_compensation)
303         s->me_penalty_compensation = avctx->me_penalty_compensation;
304     if (avctx->pre_me)
305         s->me_pre = avctx->pre_me;
306 FF_ENABLE_DEPRECATION_WARNINGS
307 #endif
308
309     s->bit_rate = avctx->bit_rate;
310     s->width    = avctx->width;
311     s->height   = avctx->height;
312     if (avctx->gop_size > 600 &&
313         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
314         av_log(avctx, AV_LOG_ERROR,
315                "Warning keyframe interval too large! reducing it ...\n");
316         avctx->gop_size = 600;
317     }
318     s->gop_size     = avctx->gop_size;
319     s->avctx        = avctx;
320     if (avctx->max_b_frames > MAX_B_FRAMES) {
321         av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
322                "is %d.\n", MAX_B_FRAMES);
323     }
324     s->max_b_frames = avctx->max_b_frames;
325     s->codec_id     = avctx->codec->id;
326     s->strict_std_compliance = avctx->strict_std_compliance;
327     s->quarter_sample     = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
328     s->rtp_mode           = !!s->rtp_payload_size;
329     s->intra_dc_precision = avctx->intra_dc_precision;
330     s->user_specified_pts = AV_NOPTS_VALUE;
331
332     if (s->gop_size <= 1) {
333         s->intra_only = 1;
334         s->gop_size   = 12;
335     } else {
336         s->intra_only = 0;
337     }
338
339 #if FF_API_MOTION_EST
340 FF_DISABLE_DEPRECATION_WARNINGS
341     s->me_method = avctx->me_method;
342 FF_ENABLE_DEPRECATION_WARNINGS
343 #endif
344
345     /* Fixed QSCALE */
346     s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
347
348 #if FF_API_MPV_OPT
349     FF_DISABLE_DEPRECATION_WARNINGS
350     if (avctx->border_masking != 0.0)
351         s->border_masking = avctx->border_masking;
352     FF_ENABLE_DEPRECATION_WARNINGS
353 #endif
354
355     s->adaptive_quant = (s->avctx->lumi_masking ||
356                          s->avctx->dark_masking ||
357                          s->avctx->temporal_cplx_masking ||
358                          s->avctx->spatial_cplx_masking  ||
359                          s->avctx->p_masking      ||
360                          s->border_masking ||
361                          (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
362                         !s->fixed_qscale;
363
364     s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
365
366     if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
367         av_log(avctx, AV_LOG_ERROR,
368                "a vbv buffer size is needed, "
369                "for encoding with a maximum bitrate\n");
370         return -1;
371     }
372
373     if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
374         av_log(avctx, AV_LOG_INFO,
375                "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
376     }
377
378     if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
379         av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
380         return -1;
381     }
382
383     if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
384         av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
385         return -1;
386     }
387
388     if (avctx->rc_max_rate &&
389         avctx->rc_max_rate == avctx->bit_rate &&
390         avctx->rc_max_rate != avctx->rc_min_rate) {
391         av_log(avctx, AV_LOG_INFO,
392                "impossible bitrate constraints, this will fail\n");
393     }
394
395     if (avctx->rc_buffer_size &&
396         avctx->bit_rate * (int64_t)avctx->time_base.num >
397             avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
398         av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
399         return -1;
400     }
401
402     if (!s->fixed_qscale &&
403         avctx->bit_rate * av_q2d(avctx->time_base) >
404             avctx->bit_rate_tolerance) {
405         av_log(avctx, AV_LOG_ERROR,
406                "bitrate tolerance too small for bitrate\n");
407         return -1;
408     }
409
410     if (s->avctx->rc_max_rate &&
411         s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
412         (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
413          s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
414         90000LL * (avctx->rc_buffer_size - 1) >
415             s->avctx->rc_max_rate * 0xFFFFLL) {
416         av_log(avctx, AV_LOG_INFO,
417                "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
418                "specified vbv buffer is too large for the given bitrate!\n");
419     }
420
421     if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
422         s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
423         s->codec_id != AV_CODEC_ID_FLV1) {
424         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
425         return -1;
426     }
427
428     if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
429         av_log(avctx, AV_LOG_ERROR,
430                "OBMC is only supported with simple mb decision\n");
431         return -1;
432     }
433
434     if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
435         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
436         return -1;
437     }
438
439     if (s->max_b_frames                    &&
440         s->codec_id != AV_CODEC_ID_MPEG4      &&
441         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
442         s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
443         av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
444         return -1;
445     }
446
447     if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
448          s->codec_id == AV_CODEC_ID_H263  ||
449          s->codec_id == AV_CODEC_ID_H263P) &&
450         (avctx->sample_aspect_ratio.num > 255 ||
451          avctx->sample_aspect_ratio.den > 255)) {
452         av_log(avctx, AV_LOG_ERROR,
453                "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
454                avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
455         return -1;
456     }
457
458     if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
459         s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
460         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
461         return -1;
462     }
463
464 #if FF_API_PRIVATE_OPT
465     FF_DISABLE_DEPRECATION_WARNINGS
466     if (avctx->mpeg_quant)
467         s->mpeg_quant = avctx->mpeg_quant;
468     FF_ENABLE_DEPRECATION_WARNINGS
469 #endif
470
471     // FIXME mpeg2 uses that too
472     if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
473         av_log(avctx, AV_LOG_ERROR,
474                "mpeg2 style quantization not supported by codec\n");
475         return -1;
476     }
477
478     if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
479         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
480         return -1;
481     }
482
483     if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
484         s->avctx->mb_decision != FF_MB_DECISION_RD) {
485         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
486         return -1;
487     }
488
489 #if FF_API_PRIVATE_OPT
490 FF_DISABLE_DEPRECATION_WARNINGS
491     if (avctx->scenechange_threshold)
492         s->scenechange_threshold = avctx->scenechange_threshold;
493 FF_ENABLE_DEPRECATION_WARNINGS
494 #endif
495
496     if (s->scenechange_threshold < 1000000000 &&
497         (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
498         av_log(avctx, AV_LOG_ERROR,
499                "closed gop with scene change detection are not supported yet, "
500                "set threshold to 1000000000\n");
501         return -1;
502     }
503
504     if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
505         if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
506             av_log(avctx, AV_LOG_ERROR,
507                   "low delay forcing is only available for mpeg2\n");
508             return -1;
509         }
510         if (s->max_b_frames != 0) {
511             av_log(avctx, AV_LOG_ERROR,
512                    "B-frames cannot be used with low delay\n");
513             return -1;
514         }
515     }
516
517     if (s->q_scale_type == 1) {
518         if (avctx->qmax > 12) {
519             av_log(avctx, AV_LOG_ERROR,
520                    "non linear quant only supports qmax <= 12 currently\n");
521             return -1;
522         }
523     }
524
525     if (avctx->slices > 1 &&
526         (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
527         av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
528         return AVERROR(EINVAL);
529     }
530
531     if (s->avctx->thread_count > 1         &&
532         s->codec_id != AV_CODEC_ID_MPEG4      &&
533         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
534         s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
535         (s->codec_id != AV_CODEC_ID_H263P)) {
536         av_log(avctx, AV_LOG_ERROR,
537                "multi threaded encoding not supported by codec\n");
538         return -1;
539     }
540
541     if (s->avctx->thread_count < 1) {
542         av_log(avctx, AV_LOG_ERROR,
543                "automatic thread number detection not supported by codec,"
544                "patch welcome\n");
545         return -1;
546     }
547
548     if (!avctx->time_base.den || !avctx->time_base.num) {
549         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
550         return -1;
551     }
552
553 #if FF_API_PRIVATE_OPT
554 FF_DISABLE_DEPRECATION_WARNINGS
555     if (avctx->b_frame_strategy)
556         s->b_frame_strategy = avctx->b_frame_strategy;
557     if (avctx->b_sensitivity != 40)
558         s->b_sensitivity = avctx->b_sensitivity;
559 FF_ENABLE_DEPRECATION_WARNINGS
560 #endif
561
562     if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
563         av_log(avctx, AV_LOG_INFO,
564                "notice: b_frame_strategy only affects the first pass\n");
565         s->b_frame_strategy = 0;
566     }
567
568     i = av_gcd(avctx->time_base.den, avctx->time_base.num);
569     if (i > 1) {
570         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
571         avctx->time_base.den /= i;
572         avctx->time_base.num /= i;
573         //return -1;
574     }
575
576     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
577         s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
578         // (a + x * 3 / 8) / x
579         s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
580         s->inter_quant_bias = 0;
581     } else {
582         s->intra_quant_bias = 0;
583         // (a - x / 4) / x
584         s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
585     }
586
587 #if FF_API_QUANT_BIAS
588 FF_DISABLE_DEPRECATION_WARNINGS
589     if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
590         s->intra_quant_bias = avctx->intra_quant_bias;
591     if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
592         s->inter_quant_bias = avctx->inter_quant_bias;
593 FF_ENABLE_DEPRECATION_WARNINGS
594 #endif
595
596     if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
597         s->avctx->time_base.den > (1 << 16) - 1) {
598         av_log(avctx, AV_LOG_ERROR,
599                "timebase %d/%d not supported by MPEG 4 standard, "
600                "the maximum admitted value for the timebase denominator "
601                "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
602                (1 << 16) - 1);
603         return -1;
604     }
605     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
606
607     switch (avctx->codec->id) {
608     case AV_CODEC_ID_MPEG1VIDEO:
609         s->out_format = FMT_MPEG1;
610         s->low_delay  = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
611         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
612         break;
613     case AV_CODEC_ID_MPEG2VIDEO:
614         s->out_format = FMT_MPEG1;
615         s->low_delay  = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
616         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
617         s->rtp_mode   = 1;
618         break;
619     case AV_CODEC_ID_MJPEG:
620         s->out_format = FMT_MJPEG;
621         s->intra_only = 1; /* force intra only for jpeg */
622         if (!CONFIG_MJPEG_ENCODER ||
623             ff_mjpeg_encode_init(s) < 0)
624             return -1;
625         avctx->delay = 0;
626         s->low_delay = 1;
627         break;
628     case AV_CODEC_ID_H261:
629         if (!CONFIG_H261_ENCODER)
630             return -1;
631         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
632             av_log(avctx, AV_LOG_ERROR,
633                    "The specified picture size of %dx%d is not valid for the "
634                    "H.261 codec.\nValid sizes are 176x144, 352x288\n",
635                     s->width, s->height);
636             return -1;
637         }
638         s->out_format = FMT_H261;
639         avctx->delay  = 0;
640         s->low_delay  = 1;
641         s->rtp_mode   = 0; /* Sliced encoding not supported */
642         break;
643     case AV_CODEC_ID_H263:
644         if (!CONFIG_H263_ENCODER)
645         return -1;
646         if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
647                              s->width, s->height) == 8) {
648             av_log(avctx, AV_LOG_INFO,
649                    "The specified picture size of %dx%d is not valid for "
650                    "the H.263 codec.\nValid sizes are 128x96, 176x144, "
651                    "352x288, 704x576, and 1408x1152."
652                    "Try H.263+.\n", s->width, s->height);
653             return -1;
654         }
655         s->out_format = FMT_H263;
656         avctx->delay  = 0;
657         s->low_delay  = 1;
658         break;
659     case AV_CODEC_ID_H263P:
660         s->out_format = FMT_H263;
661         s->h263_plus  = 1;
662         /* Fx */
663         s->h263_aic        = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
664         s->modified_quant  = s->h263_aic;
665         s->loop_filter     = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
666         s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
667
668         /* /Fx */
669         /* These are just to be sure */
670         avctx->delay = 0;
671         s->low_delay = 1;
672         break;
673     case AV_CODEC_ID_FLV1:
674         s->out_format      = FMT_H263;
675         s->h263_flv        = 2; /* format = 1; 11-bit codes */
676         s->unrestricted_mv = 1;
677         s->rtp_mode  = 0; /* don't allow GOB */
678         avctx->delay = 0;
679         s->low_delay = 1;
680         break;
681     case AV_CODEC_ID_RV10:
682         s->out_format = FMT_H263;
683         avctx->delay  = 0;
684         s->low_delay  = 1;
685         break;
686     case AV_CODEC_ID_RV20:
687         s->out_format      = FMT_H263;
688         avctx->delay       = 0;
689         s->low_delay       = 1;
690         s->modified_quant  = 1;
691         s->h263_aic        = 1;
692         s->h263_plus       = 1;
693         s->loop_filter     = 1;
694         s->unrestricted_mv = 0;
695         break;
696     case AV_CODEC_ID_MPEG4:
697         s->out_format      = FMT_H263;
698         s->h263_pred       = 1;
699         s->unrestricted_mv = 1;
700         s->low_delay       = s->max_b_frames ? 0 : 1;
701         avctx->delay       = s->low_delay ? 0 : (s->max_b_frames + 1);
702         break;
703     case AV_CODEC_ID_MSMPEG4V2:
704         s->out_format      = FMT_H263;
705         s->h263_pred       = 1;
706         s->unrestricted_mv = 1;
707         s->msmpeg4_version = 2;
708         avctx->delay       = 0;
709         s->low_delay       = 1;
710         break;
711     case AV_CODEC_ID_MSMPEG4V3:
712         s->out_format        = FMT_H263;
713         s->h263_pred         = 1;
714         s->unrestricted_mv   = 1;
715         s->msmpeg4_version   = 3;
716         s->flipflop_rounding = 1;
717         avctx->delay         = 0;
718         s->low_delay         = 1;
719         break;
720     case AV_CODEC_ID_WMV1:
721         s->out_format        = FMT_H263;
722         s->h263_pred         = 1;
723         s->unrestricted_mv   = 1;
724         s->msmpeg4_version   = 4;
725         s->flipflop_rounding = 1;
726         avctx->delay         = 0;
727         s->low_delay         = 1;
728         break;
729     case AV_CODEC_ID_WMV2:
730         s->out_format        = FMT_H263;
731         s->h263_pred         = 1;
732         s->unrestricted_mv   = 1;
733         s->msmpeg4_version   = 5;
734         s->flipflop_rounding = 1;
735         avctx->delay         = 0;
736         s->low_delay         = 1;
737         break;
738     default:
739         return -1;
740     }
741
742 #if FF_API_PRIVATE_OPT
743     FF_DISABLE_DEPRECATION_WARNINGS
744     if (avctx->noise_reduction)
745         s->noise_reduction = avctx->noise_reduction;
746     FF_ENABLE_DEPRECATION_WARNINGS
747 #endif
748
749     avctx->has_b_frames = !s->low_delay;
750
751     s->encoding = 1;
752
753     s->progressive_frame    =
754     s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
755                                                 AV_CODEC_FLAG_INTERLACED_ME) ||
756                                 s->alternate_scan);
757
758     /* init */
759     ff_mpv_idct_init(s);
760     if (ff_mpv_common_init(s) < 0)
761         return -1;
762
763     if (ARCH_X86)
764         ff_mpv_encode_init_x86(s);
765
766     ff_fdctdsp_init(&s->fdsp, avctx);
767     ff_me_cmp_init(&s->mecc, avctx);
768     ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
769     ff_pixblockdsp_init(&s->pdsp, avctx);
770     ff_qpeldsp_init(&s->qdsp);
771
772     if (s->msmpeg4_version) {
773         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
774                           2 * 2 * (MAX_LEVEL + 1) *
775                           (MAX_RUN + 1) * 2 * sizeof(int), fail);
776     }
777     FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
778
779     FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,   64 * 32 * sizeof(int), fail);
780     FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,   64 * 32 * sizeof(int), fail);
781     FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
782     FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
783     FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
784                       MAX_PICTURE_COUNT * sizeof(Picture *), fail);
785     FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
786                       MAX_PICTURE_COUNT * sizeof(Picture *), fail);
787
788
789     if (s->noise_reduction) {
790         FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
791                           2 * 64 * sizeof(uint16_t), fail);
792     }
793
794     if (CONFIG_H263_ENCODER)
795         ff_h263dsp_init(&s->h263dsp);
796     if (!s->dct_quantize)
797         s->dct_quantize = ff_dct_quantize_c;
798     if (!s->denoise_dct)
799         s->denoise_dct  = denoise_dct_c;
800     s->fast_dct_quantize = s->dct_quantize;
801     if (avctx->trellis)
802         s->dct_quantize  = dct_quantize_trellis_c;
803
804     if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
805         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
806
807     if (s->slice_context_count > 1) {
808         s->rtp_mode = 1;
809
810         if (avctx->codec_id == AV_CODEC_ID_H263 || avctx->codec_id == AV_CODEC_ID_H263P)
811             s->h263_slice_structured = 1;
812     }
813
814     s->quant_precision = 5;
815
816 #if FF_API_PRIVATE_OPT
817 FF_DISABLE_DEPRECATION_WARNINGS
818     if (avctx->frame_skip_threshold)
819         s->frame_skip_threshold = avctx->frame_skip_threshold;
820     if (avctx->frame_skip_factor)
821         s->frame_skip_factor = avctx->frame_skip_factor;
822     if (avctx->frame_skip_exp)
823         s->frame_skip_exp = avctx->frame_skip_exp;
824     if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
825         s->frame_skip_cmp = avctx->frame_skip_cmp;
826 FF_ENABLE_DEPRECATION_WARNINGS
827 #endif
828
829     ff_set_cmp(&s->mecc, s->mecc.ildct_cmp,      s->avctx->ildct_cmp);
830     ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
831
832     if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
833         ff_h261_encode_init(s);
834     if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
835         ff_h263_encode_init(s);
836     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
837         if ((ret = ff_msmpeg4_encode_init(s)) < 0)
838             return ret;
839     if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
840         && s->out_format == FMT_MPEG1)
841         ff_mpeg1_encode_init(s);
842
843     /* init q matrix */
844     for (i = 0; i < 64; i++) {
845         int j = s->idsp.idct_permutation[i];
846         if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
847             s->mpeg_quant) {
848             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
849             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
850         } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
851             s->intra_matrix[j] =
852             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
853         } else {
854             /* MPEG-1/2 */
855             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
856             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
857         }
858         if (s->avctx->intra_matrix)
859             s->intra_matrix[j] = s->avctx->intra_matrix[i];
860         if (s->avctx->inter_matrix)
861             s->inter_matrix[j] = s->avctx->inter_matrix[i];
862     }
863
864     /* precompute matrix */
865     /* for mjpeg, we do include qscale in the matrix */
866     if (s->out_format != FMT_MJPEG) {
867         ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
868                           s->intra_matrix, s->intra_quant_bias, avctx->qmin,
869                           31, 1);
870         ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
871                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
872                           31, 0);
873     }
874
875 #if FF_API_RC_STRATEGY
876 FF_DISABLE_DEPRECATION_WARNINGS
877     if (!s->rc_strategy)
878         s->rc_strategy = s->avctx->rc_strategy;
879 FF_ENABLE_DEPRECATION_WARNINGS
880 #endif
881
882     if (ff_rate_control_init(s) < 0)
883         return -1;
884
885     if ((s->avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1) {
886 #if CONFIG_LIBXVID
887         ret = ff_xvid_rate_control_init(s);
888 #else
889         ret = AVERROR(ENOSYS);
890         av_log(s->avctx, AV_LOG_ERROR,
891                "Xvid ratecontrol requires libavcodec compiled with Xvid support.\n");
892 #endif
893         if (ret < 0)
894             return ret;
895     }
896
897 #if FF_API_ERROR_RATE
898     FF_DISABLE_DEPRECATION_WARNINGS
899     if (avctx->error_rate)
900         s->error_rate = avctx->error_rate;
901     FF_ENABLE_DEPRECATION_WARNINGS;
902 #endif
903
904 #if FF_API_NORMALIZE_AQP
905     FF_DISABLE_DEPRECATION_WARNINGS
906     if (avctx->flags & CODEC_FLAG_NORMALIZE_AQP)
907         s->mpv_flags |= FF_MPV_FLAG_NAQ;
908     FF_ENABLE_DEPRECATION_WARNINGS;
909 #endif
910
911 #if FF_API_MV0
912     FF_DISABLE_DEPRECATION_WARNINGS
913     if (avctx->flags & CODEC_FLAG_MV0)
914         s->mpv_flags |= FF_MPV_FLAG_MV0;
915     FF_ENABLE_DEPRECATION_WARNINGS
916 #endif
917
918 #if FF_API_MPV_OPT
919     FF_DISABLE_DEPRECATION_WARNINGS
920     if (avctx->rc_qsquish != 0.0)
921         s->rc_qsquish = avctx->rc_qsquish;
922     if (avctx->rc_qmod_amp != 0.0)
923         s->rc_qmod_amp = avctx->rc_qmod_amp;
924     if (avctx->rc_qmod_freq)
925         s->rc_qmod_freq = avctx->rc_qmod_freq;
926     if (avctx->rc_buffer_aggressivity != 1.0)
927         s->rc_buffer_aggressivity = avctx->rc_buffer_aggressivity;
928     if (avctx->rc_initial_cplx != 0.0)
929         s->rc_initial_cplx = avctx->rc_initial_cplx;
930     if (avctx->lmin)
931         s->lmin = avctx->lmin;
932     if (avctx->lmax)
933         s->lmax = avctx->lmax;
934
935     if (avctx->rc_eq) {
936         av_freep(&s->rc_eq);
937         s->rc_eq = av_strdup(avctx->rc_eq);
938         if (!s->rc_eq)
939             return AVERROR(ENOMEM);
940     }
941     FF_ENABLE_DEPRECATION_WARNINGS
942 #endif
943
944 #if FF_API_PRIVATE_OPT
945     FF_DISABLE_DEPRECATION_WARNINGS
946     if (avctx->brd_scale)
947         s->brd_scale = avctx->brd_scale;
948
949     if (avctx->prediction_method)
950         s->pred = avctx->prediction_method + 1;
951     FF_ENABLE_DEPRECATION_WARNINGS
952 #endif
953
954     if (s->b_frame_strategy == 2) {
955         for (i = 0; i < s->max_b_frames + 2; i++) {
956             s->tmp_frames[i] = av_frame_alloc();
957             if (!s->tmp_frames[i])
958                 return AVERROR(ENOMEM);
959
960             s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
961             s->tmp_frames[i]->width  = s->width  >> s->brd_scale;
962             s->tmp_frames[i]->height = s->height >> s->brd_scale;
963
964             ret = av_frame_get_buffer(s->tmp_frames[i], 32);
965             if (ret < 0)
966                 return ret;
967         }
968     }
969
970     cpb_props = ff_add_cpb_side_data(avctx);
971     if (!cpb_props)
972         return AVERROR(ENOMEM);
973     cpb_props->max_bitrate = avctx->rc_max_rate;
974     cpb_props->min_bitrate = avctx->rc_min_rate;
975     cpb_props->avg_bitrate = avctx->bit_rate;
976     cpb_props->buffer_size = avctx->rc_buffer_size;
977
978     return 0;
979 fail:
980     ff_mpv_encode_end(avctx);
981     return AVERROR_UNKNOWN;
982 }
983
984 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
985 {
986     MpegEncContext *s = avctx->priv_data;
987     int i;
988
989     ff_rate_control_uninit(s);
990 #if CONFIG_LIBXVID
991     if ((avctx->flags & AV_CODEC_FLAG_PASS2) && s->rc_strategy == 1)
992         ff_xvid_rate_control_uninit(s);
993 #endif
994
995     ff_mpv_common_end(s);
996     if (CONFIG_MJPEG_ENCODER &&
997         s->out_format == FMT_MJPEG)
998         ff_mjpeg_encode_close(s);
999
1000     av_freep(&avctx->extradata);
1001
1002     for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1003         av_frame_free(&s->tmp_frames[i]);
1004
1005     ff_free_picture_tables(&s->new_picture);
1006     ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1007
1008     av_freep(&s->avctx->stats_out);
1009     av_freep(&s->ac_stats);
1010
1011     av_freep(&s->q_intra_matrix);
1012     av_freep(&s->q_inter_matrix);
1013     av_freep(&s->q_intra_matrix16);
1014     av_freep(&s->q_inter_matrix16);
1015     av_freep(&s->input_picture);
1016     av_freep(&s->reordered_input_picture);
1017     av_freep(&s->dct_offset);
1018
1019     return 0;
1020 }
1021
1022 static int get_sae(uint8_t *src, int ref, int stride)
1023 {
1024     int x,y;
1025     int acc = 0;
1026
1027     for (y = 0; y < 16; y++) {
1028         for (x = 0; x < 16; x++) {
1029             acc += FFABS(src[x + y * stride] - ref);
1030         }
1031     }
1032
1033     return acc;
1034 }
1035
1036 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1037                            uint8_t *ref, int stride)
1038 {
1039     int x, y, w, h;
1040     int acc = 0;
1041
1042     w = s->width  & ~15;
1043     h = s->height & ~15;
1044
1045     for (y = 0; y < h; y += 16) {
1046         for (x = 0; x < w; x += 16) {
1047             int offset = x + y * stride;
1048             int sad  = s->mecc.sad[0](NULL, src + offset, ref + offset,
1049                                       stride, 16);
1050             int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1051             int sae  = get_sae(src + offset, mean, stride);
1052
1053             acc += sae + 500 < sad;
1054         }
1055     }
1056     return acc;
1057 }
1058
1059 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1060 {
1061     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1062                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1063                             s->mb_stride, s->mb_height, s->b8_stride,
1064                             &s->linesize, &s->uvlinesize);
1065 }
1066
1067 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1068 {
1069     Picture *pic = NULL;
1070     int64_t pts;
1071     int i, display_picture_number = 0, ret;
1072     int encoding_delay = s->max_b_frames ? s->max_b_frames
1073                                          : (s->low_delay ? 0 : 1);
1074     int flush_offset = 1;
1075     int direct = 1;
1076
1077     if (pic_arg) {
1078         pts = pic_arg->pts;
1079         display_picture_number = s->input_picture_number++;
1080
1081         if (pts != AV_NOPTS_VALUE) {
1082             if (s->user_specified_pts != AV_NOPTS_VALUE) {
1083                 int64_t time = pts;
1084                 int64_t last = s->user_specified_pts;
1085
1086                 if (time <= last) {
1087                     av_log(s->avctx, AV_LOG_ERROR,
1088                            "Error, Invalid timestamp=%"PRId64", "
1089                            "last=%"PRId64"\n", pts, s->user_specified_pts);
1090                     return -1;
1091                 }
1092
1093                 if (!s->low_delay && display_picture_number == 1)
1094                     s->dts_delta = time - last;
1095             }
1096             s->user_specified_pts = pts;
1097         } else {
1098             if (s->user_specified_pts != AV_NOPTS_VALUE) {
1099                 s->user_specified_pts =
1100                 pts = s->user_specified_pts + 1;
1101                 av_log(s->avctx, AV_LOG_INFO,
1102                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1103                        pts);
1104             } else {
1105                 pts = display_picture_number;
1106             }
1107         }
1108
1109         if (!pic_arg->buf[0] ||
1110             pic_arg->linesize[0] != s->linesize ||
1111             pic_arg->linesize[1] != s->uvlinesize ||
1112             pic_arg->linesize[2] != s->uvlinesize)
1113             direct = 0;
1114         if ((s->width & 15) || (s->height & 15))
1115             direct = 0;
1116
1117         ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
1118                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1119
1120         i = ff_find_unused_picture(s->avctx, s->picture, direct);
1121         if (i < 0)
1122             return i;
1123
1124         pic = &s->picture[i];
1125         pic->reference = 3;
1126
1127         if (direct) {
1128             if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1129                 return ret;
1130         }
1131         ret = alloc_picture(s, pic, direct);
1132         if (ret < 0)
1133             return ret;
1134
1135         if (!direct) {
1136             if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1137                 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1138                 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1139                 // empty
1140             } else {
1141                 int h_chroma_shift, v_chroma_shift;
1142                 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1143                                                  &h_chroma_shift,
1144                                                  &v_chroma_shift);
1145
1146                 for (i = 0; i < 3; i++) {
1147                     int src_stride = pic_arg->linesize[i];
1148                     int dst_stride = i ? s->uvlinesize : s->linesize;
1149                     int h_shift = i ? h_chroma_shift : 0;
1150                     int v_shift = i ? v_chroma_shift : 0;
1151                     int w = s->width  >> h_shift;
1152                     int h = s->height >> v_shift;
1153                     uint8_t *src = pic_arg->data[i];
1154                     uint8_t *dst = pic->f->data[i];
1155
1156                     if (!s->avctx->rc_buffer_size)
1157                         dst += INPLACE_OFFSET;
1158
1159                     if (src_stride == dst_stride)
1160                         memcpy(dst, src, src_stride * h);
1161                     else {
1162                         int h2 = h;
1163                         uint8_t *dst2 = dst;
1164                         while (h2--) {
1165                             memcpy(dst2, src, w);
1166                             dst2 += dst_stride;
1167                             src += src_stride;
1168                         }
1169                     }
1170                     if ((s->width & 15) || (s->height & 15)) {
1171                         s->mpvencdsp.draw_edges(dst, dst_stride,
1172                                                 w, h,
1173                                                 16 >> h_shift,
1174                                                 16 >> v_shift,
1175                                                 EDGE_BOTTOM);
1176                     }
1177                 }
1178             }
1179         }
1180         ret = av_frame_copy_props(pic->f, pic_arg);
1181         if (ret < 0)
1182             return ret;
1183
1184         pic->f->display_picture_number = display_picture_number;
1185         pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1186     } else {
1187         /* Flushing: When we have not received enough input frames,
1188          * ensure s->input_picture[0] contains the first picture */
1189         for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1190             if (s->input_picture[flush_offset])
1191                 break;
1192
1193         if (flush_offset <= 1)
1194             flush_offset = 1;
1195         else
1196             encoding_delay = encoding_delay - flush_offset + 1;
1197     }
1198
1199     /* shift buffer entries */
1200     for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1201         s->input_picture[i - flush_offset] = s->input_picture[i];
1202
1203     s->input_picture[encoding_delay] = (Picture*) pic;
1204
1205     return 0;
1206 }
1207
1208 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1209 {
1210     int x, y, plane;
1211     int score = 0;
1212     int64_t score64 = 0;
1213
1214     for (plane = 0; plane < 3; plane++) {
1215         const int stride = p->f->linesize[plane];
1216         const int bw = plane ? 1 : 2;
1217         for (y = 0; y < s->mb_height * bw; y++) {
1218             for (x = 0; x < s->mb_width * bw; x++) {
1219                 int off = p->shared ? 0 : 16;
1220                 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1221                 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1222                 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1223
1224                 switch (s->frame_skip_exp) {
1225                 case 0: score    =  FFMAX(score, v);          break;
1226                 case 1: score   += FFABS(v);                  break;
1227                 case 2: score   += v * v;                     break;
1228                 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1229                 case 4: score64 += v * v * (int64_t)(v * v);  break;
1230                 }
1231             }
1232         }
1233     }
1234
1235     if (score)
1236         score64 = score;
1237
1238     if (score64 < s->frame_skip_threshold)
1239         return 1;
1240     if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1241         return 1;
1242     return 0;
1243 }
1244
1245 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1246 {
1247     AVPacket pkt = { 0 };
1248     int ret, got_output;
1249
1250     av_init_packet(&pkt);
1251     ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1252     if (ret < 0)
1253         return ret;
1254
1255     ret = pkt.size;
1256     av_packet_unref(&pkt);
1257     return ret;
1258 }
1259
1260 static int estimate_best_b_count(MpegEncContext *s)
1261 {
1262     AVCodec *codec    = avcodec_find_encoder(s->avctx->codec_id);
1263     AVCodecContext *c = avcodec_alloc_context3(NULL);
1264     const int scale = s->brd_scale;
1265     int i, j, out_size, p_lambda, b_lambda, lambda2;
1266     int64_t best_rd  = INT64_MAX;
1267     int best_b_count = -1;
1268
1269     if (!c)
1270         return AVERROR(ENOMEM);
1271     assert(scale >= 0 && scale <= 3);
1272
1273     //emms_c();
1274     //s->next_picture_ptr->quality;
1275     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1276     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1277     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1278     if (!b_lambda) // FIXME we should do this somewhere else
1279         b_lambda = p_lambda;
1280     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1281                FF_LAMBDA_SHIFT;
1282
1283     c->width        = s->width  >> scale;
1284     c->height       = s->height >> scale;
1285     c->flags        = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1286     c->flags       |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1287     c->mb_decision  = s->avctx->mb_decision;
1288     c->me_cmp       = s->avctx->me_cmp;
1289     c->mb_cmp       = s->avctx->mb_cmp;
1290     c->me_sub_cmp   = s->avctx->me_sub_cmp;
1291     c->pix_fmt      = AV_PIX_FMT_YUV420P;
1292     c->time_base    = s->avctx->time_base;
1293     c->max_b_frames = s->max_b_frames;
1294
1295     if (avcodec_open2(c, codec, NULL) < 0)
1296         return -1;
1297
1298     for (i = 0; i < s->max_b_frames + 2; i++) {
1299         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1300                                                 s->next_picture_ptr;
1301
1302         if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1303             pre_input = *pre_input_ptr;
1304
1305             if (!pre_input.shared && i) {
1306                 pre_input.f->data[0] += INPLACE_OFFSET;
1307                 pre_input.f->data[1] += INPLACE_OFFSET;
1308                 pre_input.f->data[2] += INPLACE_OFFSET;
1309             }
1310
1311             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1312                                        s->tmp_frames[i]->linesize[0],
1313                                        pre_input.f->data[0],
1314                                        pre_input.f->linesize[0],
1315                                        c->width, c->height);
1316             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1317                                        s->tmp_frames[i]->linesize[1],
1318                                        pre_input.f->data[1],
1319                                        pre_input.f->linesize[1],
1320                                        c->width >> 1, c->height >> 1);
1321             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1322                                        s->tmp_frames[i]->linesize[2],
1323                                        pre_input.f->data[2],
1324                                        pre_input.f->linesize[2],
1325                                        c->width >> 1, c->height >> 1);
1326         }
1327     }
1328
1329     for (j = 0; j < s->max_b_frames + 1; j++) {
1330         int64_t rd = 0;
1331
1332         if (!s->input_picture[j])
1333             break;
1334
1335         c->error[0] = c->error[1] = c->error[2] = 0;
1336
1337         s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1338         s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
1339
1340         out_size = encode_frame(c, s->tmp_frames[0]);
1341
1342         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1343
1344         for (i = 0; i < s->max_b_frames + 1; i++) {
1345             int is_p = i % (j + 1) == j || i == s->max_b_frames;
1346
1347             s->tmp_frames[i + 1]->pict_type = is_p ?
1348                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1349             s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
1350
1351             out_size = encode_frame(c, s->tmp_frames[i + 1]);
1352
1353             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1354         }
1355
1356         /* get the delayed frames */
1357         while (out_size) {
1358             out_size = encode_frame(c, NULL);
1359             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1360         }
1361
1362         rd += c->error[0] + c->error[1] + c->error[2];
1363
1364         if (rd < best_rd) {
1365             best_rd = rd;
1366             best_b_count = j;
1367         }
1368     }
1369
1370     avcodec_free_context(&c);
1371
1372     return best_b_count;
1373 }
1374
1375 static int select_input_picture(MpegEncContext *s)
1376 {
1377     int i, ret;
1378
1379     for (i = 1; i < MAX_PICTURE_COUNT; i++)
1380         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1381     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1382
1383     /* set next picture type & ordering */
1384     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1385         if (/*s->picture_in_gop_number >= s->gop_size ||*/
1386             !s->next_picture_ptr || s->intra_only) {
1387             s->reordered_input_picture[0] = s->input_picture[0];
1388             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1389             s->reordered_input_picture[0]->f->coded_picture_number =
1390                 s->coded_picture_number++;
1391         } else {
1392             int b_frames = 0;
1393
1394             if (s->frame_skip_threshold || s->frame_skip_factor) {
1395                 if (s->picture_in_gop_number < s->gop_size &&
1396                     skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1397                     // FIXME check that the gop check above is +-1 correct
1398                     av_frame_unref(s->input_picture[0]->f);
1399
1400                     emms_c();
1401                     ff_vbv_update(s, 0);
1402
1403                     goto no_output_pic;
1404                 }
1405             }
1406
1407             if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1408                 for (i = 0; i < s->max_b_frames + 1; i++) {
1409                     int pict_num = s->input_picture[0]->f->display_picture_number + i;
1410
1411                     if (pict_num >= s->rc_context.num_entries)
1412                         break;
1413                     if (!s->input_picture[i]) {
1414                         s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1415                         break;
1416                     }
1417
1418                     s->input_picture[i]->f->pict_type =
1419                         s->rc_context.entry[pict_num].new_pict_type;
1420                 }
1421             }
1422
1423             if (s->b_frame_strategy == 0) {
1424                 b_frames = s->max_b_frames;
1425                 while (b_frames && !s->input_picture[b_frames])
1426                     b_frames--;
1427             } else if (s->b_frame_strategy == 1) {
1428                 for (i = 1; i < s->max_b_frames + 1; i++) {
1429                     if (s->input_picture[i] &&
1430                         s->input_picture[i]->b_frame_score == 0) {
1431                         s->input_picture[i]->b_frame_score =
1432                             get_intra_count(s,
1433                                             s->input_picture[i    ]->f->data[0],
1434                                             s->input_picture[i - 1]->f->data[0],
1435                                             s->linesize) + 1;
1436                     }
1437                 }
1438                 for (i = 0; i < s->max_b_frames + 1; i++) {
1439                     if (!s->input_picture[i] ||
1440                         s->input_picture[i]->b_frame_score - 1 >
1441                             s->mb_num / s->b_sensitivity)
1442                         break;
1443                 }
1444
1445                 b_frames = FFMAX(0, i - 1);
1446
1447                 /* reset scores */
1448                 for (i = 0; i < b_frames + 1; i++) {
1449                     s->input_picture[i]->b_frame_score = 0;
1450                 }
1451             } else if (s->b_frame_strategy == 2) {
1452                 b_frames = estimate_best_b_count(s);
1453             }
1454
1455             emms_c();
1456
1457             for (i = b_frames - 1; i >= 0; i--) {
1458                 int type = s->input_picture[i]->f->pict_type;
1459                 if (type && type != AV_PICTURE_TYPE_B)
1460                     b_frames = i;
1461             }
1462             if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1463                 b_frames == s->max_b_frames) {
1464                 av_log(s->avctx, AV_LOG_ERROR,
1465                        "warning, too many B-frames in a row\n");
1466             }
1467
1468             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1469                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1470                     s->gop_size > s->picture_in_gop_number) {
1471                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
1472                 } else {
1473                     if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1474                         b_frames = 0;
1475                     s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1476                 }
1477             }
1478
1479             if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1480                 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1481                 b_frames--;
1482
1483             s->reordered_input_picture[0] = s->input_picture[b_frames];
1484             if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1485                 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1486             s->reordered_input_picture[0]->f->coded_picture_number =
1487                 s->coded_picture_number++;
1488             for (i = 0; i < b_frames; i++) {
1489                 s->reordered_input_picture[i + 1] = s->input_picture[i];
1490                 s->reordered_input_picture[i + 1]->f->pict_type =
1491                     AV_PICTURE_TYPE_B;
1492                 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1493                     s->coded_picture_number++;
1494             }
1495         }
1496     }
1497 no_output_pic:
1498     ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1499
1500     if (s->reordered_input_picture[0]) {
1501         s->reordered_input_picture[0]->reference =
1502            s->reordered_input_picture[0]->f->pict_type !=
1503                AV_PICTURE_TYPE_B ? 3 : 0;
1504
1505         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1506             return ret;
1507
1508         if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1509             // input is a shared pix, so we can't modify it -> allocate a new
1510             // one & ensure that the shared one is reuseable
1511
1512             Picture *pic;
1513             int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1514             if (i < 0)
1515                 return i;
1516             pic = &s->picture[i];
1517
1518             pic->reference = s->reordered_input_picture[0]->reference;
1519             if (alloc_picture(s, pic, 0) < 0) {
1520                 return -1;
1521             }
1522
1523             ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1524             if (ret < 0)
1525                 return ret;
1526
1527             /* mark us unused / free shared pic */
1528             av_frame_unref(s->reordered_input_picture[0]->f);
1529             s->reordered_input_picture[0]->shared = 0;
1530
1531             s->current_picture_ptr = pic;
1532         } else {
1533             // input is not a shared pix -> reuse buffer for current_pix
1534             s->current_picture_ptr = s->reordered_input_picture[0];
1535             for (i = 0; i < 4; i++) {
1536                 s->new_picture.f->data[i] += INPLACE_OFFSET;
1537             }
1538         }
1539         ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1540         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1541                                        s->current_picture_ptr)) < 0)
1542             return ret;
1543
1544         s->picture_number = s->new_picture.f->display_picture_number;
1545     }
1546     return 0;
1547 }
1548
1549 static void frame_end(MpegEncContext *s)
1550 {
1551     int i;
1552
1553     if (s->unrestricted_mv &&
1554         s->current_picture.reference &&
1555         !s->intra_only) {
1556         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1557         int hshift = desc->log2_chroma_w;
1558         int vshift = desc->log2_chroma_h;
1559         s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1560                                 s->h_edge_pos, s->v_edge_pos,
1561                                 EDGE_WIDTH, EDGE_WIDTH,
1562                                 EDGE_TOP | EDGE_BOTTOM);
1563         s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1564                                 s->h_edge_pos >> hshift,
1565                                 s->v_edge_pos >> vshift,
1566                                 EDGE_WIDTH >> hshift,
1567                                 EDGE_WIDTH >> vshift,
1568                                 EDGE_TOP | EDGE_BOTTOM);
1569         s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1570                                 s->h_edge_pos >> hshift,
1571                                 s->v_edge_pos >> vshift,
1572                                 EDGE_WIDTH >> hshift,
1573                                 EDGE_WIDTH >> vshift,
1574                                 EDGE_TOP | EDGE_BOTTOM);
1575     }
1576
1577     emms_c();
1578
1579     s->last_pict_type                 = s->pict_type;
1580     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1581     if (s->pict_type!= AV_PICTURE_TYPE_B)
1582         s->last_non_b_pict_type = s->pict_type;
1583
1584     if (s->encoding) {
1585         /* release non-reference frames */
1586         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1587             if (!s->picture[i].reference)
1588                 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1589         }
1590     }
1591
1592 #if FF_API_CODED_FRAME
1593 FF_DISABLE_DEPRECATION_WARNINGS
1594     av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1595 FF_ENABLE_DEPRECATION_WARNINGS
1596 #endif
1597 #if FF_API_ERROR_FRAME
1598 FF_DISABLE_DEPRECATION_WARNINGS
1599     memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1600            sizeof(s->current_picture.encoding_error));
1601 FF_ENABLE_DEPRECATION_WARNINGS
1602 #endif
1603 }
1604
1605 static void update_noise_reduction(MpegEncContext *s)
1606 {
1607     int intra, i;
1608
1609     for (intra = 0; intra < 2; intra++) {
1610         if (s->dct_count[intra] > (1 << 16)) {
1611             for (i = 0; i < 64; i++) {
1612                 s->dct_error_sum[intra][i] >>= 1;
1613             }
1614             s->dct_count[intra] >>= 1;
1615         }
1616
1617         for (i = 0; i < 64; i++) {
1618             s->dct_offset[intra][i] = (s->noise_reduction *
1619                                        s->dct_count[intra] +
1620                                        s->dct_error_sum[intra][i] / 2) /
1621                                       (s->dct_error_sum[intra][i] + 1);
1622         }
1623     }
1624 }
1625
1626 static int frame_start(MpegEncContext *s)
1627 {
1628     int ret;
1629
1630     /* mark & release old frames */
1631     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1632         s->last_picture_ptr != s->next_picture_ptr &&
1633         s->last_picture_ptr->f->buf[0]) {
1634         ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1635     }
1636
1637     s->current_picture_ptr->f->pict_type = s->pict_type;
1638     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1639
1640     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1641     if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1642                                    s->current_picture_ptr)) < 0)
1643         return ret;
1644
1645     if (s->pict_type != AV_PICTURE_TYPE_B) {
1646         s->last_picture_ptr = s->next_picture_ptr;
1647         if (!s->droppable)
1648             s->next_picture_ptr = s->current_picture_ptr;
1649     }
1650
1651     if (s->last_picture_ptr) {
1652         ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1653         if (s->last_picture_ptr->f->buf[0] &&
1654             (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1655                                        s->last_picture_ptr)) < 0)
1656             return ret;
1657     }
1658     if (s->next_picture_ptr) {
1659         ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1660         if (s->next_picture_ptr->f->buf[0] &&
1661             (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1662                                        s->next_picture_ptr)) < 0)
1663             return ret;
1664     }
1665
1666     if (s->picture_structure!= PICT_FRAME) {
1667         int i;
1668         for (i = 0; i < 4; i++) {
1669             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1670                 s->current_picture.f->data[i] +=
1671                     s->current_picture.f->linesize[i];
1672             }
1673             s->current_picture.f->linesize[i] *= 2;
1674             s->last_picture.f->linesize[i]    *= 2;
1675             s->next_picture.f->linesize[i]    *= 2;
1676         }
1677     }
1678
1679     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1680         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1681         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1682     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1683         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1684         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1685     } else {
1686         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1687         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1688     }
1689
1690     if (s->dct_error_sum) {
1691         assert(s->noise_reduction && s->encoding);
1692         update_noise_reduction(s);
1693     }
1694
1695     return 0;
1696 }
1697
1698 static void write_pass1_stats(MpegEncContext *s)
1699 {
1700     snprintf(s->avctx->stats_out, 256,
1701              "in:%d out:%d type:%d q:%d itex:%d ptex:%d mv:%d misc:%d "
1702              "fcode:%d bcode:%d mc-var:%d var:%d icount:%d skipcount:%d "
1703              "hbits:%d;\n",
1704              s->current_picture_ptr->f->display_picture_number,
1705              s->current_picture_ptr->f->coded_picture_number,
1706              s->pict_type,
1707              s->current_picture.f->quality,
1708              s->i_tex_bits,
1709              s->p_tex_bits,
1710              s->mv_bits,
1711              s->misc_bits,
1712              s->f_code,
1713              s->b_code,
1714              s->current_picture.mc_mb_var_sum,
1715              s->current_picture.mb_var_sum,
1716              s->i_count, s->skip_count,
1717              s->header_bits);
1718 }
1719
1720 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1721                           const AVFrame *pic_arg, int *got_packet)
1722 {
1723     MpegEncContext *s = avctx->priv_data;
1724     int i, stuffing_count, ret;
1725     int context_count = s->slice_context_count;
1726
1727     s->picture_in_gop_number++;
1728
1729     if (load_input_picture(s, pic_arg) < 0)
1730         return -1;
1731
1732     if (select_input_picture(s) < 0) {
1733         return -1;
1734     }
1735
1736     /* output? */
1737     if (s->new_picture.f->data[0]) {
1738         uint8_t *sd;
1739         if (!pkt->data &&
1740             (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1741             return ret;
1742         if (s->mb_info) {
1743             s->mb_info_ptr = av_packet_new_side_data(pkt,
1744                                  AV_PKT_DATA_H263_MB_INFO,
1745                                  s->mb_width*s->mb_height*12);
1746             s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1747         }
1748
1749         for (i = 0; i < context_count; i++) {
1750             int start_y = s->thread_context[i]->start_mb_y;
1751             int   end_y = s->thread_context[i]->  end_mb_y;
1752             int h       = s->mb_height;
1753             uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1754             uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);
1755
1756             init_put_bits(&s->thread_context[i]->pb, start, end - start);
1757         }
1758
1759         s->pict_type = s->new_picture.f->pict_type;
1760         //emms_c();
1761         ret = frame_start(s);
1762         if (ret < 0)
1763             return ret;
1764 vbv_retry:
1765         if (encode_picture(s, s->picture_number) < 0)
1766             return -1;
1767
1768 #if FF_API_STAT_BITS
1769 FF_DISABLE_DEPRECATION_WARNINGS
1770         avctx->header_bits = s->header_bits;
1771         avctx->mv_bits     = s->mv_bits;
1772         avctx->misc_bits   = s->misc_bits;
1773         avctx->i_tex_bits  = s->i_tex_bits;
1774         avctx->p_tex_bits  = s->p_tex_bits;
1775         avctx->i_count     = s->i_count;
1776         // FIXME f/b_count in avctx
1777         avctx->p_count     = s->mb_num - s->i_count - s->skip_count;
1778         avctx->skip_count  = s->skip_count;
1779 FF_ENABLE_DEPRECATION_WARNINGS
1780 #endif
1781
1782         frame_end(s);
1783
1784         sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
1785                                      sizeof(int));
1786         if (!sd)
1787             return AVERROR(ENOMEM);
1788         *(int *)sd = s->current_picture.f->quality;
1789
1790         if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1791             ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1792
1793         if (avctx->rc_buffer_size) {
1794             RateControlContext *rcc = &s->rc_context;
1795             int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1796
1797             if (put_bits_count(&s->pb) > max_size &&
1798                 s->lambda < s->lmax) {
1799                 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1800                                        (s->qscale + 1) / s->qscale);
1801                 if (s->adaptive_quant) {
1802                     int i;
1803                     for (i = 0; i < s->mb_height * s->mb_stride; i++)
1804                         s->lambda_table[i] =
1805                             FFMAX(s->lambda_table[i] + 1,
1806                                   s->lambda_table[i] * (s->qscale + 1) /
1807                                   s->qscale);
1808                 }
1809                 s->mb_skipped = 0;        // done in frame_start()
1810                 // done in encode_picture() so we must undo it
1811                 if (s->pict_type == AV_PICTURE_TYPE_P) {
1812                     if (s->flipflop_rounding          ||
1813                         s->codec_id == AV_CODEC_ID_H263P ||
1814                         s->codec_id == AV_CODEC_ID_MPEG4)
1815                         s->no_rounding ^= 1;
1816                 }
1817                 if (s->pict_type != AV_PICTURE_TYPE_B) {
1818                     s->time_base       = s->last_time_base;
1819                     s->last_non_b_time = s->time - s->pp_time;
1820                 }
1821                 for (i = 0; i < context_count; i++) {
1822                     PutBitContext *pb = &s->thread_context[i]->pb;
1823                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1824                 }
1825                 goto vbv_retry;
1826             }
1827
1828             assert(s->avctx->rc_max_rate);
1829         }
1830
1831         if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1832             write_pass1_stats(s);
1833
1834         for (i = 0; i < 4; i++) {
1835             s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1836             avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1837         }
1838
1839         if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1840             assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1841                                              s->misc_bits + s->i_tex_bits +
1842                                              s->p_tex_bits);
1843         flush_put_bits(&s->pb);
1844         s->frame_bits  = put_bits_count(&s->pb);
1845
1846         stuffing_count = ff_vbv_update(s, s->frame_bits);
1847         if (stuffing_count) {
1848             if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1849                     stuffing_count + 50) {
1850                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1851                 return -1;
1852             }
1853
1854             switch (s->codec_id) {
1855             case AV_CODEC_ID_MPEG1VIDEO:
1856             case AV_CODEC_ID_MPEG2VIDEO:
1857                 while (stuffing_count--) {
1858                     put_bits(&s->pb, 8, 0);
1859                 }
1860             break;
1861             case AV_CODEC_ID_MPEG4:
1862                 put_bits(&s->pb, 16, 0);
1863                 put_bits(&s->pb, 16, 0x1C3);
1864                 stuffing_count -= 4;
1865                 while (stuffing_count--) {
1866                     put_bits(&s->pb, 8, 0xFF);
1867                 }
1868             break;
1869             default:
1870                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1871             }
1872             flush_put_bits(&s->pb);
1873             s->frame_bits  = put_bits_count(&s->pb);
1874         }
1875
1876         /* update MPEG-1/2 vbv_delay for CBR */
1877         if (s->avctx->rc_max_rate                          &&
1878             s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1879             s->out_format == FMT_MPEG1                     &&
1880             90000LL * (avctx->rc_buffer_size - 1) <=
1881                 s->avctx->rc_max_rate * 0xFFFFLL) {
1882             AVCPBProperties *props;
1883             size_t props_size;
1884
1885             int vbv_delay, min_delay;
1886             double inbits  = s->avctx->rc_max_rate *
1887                              av_q2d(s->avctx->time_base);
1888             int    minbits = s->frame_bits - 8 *
1889                              (s->vbv_delay_ptr - s->pb.buf - 1);
1890             double bits    = s->rc_context.buffer_index + minbits - inbits;
1891
1892             if (bits < 0)
1893                 av_log(s->avctx, AV_LOG_ERROR,
1894                        "Internal error, negative bits\n");
1895
1896             assert(s->repeat_first_field == 0);
1897
1898             vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1899             min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1900                         s->avctx->rc_max_rate;
1901
1902             vbv_delay = FFMAX(vbv_delay, min_delay);
1903
1904             assert(vbv_delay < 0xFFFF);
1905
1906             s->vbv_delay_ptr[0] &= 0xF8;
1907             s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1908             s->vbv_delay_ptr[1]  = vbv_delay >> 5;
1909             s->vbv_delay_ptr[2] &= 0x07;
1910             s->vbv_delay_ptr[2] |= vbv_delay << 3;
1911
1912             props = av_cpb_properties_alloc(&props_size);
1913             if (!props)
1914                 return AVERROR(ENOMEM);
1915             props->vbv_delay = vbv_delay * 300;
1916
1917             ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
1918                                           (uint8_t*)props, props_size);
1919             if (ret < 0) {
1920                 av_freep(&props);
1921                 return ret;
1922             }
1923
1924 #if FF_API_VBV_DELAY
1925 FF_DISABLE_DEPRECATION_WARNINGS
1926             avctx->vbv_delay     = vbv_delay * 300;
1927 FF_ENABLE_DEPRECATION_WARNINGS
1928 #endif
1929         }
1930         s->total_bits     += s->frame_bits;
1931 #if FF_API_STAT_BITS
1932 FF_DISABLE_DEPRECATION_WARNINGS
1933         avctx->frame_bits  = s->frame_bits;
1934 FF_ENABLE_DEPRECATION_WARNINGS
1935 #endif
1936
1937
1938         pkt->pts = s->current_picture.f->pts;
1939         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1940             if (!s->current_picture.f->coded_picture_number)
1941                 pkt->dts = pkt->pts - s->dts_delta;
1942             else
1943                 pkt->dts = s->reordered_pts;
1944             s->reordered_pts = pkt->pts;
1945         } else
1946             pkt->dts = pkt->pts;
1947         if (s->current_picture.f->key_frame)
1948             pkt->flags |= AV_PKT_FLAG_KEY;
1949         if (s->mb_info)
1950             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1951     } else {
1952         s->frame_bits = 0;
1953     }
1954     assert((s->frame_bits & 7) == 0);
1955
1956     pkt->size = s->frame_bits / 8;
1957     *got_packet = !!pkt->size;
1958     return 0;
1959 }
1960
1961 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1962                                                 int n, int threshold)
1963 {
1964     static const char tab[64] = {
1965         3, 2, 2, 1, 1, 1, 1, 1,
1966         1, 1, 1, 1, 1, 1, 1, 1,
1967         1, 1, 1, 1, 1, 1, 1, 1,
1968         0, 0, 0, 0, 0, 0, 0, 0,
1969         0, 0, 0, 0, 0, 0, 0, 0,
1970         0, 0, 0, 0, 0, 0, 0, 0,
1971         0, 0, 0, 0, 0, 0, 0, 0,
1972         0, 0, 0, 0, 0, 0, 0, 0
1973     };
1974     int score = 0;
1975     int run = 0;
1976     int i;
1977     int16_t *block = s->block[n];
1978     const int last_index = s->block_last_index[n];
1979     int skip_dc;
1980
1981     if (threshold < 0) {
1982         skip_dc = 0;
1983         threshold = -threshold;
1984     } else
1985         skip_dc = 1;
1986
1987     /* Are all we could set to zero already zero? */
1988     if (last_index <= skip_dc - 1)
1989         return;
1990
1991     for (i = 0; i <= last_index; i++) {
1992         const int j = s->intra_scantable.permutated[i];
1993         const int level = FFABS(block[j]);
1994         if (level == 1) {
1995             if (skip_dc && i == 0)
1996                 continue;
1997             score += tab[run];
1998             run = 0;
1999         } else if (level > 1) {
2000             return;
2001         } else {
2002             run++;
2003         }
2004     }
2005     if (score >= threshold)
2006         return;
2007     for (i = skip_dc; i <= last_index; i++) {
2008         const int j = s->intra_scantable.permutated[i];
2009         block[j] = 0;
2010     }
2011     if (block[0])
2012         s->block_last_index[n] = 0;
2013     else
2014         s->block_last_index[n] = -1;
2015 }
2016
2017 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2018                                int last_index)
2019 {
2020     int i;
2021     const int maxlevel = s->max_qcoeff;
2022     const int minlevel = s->min_qcoeff;
2023     int overflow = 0;
2024
2025     if (s->mb_intra) {
2026         i = 1; // skip clipping of intra dc
2027     } else
2028         i = 0;
2029
2030     for (; i <= last_index; i++) {
2031         const int j = s->intra_scantable.permutated[i];
2032         int level = block[j];
2033
2034         if (level > maxlevel) {
2035             level = maxlevel;
2036             overflow++;
2037         } else if (level < minlevel) {
2038             level = minlevel;
2039             overflow++;
2040         }
2041
2042         block[j] = level;
2043     }
2044
2045     if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2046         av_log(s->avctx, AV_LOG_INFO,
2047                "warning, clipping %d dct coefficients to %d..%d\n",
2048                overflow, minlevel, maxlevel);
2049 }
2050
2051 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2052 {
2053     int x, y;
2054     // FIXME optimize
2055     for (y = 0; y < 8; y++) {
2056         for (x = 0; x < 8; x++) {
2057             int x2, y2;
2058             int sum = 0;
2059             int sqr = 0;
2060             int count = 0;
2061
2062             for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2063                 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2064                     int v = ptr[x2 + y2 * stride];
2065                     sum += v;
2066                     sqr += v * v;
2067                     count++;
2068                 }
2069             }
2070             weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2071         }
2072     }
2073 }
2074
2075 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2076                                                 int motion_x, int motion_y,
2077                                                 int mb_block_height,
2078                                                 int mb_block_count)
2079 {
2080     int16_t weight[8][64];
2081     int16_t orig[8][64];
2082     const int mb_x = s->mb_x;
2083     const int mb_y = s->mb_y;
2084     int i;
2085     int skip_dct[8];
2086     int dct_offset = s->linesize * 8; // default for progressive frames
2087     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2088     ptrdiff_t wrap_y, wrap_c;
2089
2090     for (i = 0; i < mb_block_count; i++)
2091         skip_dct[i] = s->skipdct;
2092
2093     if (s->adaptive_quant) {
2094         const int last_qp = s->qscale;
2095         const int mb_xy = mb_x + mb_y * s->mb_stride;
2096
2097         s->lambda = s->lambda_table[mb_xy];
2098         update_qscale(s);
2099
2100         if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2101             s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2102             s->dquant = s->qscale - last_qp;
2103
2104             if (s->out_format == FMT_H263) {
2105                 s->dquant = av_clip(s->dquant, -2, 2);
2106
2107                 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2108                     if (!s->mb_intra) {
2109                         if (s->pict_type == AV_PICTURE_TYPE_B) {
2110                             if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2111                                 s->dquant = 0;
2112                         }
2113                         if (s->mv_type == MV_TYPE_8X8)
2114                             s->dquant = 0;
2115                     }
2116                 }
2117             }
2118         }
2119         ff_set_qscale(s, last_qp + s->dquant);
2120     } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2121         ff_set_qscale(s, s->qscale + s->dquant);
2122
2123     wrap_y = s->linesize;
2124     wrap_c = s->uvlinesize;
2125     ptr_y  = s->new_picture.f->data[0] +
2126              (mb_y * 16 * wrap_y)              + mb_x * 16;
2127     ptr_cb = s->new_picture.f->data[1] +
2128              (mb_y * mb_block_height * wrap_c) + mb_x * 8;
2129     ptr_cr = s->new_picture.f->data[2] +
2130              (mb_y * mb_block_height * wrap_c) + mb_x * 8;
2131
2132     if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
2133         uint8_t *ebuf = s->sc.edge_emu_buffer + 32;
2134         s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2135                                  wrap_y, wrap_y,
2136                                  16, 16, mb_x * 16, mb_y * 16,
2137                                  s->width, s->height);
2138         ptr_y = ebuf;
2139         s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
2140                                  wrap_c, wrap_c,
2141                                  8, mb_block_height, mb_x * 8, mb_y * 8,
2142                                  s->width >> 1, s->height >> 1);
2143         ptr_cb = ebuf + 18 * wrap_y;
2144         s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
2145                                  wrap_c, wrap_c,
2146                                  8, mb_block_height, mb_x * 8, mb_y * 8,
2147                                  s->width >> 1, s->height >> 1);
2148         ptr_cr = ebuf + 18 * wrap_y + 8;
2149     }
2150
2151     if (s->mb_intra) {
2152         if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2153             int progressive_score, interlaced_score;
2154
2155             s->interlaced_dct = 0;
2156             progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2157                                 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2158                                                      NULL, wrap_y, 8) - 400;
2159
2160             if (progressive_score > 0) {
2161                 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2162                                                         NULL, wrap_y * 2, 8) +
2163                                    s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2164                                                         NULL, wrap_y * 2, 8);
2165                 if (progressive_score > interlaced_score) {
2166                     s->interlaced_dct = 1;
2167
2168                     dct_offset = wrap_y;
2169                     wrap_y <<= 1;
2170                     if (s->chroma_format == CHROMA_422)
2171                         wrap_c <<= 1;
2172                 }
2173             }
2174         }
2175
2176         s->pdsp.get_pixels(s->block[0], ptr_y,                  wrap_y);
2177         s->pdsp.get_pixels(s->block[1], ptr_y + 8,              wrap_y);
2178         s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset,     wrap_y);
2179         s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2180
2181         if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2182             skip_dct[4] = 1;
2183             skip_dct[5] = 1;
2184         } else {
2185             s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2186             s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2187             if (!s->chroma_y_shift) { /* 422 */
2188                 s->pdsp.get_pixels(s->block[6],
2189                                    ptr_cb + (dct_offset >> 1), wrap_c);
2190                 s->pdsp.get_pixels(s->block[7],
2191                                    ptr_cr + (dct_offset >> 1), wrap_c);
2192             }
2193         }
2194     } else {
2195         op_pixels_func (*op_pix)[4];
2196         qpel_mc_func (*op_qpix)[16];
2197         uint8_t *dest_y, *dest_cb, *dest_cr;
2198
2199         dest_y  = s->dest[0];
2200         dest_cb = s->dest[1];
2201         dest_cr = s->dest[2];
2202
2203         if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2204             op_pix  = s->hdsp.put_pixels_tab;
2205             op_qpix = s->qdsp.put_qpel_pixels_tab;
2206         } else {
2207             op_pix  = s->hdsp.put_no_rnd_pixels_tab;
2208             op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2209         }
2210
2211         if (s->mv_dir & MV_DIR_FORWARD) {
2212             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2213                           s->last_picture.f->data,
2214                           op_pix, op_qpix);
2215             op_pix  = s->hdsp.avg_pixels_tab;
2216             op_qpix = s->qdsp.avg_qpel_pixels_tab;
2217         }
2218         if (s->mv_dir & MV_DIR_BACKWARD) {
2219             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2220                           s->next_picture.f->data,
2221                           op_pix, op_qpix);
2222         }
2223
2224         if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2225             int progressive_score, interlaced_score;
2226
2227             s->interlaced_dct = 0;
2228             progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2229                                 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2230                                                      ptr_y + wrap_y * 8,
2231                                                      wrap_y, 8) - 400;
2232
2233             if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2234                 progressive_score -= 400;
2235
2236             if (progressive_score > 0) {
2237                 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2238                                                         wrap_y * 2, 8) +
2239                                    s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2240                                                         ptr_y + wrap_y,
2241                                                         wrap_y * 2, 8);
2242
2243                 if (progressive_score > interlaced_score) {
2244                     s->interlaced_dct = 1;
2245
2246                     dct_offset = wrap_y;
2247                     wrap_y <<= 1;
2248                     if (s->chroma_format == CHROMA_422)
2249                         wrap_c <<= 1;
2250                 }
2251             }
2252         }
2253
2254         s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2255         s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2256         s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2257                             dest_y + dct_offset, wrap_y);
2258         s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2259                             dest_y + dct_offset + 8, wrap_y);
2260
2261         if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2262             skip_dct[4] = 1;
2263             skip_dct[5] = 1;
2264         } else {
2265             s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2266             s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2267             if (!s->chroma_y_shift) { /* 422 */
2268                 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2269                                     dest_cb + (dct_offset >> 1), wrap_c);
2270                 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2271                                     dest_cr + (dct_offset >> 1), wrap_c);
2272             }
2273         }
2274         /* pre quantization */
2275         if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2276                 2 * s->qscale * s->qscale) {
2277             // FIXME optimize
2278             if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2279                 skip_dct[0] = 1;
2280             if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2281                 skip_dct[1] = 1;
2282             if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2283                                wrap_y, 8) < 20 * s->qscale)
2284                 skip_dct[2] = 1;
2285             if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2286                                wrap_y, 8) < 20 * s->qscale)
2287                 skip_dct[3] = 1;
2288             if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2289                 skip_dct[4] = 1;
2290             if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2291                 skip_dct[5] = 1;
2292             if (!s->chroma_y_shift) { /* 422 */
2293                 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2294                                    dest_cb + (dct_offset >> 1),
2295                                    wrap_c, 8) < 20 * s->qscale)
2296                     skip_dct[6] = 1;
2297                 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2298                                    dest_cr + (dct_offset >> 1),
2299                                    wrap_c, 8) < 20 * s->qscale)
2300                     skip_dct[7] = 1;
2301             }
2302         }
2303     }
2304
2305     if (s->quantizer_noise_shaping) {
2306         if (!skip_dct[0])
2307             get_visual_weight(weight[0], ptr_y                 , wrap_y);
2308         if (!skip_dct[1])
2309             get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
2310         if (!skip_dct[2])
2311             get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
2312         if (!skip_dct[3])
2313             get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2314         if (!skip_dct[4])
2315             get_visual_weight(weight[4], ptr_cb                , wrap_c);
2316         if (!skip_dct[5])
2317             get_visual_weight(weight[5], ptr_cr                , wrap_c);
2318         if (!s->chroma_y_shift) { /* 422 */
2319             if (!skip_dct[6])
2320                 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2321                                   wrap_c);
2322             if (!skip_dct[7])
2323                 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2324                                   wrap_c);
2325         }
2326         memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2327     }
2328
2329     /* DCT & quantize */
2330     assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2331     {
2332         for (i = 0; i < mb_block_count; i++) {
2333             if (!skip_dct[i]) {
2334                 int overflow;
2335                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2336                 // FIXME we could decide to change to quantizer instead of
2337                 // clipping
2338                 // JS: I don't think that would be a good idea it could lower
2339                 //     quality instead of improve it. Just INTRADC clipping
2340                 //     deserves changes in quantizer
2341                 if (overflow)
2342                     clip_coeffs(s, s->block[i], s->block_last_index[i]);
2343             } else
2344                 s->block_last_index[i] = -1;
2345         }
2346         if (s->quantizer_noise_shaping) {
2347             for (i = 0; i < mb_block_count; i++) {
2348                 if (!skip_dct[i]) {
2349                     s->block_last_index[i] =
2350                         dct_quantize_refine(s, s->block[i], weight[i],
2351                                             orig[i], i, s->qscale);
2352                 }
2353             }
2354         }
2355
2356         if (s->luma_elim_threshold && !s->mb_intra)
2357             for (i = 0; i < 4; i++)
2358                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2359         if (s->chroma_elim_threshold && !s->mb_intra)
2360             for (i = 4; i < mb_block_count; i++)
2361                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2362
2363         if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2364             for (i = 0; i < mb_block_count; i++) {
2365                 if (s->block_last_index[i] == -1)
2366                     s->coded_score[i] = INT_MAX / 256;
2367             }
2368         }
2369     }
2370
2371     if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2372         s->block_last_index[4] =
2373         s->block_last_index[5] = 0;
2374         s->block[4][0] =
2375         s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2376     }
2377
2378     // non c quantize code returns incorrect block_last_index FIXME
2379     if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2380         for (i = 0; i < mb_block_count; i++) {
2381             int j;
2382             if (s->block_last_index[i] > 0) {
2383                 for (j = 63; j > 0; j--) {
2384                     if (s->block[i][s->intra_scantable.permutated[j]])
2385                         break;
2386                 }
2387                 s->block_last_index[i] = j;
2388             }
2389         }
2390     }
2391
2392     /* huffman encode */
2393     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2394     case AV_CODEC_ID_MPEG1VIDEO:
2395     case AV_CODEC_ID_MPEG2VIDEO:
2396         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2397             ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2398         break;
2399     case AV_CODEC_ID_MPEG4:
2400         if (CONFIG_MPEG4_ENCODER)
2401             ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2402         break;
2403     case AV_CODEC_ID_MSMPEG4V2:
2404     case AV_CODEC_ID_MSMPEG4V3:
2405     case AV_CODEC_ID_WMV1:
2406         if (CONFIG_MSMPEG4_ENCODER)
2407             ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2408         break;
2409     case AV_CODEC_ID_WMV2:
2410         if (CONFIG_WMV2_ENCODER)
2411             ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2412         break;
2413     case AV_CODEC_ID_H261:
2414         if (CONFIG_H261_ENCODER)
2415             ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2416         break;
2417     case AV_CODEC_ID_H263:
2418     case AV_CODEC_ID_H263P:
2419     case AV_CODEC_ID_FLV1:
2420     case AV_CODEC_ID_RV10:
2421     case AV_CODEC_ID_RV20:
2422         if (CONFIG_H263_ENCODER)
2423             ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2424         break;
2425     case AV_CODEC_ID_MJPEG:
2426         if (CONFIG_MJPEG_ENCODER)
2427             ff_mjpeg_encode_mb(s, s->block);
2428         break;
2429     default:
2430         assert(0);
2431     }
2432 }
2433
2434 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2435 {
2436     if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
2437     else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
2438 }
2439
2440 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2441     int i;
2442
2443     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2444
2445     /* MPEG-1 */
2446     d->mb_skip_run= s->mb_skip_run;
2447     for(i=0; i<3; i++)
2448         d->last_dc[i] = s->last_dc[i];
2449
2450     /* statistics */
2451     d->mv_bits= s->mv_bits;
2452     d->i_tex_bits= s->i_tex_bits;
2453     d->p_tex_bits= s->p_tex_bits;
2454     d->i_count= s->i_count;
2455     d->f_count= s->f_count;
2456     d->b_count= s->b_count;
2457     d->skip_count= s->skip_count;
2458     d->misc_bits= s->misc_bits;
2459     d->last_bits= 0;
2460
2461     d->mb_skipped= 0;
2462     d->qscale= s->qscale;
2463     d->dquant= s->dquant;
2464
2465     d->esc3_level_length= s->esc3_level_length;
2466 }
2467
2468 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2469     int i;
2470
2471     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2472     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2473
2474     /* MPEG-1 */
2475     d->mb_skip_run= s->mb_skip_run;
2476     for(i=0; i<3; i++)
2477         d->last_dc[i] = s->last_dc[i];
2478
2479     /* statistics */
2480     d->mv_bits= s->mv_bits;
2481     d->i_tex_bits= s->i_tex_bits;
2482     d->p_tex_bits= s->p_tex_bits;
2483     d->i_count= s->i_count;
2484     d->f_count= s->f_count;
2485     d->b_count= s->b_count;
2486     d->skip_count= s->skip_count;
2487     d->misc_bits= s->misc_bits;
2488
2489     d->mb_intra= s->mb_intra;
2490     d->mb_skipped= s->mb_skipped;
2491     d->mv_type= s->mv_type;
2492     d->mv_dir= s->mv_dir;
2493     d->pb= s->pb;
2494     if(s->data_partitioning){
2495         d->pb2= s->pb2;
2496         d->tex_pb= s->tex_pb;
2497     }
2498     d->block= s->block;
2499     for(i=0; i<8; i++)
2500         d->block_last_index[i]= s->block_last_index[i];
2501     d->interlaced_dct= s->interlaced_dct;
2502     d->qscale= s->qscale;
2503
2504     d->esc3_level_length= s->esc3_level_length;
2505 }
2506
2507 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2508                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2509                            int *dmin, int *next_block, int motion_x, int motion_y)
2510 {
2511     int score;
2512     uint8_t *dest_backup[3];
2513
2514     copy_context_before_encode(s, backup, type);
2515
2516     s->block= s->blocks[*next_block];
2517     s->pb= pb[*next_block];
2518     if(s->data_partitioning){
2519         s->pb2   = pb2   [*next_block];
2520         s->tex_pb= tex_pb[*next_block];
2521     }
2522
2523     if(*next_block){
2524         memcpy(dest_backup, s->dest, sizeof(s->dest));
2525         s->dest[0] = s->sc.rd_scratchpad;
2526         s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2527         s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2528         assert(s->linesize >= 32); //FIXME
2529     }
2530
2531     encode_mb(s, motion_x, motion_y);
2532
2533     score= put_bits_count(&s->pb);
2534     if(s->data_partitioning){
2535         score+= put_bits_count(&s->pb2);
2536         score+= put_bits_count(&s->tex_pb);
2537     }
2538
2539     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2540         ff_mpv_decode_mb(s, s->block);
2541
2542         score *= s->lambda2;
2543         score += sse_mb(s) << FF_LAMBDA_SHIFT;
2544     }
2545
2546     if(*next_block){
2547         memcpy(s->dest, dest_backup, sizeof(s->dest));
2548     }
2549
2550     if(score<*dmin){
2551         *dmin= score;
2552         *next_block^=1;
2553
2554         copy_context_after_encode(best, s, type);
2555     }
2556 }
2557
2558 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2559     uint32_t *sq = ff_square_tab + 256;
2560     int acc=0;
2561     int x,y;
2562
2563     if(w==16 && h==16)
2564         return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2565     else if(w==8 && h==8)
2566         return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2567
2568     for(y=0; y<h; y++){
2569         for(x=0; x<w; x++){
2570             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2571         }
2572     }
2573
2574     assert(acc>=0);
2575
2576     return acc;
2577 }
2578
2579 static int sse_mb(MpegEncContext *s){
2580     int w= 16;
2581     int h= 16;
2582
2583     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2584     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2585
2586     if(w==16 && h==16)
2587       if(s->avctx->mb_cmp == FF_CMP_NSSE){
2588         return s->mecc.nsse[0](s, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize   * 16, s->dest[0], s->linesize,   16) +
2589                s->mecc.nsse[1](s, s->new_picture.f->data[1] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[1], s->uvlinesize,  8) +
2590                s->mecc.nsse[1](s, s->new_picture.f->data[2] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[2], s->uvlinesize,  8);
2591       }else{
2592         return s->mecc.sse[0](NULL, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize   * 16, s->dest[0], s->linesize,   16) +
2593                s->mecc.sse[1](NULL, s->new_picture.f->data[1] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[1], s->uvlinesize,  8) +
2594                s->mecc.sse[1](NULL, s->new_picture.f->data[2] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[2], s->uvlinesize,  8);
2595       }
2596     else
2597         return  sse(s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
2598                +sse(s, s->new_picture.f->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
2599                +sse(s, s->new_picture.f->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
2600 }
2601
2602 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2603     MpegEncContext *s= *(void**)arg;
2604
2605
2606     s->me.pre_pass=1;
2607     s->me.dia_size= s->avctx->pre_dia_size;
2608     s->first_slice_line=1;
2609     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2610         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2611             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2612         }
2613         s->first_slice_line=0;
2614     }
2615
2616     s->me.pre_pass=0;
2617
2618     return 0;
2619 }
2620
2621 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2622     MpegEncContext *s= *(void**)arg;
2623
2624     s->me.dia_size= s->avctx->dia_size;
2625     s->first_slice_line=1;
2626     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2627         s->mb_x=0; //for block init below
2628         ff_init_block_index(s);
2629         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2630             s->block_index[0]+=2;
2631             s->block_index[1]+=2;
2632             s->block_index[2]+=2;
2633             s->block_index[3]+=2;
2634
2635             /* compute motion vector & mb_type and store in context */
2636             if(s->pict_type==AV_PICTURE_TYPE_B)
2637                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2638             else
2639                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2640         }
2641         s->first_slice_line=0;
2642     }
2643     return 0;
2644 }
2645
2646 static int mb_var_thread(AVCodecContext *c, void *arg){
2647     MpegEncContext *s= *(void**)arg;
2648     int mb_x, mb_y;
2649
2650     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2651         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2652             int xx = mb_x * 16;
2653             int yy = mb_y * 16;
2654             uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2655             int varc;
2656             int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2657
2658             varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2659                     (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2660
2661             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2662             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2663             s->me.mb_var_sum_temp    += varc;
2664         }
2665     }
2666     return 0;
2667 }
2668
2669 static void write_slice_end(MpegEncContext *s){
2670     if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2671         if(s->partitioned_frame){
2672             ff_mpeg4_merge_partitions(s);
2673         }
2674
2675         ff_mpeg4_stuffing(&s->pb);
2676     }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2677         ff_mjpeg_encode_stuffing(&s->pb);
2678     }
2679
2680     avpriv_align_put_bits(&s->pb);
2681     flush_put_bits(&s->pb);
2682
2683     if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2684         s->misc_bits+= get_bits_diff(s);
2685 }
2686
2687 static void write_mb_info(MpegEncContext *s)
2688 {
2689     uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2690     int offset = put_bits_count(&s->pb);
2691     int mba  = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2692     int gobn = s->mb_y / s->gob_index;
2693     int pred_x, pred_y;
2694     if (CONFIG_H263_ENCODER)
2695         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2696     bytestream_put_le32(&ptr, offset);
2697     bytestream_put_byte(&ptr, s->qscale);
2698     bytestream_put_byte(&ptr, gobn);
2699     bytestream_put_le16(&ptr, mba);
2700     bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2701     bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2702     /* 4MV not implemented */
2703     bytestream_put_byte(&ptr, 0); /* hmv2 */
2704     bytestream_put_byte(&ptr, 0); /* vmv2 */
2705 }
2706
2707 static void update_mb_info(MpegEncContext *s, int startcode)
2708 {
2709     if (!s->mb_info)
2710         return;
2711     if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2712         s->mb_info_size += 12;
2713         s->prev_mb_info = s->last_mb_info;
2714     }
2715     if (startcode) {
2716         s->prev_mb_info = put_bits_count(&s->pb)/8;
2717         /* This might have incremented mb_info_size above, and we return without
2718          * actually writing any info into that slot yet. But in that case,
2719          * this will be called again at the start of the after writing the
2720          * start code, actually writing the mb info. */
2721         return;
2722     }
2723
2724     s->last_mb_info = put_bits_count(&s->pb)/8;
2725     if (!s->mb_info_size)
2726         s->mb_info_size += 12;
2727     write_mb_info(s);
2728 }
2729
2730 static int encode_thread(AVCodecContext *c, void *arg){
2731     MpegEncContext *s= *(void**)arg;
2732     int mb_x, mb_y;
2733     int chr_h= 16>>s->chroma_y_shift;
2734     int i, j;
2735     MpegEncContext best_s = { 0 }, backup_s;
2736     uint8_t bit_buf[2][MAX_MB_BYTES];
2737     uint8_t bit_buf2[2][MAX_MB_BYTES];
2738     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2739     PutBitContext pb[2], pb2[2], tex_pb[2];
2740
2741     for(i=0; i<2; i++){
2742         init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
2743         init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
2744         init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2745     }
2746
2747     s->last_bits= put_bits_count(&s->pb);
2748     s->mv_bits=0;
2749     s->misc_bits=0;
2750     s->i_tex_bits=0;
2751     s->p_tex_bits=0;
2752     s->i_count=0;
2753     s->f_count=0;
2754     s->b_count=0;
2755     s->skip_count=0;
2756
2757     for(i=0; i<3; i++){
2758         /* init last dc values */
2759         /* note: quant matrix value (8) is implied here */
2760         s->last_dc[i] = 128 << s->intra_dc_precision;
2761
2762         s->current_picture.encoding_error[i] = 0;
2763     }
2764     s->mb_skip_run = 0;
2765     memset(s->last_mv, 0, sizeof(s->last_mv));
2766
2767     s->last_mv_dir = 0;
2768
2769     switch(s->codec_id){
2770     case AV_CODEC_ID_H263:
2771     case AV_CODEC_ID_H263P:
2772     case AV_CODEC_ID_FLV1:
2773         if (CONFIG_H263_ENCODER)
2774             s->gob_index = H263_GOB_HEIGHT(s->height);
2775         break;
2776     case AV_CODEC_ID_MPEG4:
2777         if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2778             ff_mpeg4_init_partitions(s);
2779         break;
2780     }
2781
2782     s->resync_mb_x=0;
2783     s->resync_mb_y=0;
2784     s->first_slice_line = 1;
2785     s->ptr_lastgob = s->pb.buf;
2786     for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2787         s->mb_x=0;
2788         s->mb_y= mb_y;
2789
2790         ff_set_qscale(s, s->qscale);
2791         ff_init_block_index(s);
2792
2793         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2794             int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2795             int mb_type= s->mb_type[xy];
2796 //            int d;
2797             int dmin= INT_MAX;
2798             int dir;
2799
2800             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2801                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2802                 return -1;
2803             }
2804             if(s->data_partitioning){
2805                 if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
2806                    || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2807                     av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2808                     return -1;
2809                 }
2810             }
2811
2812             s->mb_x = mb_x;
2813             s->mb_y = mb_y;  // moved into loop, can get changed by H.261
2814             ff_update_block_index(s);
2815
2816             if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2817                 ff_h261_reorder_mb_index(s);
2818                 xy= s->mb_y*s->mb_stride + s->mb_x;
2819                 mb_type= s->mb_type[xy];
2820             }
2821
2822             /* write gob / video packet header  */
2823             if(s->rtp_mode){
2824                 int current_packet_size, is_gob_start;
2825
2826                 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2827
2828                 is_gob_start = s->rtp_payload_size &&
2829                                current_packet_size >= s->rtp_payload_size &&
2830                                mb_y + mb_x > 0;
2831
2832                 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2833
2834                 switch(s->codec_id){
2835                 case AV_CODEC_ID_H263:
2836                 case AV_CODEC_ID_H263P:
2837                     if(!s->h263_slice_structured)
2838                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2839                     break;
2840                 case AV_CODEC_ID_MPEG2VIDEO:
2841                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2842                 case AV_CODEC_ID_MPEG1VIDEO:
2843                     if(s->mb_skip_run) is_gob_start=0;
2844                     break;
2845                 }
2846
2847                 if(is_gob_start){
2848                     if(s->start_mb_y != mb_y || mb_x!=0){
2849                         write_slice_end(s);
2850
2851                         if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2852                             ff_mpeg4_init_partitions(s);
2853                         }
2854                     }
2855
2856                     assert((put_bits_count(&s->pb)&7) == 0);
2857                     current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2858
2859                     if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2860                         int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2861                         int d = 100 / s->error_rate;
2862                         if(r % d == 0){
2863                             current_packet_size=0;
2864                             s->pb.buf_ptr= s->ptr_lastgob;
2865                             assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2866                         }
2867                     }
2868
2869 #if FF_API_RTP_CALLBACK
2870 FF_DISABLE_DEPRECATION_WARNINGS
2871                     if (s->avctx->rtp_callback){
2872                         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2873                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2874                     }
2875 FF_ENABLE_DEPRECATION_WARNINGS
2876 #endif
2877                     update_mb_info(s, 1);
2878
2879                     switch(s->codec_id){
2880                     case AV_CODEC_ID_MPEG4:
2881                         if (CONFIG_MPEG4_ENCODER) {
2882                             ff_mpeg4_encode_video_packet_header(s);
2883                             ff_mpeg4_clean_buffers(s);
2884                         }
2885                     break;
2886                     case AV_CODEC_ID_MPEG1VIDEO:
2887                     case AV_CODEC_ID_MPEG2VIDEO:
2888                         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2889                             ff_mpeg1_encode_slice_header(s);
2890                             ff_mpeg1_clean_buffers(s);
2891                         }
2892                     break;
2893                     case AV_CODEC_ID_H263:
2894                     case AV_CODEC_ID_H263P:
2895                         if (CONFIG_H263_ENCODER)
2896                             ff_h263_encode_gob_header(s, mb_y);
2897                     break;
2898                     }
2899
2900                     if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
2901                         int bits= put_bits_count(&s->pb);
2902                         s->misc_bits+= bits - s->last_bits;
2903                         s->last_bits= bits;
2904                     }
2905
2906                     s->ptr_lastgob += current_packet_size;
2907                     s->first_slice_line=1;
2908                     s->resync_mb_x=mb_x;
2909                     s->resync_mb_y=mb_y;
2910                 }
2911             }
2912
2913             if(  (s->resync_mb_x   == s->mb_x)
2914                && s->resync_mb_y+1 == s->mb_y){
2915                 s->first_slice_line=0;
2916             }
2917
2918             s->mb_skipped=0;
2919             s->dquant=0; //only for QP_RD
2920
2921             update_mb_info(s, 0);
2922
2923             if (mb_type & (mb_type-1) || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) { // more than 1 MB type possible or FF_MPV_FLAG_QP_RD
2924                 int next_block=0;
2925                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2926
2927                 copy_context_before_encode(&backup_s, s, -1);
2928                 backup_s.pb= s->pb;
2929                 best_s.data_partitioning= s->data_partitioning;
2930                 best_s.partitioned_frame= s->partitioned_frame;
2931                 if(s->data_partitioning){
2932                     backup_s.pb2= s->pb2;
2933                     backup_s.tex_pb= s->tex_pb;
2934                 }
2935
2936                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2937                     s->mv_dir = MV_DIR_FORWARD;
2938                     s->mv_type = MV_TYPE_16X16;
2939                     s->mb_intra= 0;
2940                     s->mv[0][0][0] = s->p_mv_table[xy][0];
2941                     s->mv[0][0][1] = s->p_mv_table[xy][1];
2942                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2943                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2944                 }
2945                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2946                     s->mv_dir = MV_DIR_FORWARD;
2947                     s->mv_type = MV_TYPE_FIELD;
2948                     s->mb_intra= 0;
2949                     for(i=0; i<2; i++){
2950                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2951                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2952                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2953                     }
2954                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2955                                  &dmin, &next_block, 0, 0);
2956                 }
2957                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2958                     s->mv_dir = MV_DIR_FORWARD;
2959                     s->mv_type = MV_TYPE_16X16;
2960                     s->mb_intra= 0;
2961                     s->mv[0][0][0] = 0;
2962                     s->mv[0][0][1] = 0;
2963                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2964                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2965                 }
2966                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2967                     s->mv_dir = MV_DIR_FORWARD;
2968                     s->mv_type = MV_TYPE_8X8;
2969                     s->mb_intra= 0;
2970                     for(i=0; i<4; i++){
2971                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2972                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2973                     }
2974                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2975                                  &dmin, &next_block, 0, 0);
2976                 }
2977                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2978                     s->mv_dir = MV_DIR_FORWARD;
2979                     s->mv_type = MV_TYPE_16X16;
2980                     s->mb_intra= 0;
2981                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2982                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2983                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2984                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2985                 }
2986                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2987                     s->mv_dir = MV_DIR_BACKWARD;
2988                     s->mv_type = MV_TYPE_16X16;
2989                     s->mb_intra= 0;
2990                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2991                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2992                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2993                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2994                 }
2995                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2996                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2997                     s->mv_type = MV_TYPE_16X16;
2998                     s->mb_intra= 0;
2999                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3000                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3001                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3002                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3003                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3004                                  &dmin, &next_block, 0, 0);
3005                 }
3006                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3007                     s->mv_dir = MV_DIR_FORWARD;
3008                     s->mv_type = MV_TYPE_FIELD;
3009                     s->mb_intra= 0;
3010                     for(i=0; i<2; i++){
3011                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3012                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3013                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3014                     }
3015                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3016                                  &dmin, &next_block, 0, 0);
3017                 }
3018                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3019                     s->mv_dir = MV_DIR_BACKWARD;
3020                     s->mv_type = MV_TYPE_FIELD;
3021                     s->mb_intra= 0;
3022                     for(i=0; i<2; i++){
3023                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3024                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3025                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3026                     }
3027                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3028                                  &dmin, &next_block, 0, 0);
3029                 }
3030                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3031                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3032                     s->mv_type = MV_TYPE_FIELD;
3033                     s->mb_intra= 0;
3034                     for(dir=0; dir<2; dir++){
3035                         for(i=0; i<2; i++){
3036                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3037                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3038                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3039                         }
3040                     }
3041                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3042                                  &dmin, &next_block, 0, 0);
3043                 }
3044                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3045                     s->mv_dir = 0;
3046                     s->mv_type = MV_TYPE_16X16;
3047                     s->mb_intra= 1;
3048                     s->mv[0][0][0] = 0;
3049                     s->mv[0][0][1] = 0;
3050                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3051                                  &dmin, &next_block, 0, 0);
3052                     if(s->h263_pred || s->h263_aic){
3053                         if(best_s.mb_intra)
3054                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3055                         else
3056                             ff_clean_intra_table_entries(s); //old mode?
3057                     }
3058                 }
3059
3060                 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3061                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3062                         const int last_qp= backup_s.qscale;
3063                         int qpi, qp, dc[6];
3064                         int16_t ac[6][16];
3065                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3066                         static const int dquant_tab[4]={-1,1,-2,2};
3067
3068                         assert(backup_s.dquant == 0);
3069
3070                         //FIXME intra
3071                         s->mv_dir= best_s.mv_dir;
3072                         s->mv_type = MV_TYPE_16X16;
3073                         s->mb_intra= best_s.mb_intra;
3074                         s->mv[0][0][0] = best_s.mv[0][0][0];
3075                         s->mv[0][0][1] = best_s.mv[0][0][1];
3076                         s->mv[1][0][0] = best_s.mv[1][0][0];
3077                         s->mv[1][0][1] = best_s.mv[1][0][1];
3078
3079                         qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3080                         for(; qpi<4; qpi++){
3081                             int dquant= dquant_tab[qpi];
3082                             qp= last_qp + dquant;
3083                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3084                                 continue;
3085                             backup_s.dquant= dquant;
3086                             if(s->mb_intra && s->dc_val[0]){
3087                                 for(i=0; i<6; i++){
3088                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
3089                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3090                                 }
3091                             }
3092
3093                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3094                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3095                             if(best_s.qscale != qp){
3096                                 if(s->mb_intra && s->dc_val[0]){
3097                                     for(i=0; i<6; i++){
3098                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
3099                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3100                                     }
3101                                 }
3102                             }
3103                         }
3104                     }
3105                 }
3106                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3107                     int mx= s->b_direct_mv_table[xy][0];
3108                     int my= s->b_direct_mv_table[xy][1];
3109
3110                     backup_s.dquant = 0;
3111                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3112                     s->mb_intra= 0;
3113                     ff_mpeg4_set_direct_mv(s, mx, my);
3114                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3115                                  &dmin, &next_block, mx, my);
3116                 }
3117                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3118                     backup_s.dquant = 0;
3119                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3120                     s->mb_intra= 0;
3121                     ff_mpeg4_set_direct_mv(s, 0, 0);
3122                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3123                                  &dmin, &next_block, 0, 0);
3124                 }
3125                 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3126                     int coded=0;
3127                     for(i=0; i<6; i++)
3128                         coded |= s->block_last_index[i];
3129                     if(coded){
3130                         int mx,my;
3131                         memcpy(s->mv, best_s.mv, sizeof(s->mv));
3132                         if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3133                             mx=my=0; //FIXME find the one we actually used
3134                             ff_mpeg4_set_direct_mv(s, mx, my);
3135                         }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3136                             mx= s->mv[1][0][0];
3137                             my= s->mv[1][0][1];
3138                         }else{
3139                             mx= s->mv[0][0][0];
3140                             my= s->mv[0][0][1];
3141                         }
3142
3143                         s->mv_dir= best_s.mv_dir;
3144                         s->mv_type = best_s.mv_type;
3145                         s->mb_intra= 0;
3146 /*                        s->mv[0][0][0] = best_s.mv[0][0][0];
3147                         s->mv[0][0][1] = best_s.mv[0][0][1];
3148                         s->mv[1][0][0] = best_s.mv[1][0][0];
3149                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
3150                         backup_s.dquant= 0;
3151                         s->skipdct=1;
3152                         encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3153                                         &dmin, &next_block, mx, my);
3154                         s->skipdct=0;
3155                     }
3156                 }
3157
3158                 s->current_picture.qscale_table[xy] = best_s.qscale;
3159
3160                 copy_context_after_encode(s, &best_s, -1);
3161
3162                 pb_bits_count= put_bits_count(&s->pb);
3163                 flush_put_bits(&s->pb);
3164                 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3165                 s->pb= backup_s.pb;
3166
3167                 if(s->data_partitioning){
3168                     pb2_bits_count= put_bits_count(&s->pb2);
3169                     flush_put_bits(&s->pb2);
3170                     avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3171                     s->pb2= backup_s.pb2;
3172
3173                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
3174                     flush_put_bits(&s->tex_pb);
3175                     avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3176                     s->tex_pb= backup_s.tex_pb;
3177                 }
3178                 s->last_bits= put_bits_count(&s->pb);
3179
3180                 if (CONFIG_H263_ENCODER &&
3181                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3182                     ff_h263_update_motion_val(s);
3183
3184                 if(next_block==0){ //FIXME 16 vs linesize16
3185                     s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad                     , s->linesize  ,16);
3186                     s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
3187                     s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3188                 }
3189
3190                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3191                     ff_mpv_decode_mb(s, s->block);
3192             } else {
3193                 int motion_x = 0, motion_y = 0;
3194                 s->mv_type=MV_TYPE_16X16;
3195                 // only one MB-Type possible
3196
3197                 switch(mb_type){
3198                 case CANDIDATE_MB_TYPE_INTRA:
3199                     s->mv_dir = 0;
3200                     s->mb_intra= 1;
3201                     motion_x= s->mv[0][0][0] = 0;
3202                     motion_y= s->mv[0][0][1] = 0;
3203                     break;
3204                 case CANDIDATE_MB_TYPE_INTER:
3205                     s->mv_dir = MV_DIR_FORWARD;
3206                     s->mb_intra= 0;
3207                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3208                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3209                     break;
3210                 case CANDIDATE_MB_TYPE_INTER_I:
3211                     s->mv_dir = MV_DIR_FORWARD;
3212                     s->mv_type = MV_TYPE_FIELD;
3213                     s->mb_intra= 0;
3214                     for(i=0; i<2; i++){
3215                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3216                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3217                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3218                     }
3219                     break;
3220                 case CANDIDATE_MB_TYPE_INTER4V:
3221                     s->mv_dir = MV_DIR_FORWARD;
3222                     s->mv_type = MV_TYPE_8X8;
3223                     s->mb_intra= 0;
3224                     for(i=0; i<4; i++){
3225                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3226                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3227                     }
3228                     break;
3229                 case CANDIDATE_MB_TYPE_DIRECT:
3230                     if (CONFIG_MPEG4_ENCODER) {
3231                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3232                         s->mb_intra= 0;
3233                         motion_x=s->b_direct_mv_table[xy][0];
3234                         motion_y=s->b_direct_mv_table[xy][1];
3235                         ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3236                     }
3237                     break;
3238                 case CANDIDATE_MB_TYPE_DIRECT0:
3239                     if (CONFIG_MPEG4_ENCODER) {
3240                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3241                         s->mb_intra= 0;
3242                         ff_mpeg4_set_direct_mv(s, 0, 0);
3243                     }
3244                     break;
3245                 case CANDIDATE_MB_TYPE_BIDIR:
3246                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3247                     s->mb_intra= 0;
3248                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3249                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3250                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3251                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3252                     break;
3253                 case CANDIDATE_MB_TYPE_BACKWARD:
3254                     s->mv_dir = MV_DIR_BACKWARD;
3255                     s->mb_intra= 0;
3256                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3257                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3258                     break;
3259                 case CANDIDATE_MB_TYPE_FORWARD:
3260                     s->mv_dir = MV_DIR_FORWARD;
3261                     s->mb_intra= 0;
3262                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3263                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3264                     break;
3265                 case CANDIDATE_MB_TYPE_FORWARD_I:
3266                     s->mv_dir = MV_DIR_FORWARD;
3267                     s->mv_type = MV_TYPE_FIELD;
3268                     s->mb_intra= 0;
3269                     for(i=0; i<2; i++){
3270                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3271                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3272                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3273                     }
3274                     break;
3275                 case CANDIDATE_MB_TYPE_BACKWARD_I:
3276                     s->mv_dir = MV_DIR_BACKWARD;
3277                     s->mv_type = MV_TYPE_FIELD;
3278                     s->mb_intra= 0;
3279                     for(i=0; i<2; i++){
3280                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3281                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3282                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3283                     }
3284                     break;
3285                 case CANDIDATE_MB_TYPE_BIDIR_I:
3286                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3287                     s->mv_type = MV_TYPE_FIELD;
3288                     s->mb_intra= 0;
3289                     for(dir=0; dir<2; dir++){
3290                         for(i=0; i<2; i++){
3291                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3292                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3293                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3294                         }
3295                     }
3296                     break;
3297                 default:
3298                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3299                 }
3300
3301                 encode_mb(s, motion_x, motion_y);
3302
3303                 // RAL: Update last macroblock type
3304                 s->last_mv_dir = s->mv_dir;
3305
3306                 if (CONFIG_H263_ENCODER &&
3307                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3308                     ff_h263_update_motion_val(s);
3309
3310                 ff_mpv_decode_mb(s, s->block);
3311             }
3312
3313             /* clean the MV table in IPS frames for direct mode in B-frames */
3314             if(s->mb_intra /* && I,P,S_TYPE */){
3315                 s->p_mv_table[xy][0]=0;
3316                 s->p_mv_table[xy][1]=0;
3317             }
3318
3319             if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3320                 int w= 16;
3321                 int h= 16;