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