GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mpegvideo_enc.c Lines: 2012 2898 69.4 %
Date: 2020-07-11 02:49:52 Branches: 1180 1926 61.3 %

Line Branch Exec Source
1
/*
2
 * The simplest mpeg encoder (well, it was the simplest!)
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24
25
/*
26
 * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
27
 */
28
29
/**
30
 * @file
31
 * The simplest mpeg encoder (well, it was the simplest!).
32
 */
33
34
#include <stdint.h>
35
36
#include "libavutil/internal.h"
37
#include "libavutil/intmath.h"
38
#include "libavutil/mathematics.h"
39
#include "libavutil/pixdesc.h"
40
#include "libavutil/opt.h"
41
#include "avcodec.h"
42
#include "dct.h"
43
#include "idctdsp.h"
44
#include "mpeg12.h"
45
#include "mpegvideo.h"
46
#include "mpegvideodata.h"
47
#include "h261.h"
48
#include "h263.h"
49
#include "h263data.h"
50
#include "mjpegenc_common.h"
51
#include "mathops.h"
52
#include "mpegutils.h"
53
#include "mjpegenc.h"
54
#include "msmpeg4.h"
55
#include "pixblockdsp.h"
56
#include "qpeldsp.h"
57
#include "faandct.h"
58
#include "thread.h"
59
#include "aandcttab.h"
60
#include "flv.h"
61
#include "mpeg4video.h"
62
#include "internal.h"
63
#include "bytestream.h"
64
#include "wmv2.h"
65
#include "rv10.h"
66
#include "packet_internal.h"
67
#include "libxvid.h"
68
#include <limits.h>
69
#include "sp5x.h"
70
71
#define QUANT_BIAS_SHIFT 8
72
73
#define QMAT_SHIFT_MMX 16
74
#define QMAT_SHIFT 21
75
76
static int encode_picture(MpegEncContext *s, int picture_number);
77
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
78
static int sse_mb(MpegEncContext *s);
79
static void denoise_dct_c(MpegEncContext *s, int16_t *block);
80
static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
81
82
static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
83
static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
84
85
const AVOption ff_mpv_generic_options[] = {
86
    FF_MPV_COMMON_OPTS
87
    { NULL },
88
};
89
90
3712
void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
91
                       uint16_t (*qmat16)[2][64],
92
                       const uint16_t *quant_matrix,
93
                       int bias, int qmin, int qmax, int intra)
94
{
95
3712
    FDCTDSPContext *fdsp = &s->fdsp;
96
    int qscale;
97
3712
    int shift = 0;
98
99
100478
    for (qscale = qmin; qscale <= qmax; qscale++) {
100
        int i;
101
        int qscale2;
102
103
96766
        if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
104
96704
        else                 qscale2 = qscale << 1;
105
106
96766
        if (fdsp->fdct == ff_jpeg_fdct_islow_8  ||
107
#if CONFIG_FAANDCT
108
96466
            fdsp->fdct == ff_faandct            ||
109
#endif /* CONFIG_FAANDCT */
110
96466
            fdsp->fdct == ff_jpeg_fdct_islow_10) {
111
19500
            for (i = 0; i < 64; i++) {
112
19200
                const int j = s->idsp.idct_permutation[i];
113
19200
                int64_t den = (int64_t) qscale2 * quant_matrix[j];
114
                /* 16 <= qscale * quant_matrix[i] <= 7905
115
                 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
116
                 *             19952 <=              x  <= 249205026
117
                 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
118
                 *           3444240 >= (1 << 36) / (x) >= 275 */
119
120
19200
                qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
121
            }
122
96466
        } else if (fdsp->fdct == ff_fdct_ifast) {
123
6270290
            for (i = 0; i < 64; i++) {
124
6173824
                const int j = s->idsp.idct_permutation[i];
125
6173824
                int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
126
                /* 16 <= qscale * quant_matrix[i] <= 7905
127
                 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
128
                 *             19952 <=              x  <= 249205026
129
                 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
130
                 *           3444240 >= (1 << 36) / (x) >= 275 */
131
132
6173824
                qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
133
            }
134
        } else {
135
            for (i = 0; i < 64; i++) {
136
                const int j = s->idsp.idct_permutation[i];
137
                int64_t den = (int64_t) qscale2 * quant_matrix[j];
138
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
139
                 * Assume x = qscale * quant_matrix[i]
140
                 * So             16 <=              x  <= 7905
141
                 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
142
                 * so          32768 >= (1 << 19) / (x) >= 67 */
143
                qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
144
                //qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) /
145
                //                    (qscale * quant_matrix[i]);
146
                qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
147
148
                if (qmat16[qscale][0][i] == 0 ||
149
                    qmat16[qscale][0][i] == 128 * 256)
150
                    qmat16[qscale][0][i] = 128 * 256 - 1;
151
                qmat16[qscale][1][i] =
152
                    ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
153
                                qmat16[qscale][0][i]);
154
            }
155
        }
156
157
6197585
        for (i = intra; i < 64; i++) {
158
6100819
            int64_t max = 8191;
159
6100819
            if (fdsp->fdct == ff_fdct_ifast) {
160
6081769
                max = (8191LL * ff_aanscales[i]) >> 14;
161
            }
162
6100819
            while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
163
                shift++;
164
            }
165
        }
166
    }
167
3712
    if (shift) {
168
        av_log(s->avctx, AV_LOG_INFO,
169
               "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
170
               QMAT_SHIFT - shift);
171
    }
172
3712
}
173
174
1281842
static inline void update_qscale(MpegEncContext *s)
175
{
176
    if (s->q_scale_type == 1 && 0) {
177
        int i;
178
        int bestdiff=INT_MAX;
179
        int best = 1;
180
181
        for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
182
            int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
183
            if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
184
                (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
185
                continue;
186
            if (diff < bestdiff) {
187
                bestdiff = diff;
188
                best = i;
189
            }
190
        }
191
        s->qscale = best;
192
    } else {
193
1281842
        s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
194
                    (FF_LAMBDA_SHIFT + 7);
195
1281842
        s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
196
    }
197
198
1281842
    s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
199
                 FF_LAMBDA_SHIFT;
200
1281842
}
201
202
760
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
203
{
204
    int i;
205
206
760
    if (matrix) {
207
        put_bits(pb, 1, 1);
208
        for (i = 0; i < 64; i++) {
209
            put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
210
        }
211
    } else
212
760
        put_bits(pb, 1, 0);
213
760
}
214
215
/**
216
 * init s->current_picture.qscale_table from s->lambda_table
217
 */
218
800
void ff_init_qscale_tab(MpegEncContext *s)
219
{
220
800
    int8_t * const qscale_table = s->current_picture.qscale_table;
221
    int i;
222
223
240350
    for (i = 0; i < s->mb_num; i++) {
224
239550
        unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
225
239550
        int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
226
239550
        qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
227
239550
                                                  s->avctx->qmax);
228
    }
229
800
}
230
231
600
static void update_duplicate_context_after_me(MpegEncContext *dst,
232
                                              MpegEncContext *src)
233
{
234
#define COPY(a) dst->a= src->a
235
600
    COPY(pict_type);
236
600
    COPY(current_picture);
237
600
    COPY(f_code);
238
600
    COPY(b_code);
239
600
    COPY(qscale);
240
600
    COPY(lambda);
241
600
    COPY(lambda2);
242
600
    COPY(picture_in_gop_number);
243
600
    COPY(gop_picture_number);
244
600
    COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
245
600
    COPY(progressive_frame);    // FIXME don't set in encode_header
246
600
    COPY(partitioned_frame);    // FIXME don't set in encode_header
247
#undef COPY
248
600
}
249
250
/**
251
 * Set the given MpegEncContext to defaults for encoding.
252
 * the changed fields will not depend upon the prior state of the MpegEncContext.
253
 */
254
182
static void mpv_encode_defaults(MpegEncContext *s)
255
{
256
    int i;
257
182
    ff_mpv_common_defaults(s);
258
259
6006
    for (i = -16; i < 16; i++) {
260
5824
        default_fcode_tab[i + MAX_MV] = 1;
261
    }
262
182
    s->me.mv_penalty = default_mv_penalty;
263
182
    s->fcode_tab     = default_fcode_tab;
264
265
182
    s->input_picture_number  = 0;
266
182
    s->picture_in_gop_number = 0;
267
182
}
268
269
255
av_cold int ff_dct_encode_init(MpegEncContext *s)
270
{
271
    if (ARCH_X86)
272
255
        ff_dct_encode_init_x86(s);
273
274
    if (CONFIG_H263_ENCODER)
275
255
        ff_h263dsp_init(&s->h263dsp);
276
255
    if (!s->dct_quantize)
277
255
        s->dct_quantize = ff_dct_quantize_c;
278
255
    if (!s->denoise_dct)
279
255
        s->denoise_dct  = denoise_dct_c;
280
255
    s->fast_dct_quantize = s->dct_quantize;
281
255
    if (s->avctx->trellis)
282
35
        s->dct_quantize  = dct_quantize_trellis_c;
283
284
255
    return 0;
285
}
286
287
/* init video encoder */
288
182
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
289
{
290
182
    MpegEncContext *s = avctx->priv_data;
291
    AVCPBProperties *cpb_props;
292
    int i, ret, format_supported;
293
294
182
    mpv_encode_defaults(s);
295
296
182
    switch (avctx->codec_id) {
297
37
    case AV_CODEC_ID_MPEG2VIDEO:
298
37
        if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
299
5
            avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
300
            av_log(avctx, AV_LOG_ERROR,
301
                   "only YUV420 and YUV422 are supported\n");
302
            return AVERROR(EINVAL);
303
        }
304
37
        break;
305
30
    case AV_CODEC_ID_MJPEG:
306
    case AV_CODEC_ID_AMV:
307
30
        format_supported = 0;
308
        /* JPEG color space */
309
30
        if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
310
8
            avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
311
4
            avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
312
            (avctx->color_range == AVCOL_RANGE_JPEG &&
313
             (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
314
              avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
315
              avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
316
30
            format_supported = 1;
317
        /* MPEG color space */
318
        else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
319
                 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
320
                  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
321
                  avctx->pix_fmt == AV_PIX_FMT_YUV444P))
322
            format_supported = 1;
323
324
30
        if (!format_supported) {
325
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
326
            return AVERROR(EINVAL);
327
        }
328
30
        break;
329
115
    default:
330
115
        if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
331
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
332
            return AVERROR(EINVAL);
333
        }
334
    }
335
336
182
    switch (avctx->pix_fmt) {
337
4
    case AV_PIX_FMT_YUVJ444P:
338
    case AV_PIX_FMT_YUV444P:
339
4
        s->chroma_format = CHROMA_444;
340
4
        break;
341
9
    case AV_PIX_FMT_YUVJ422P:
342
    case AV_PIX_FMT_YUV422P:
343
9
        s->chroma_format = CHROMA_422;
344
9
        break;
345
169
    case AV_PIX_FMT_YUVJ420P:
346
    case AV_PIX_FMT_YUV420P:
347
    default:
348
169
        s->chroma_format = CHROMA_420;
349
169
        break;
350
    }
351
352
182
    avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
353
354
#if FF_API_PRIVATE_OPT
355
FF_DISABLE_DEPRECATION_WARNINGS
356
182
    if (avctx->rtp_payload_size)
357
        s->rtp_payload_size = avctx->rtp_payload_size;
358
182
    if (avctx->me_penalty_compensation)
359
182
        s->me_penalty_compensation = avctx->me_penalty_compensation;
360
182
    if (avctx->pre_me)
361
        s->me_pre = avctx->pre_me;
362
FF_ENABLE_DEPRECATION_WARNINGS
363
#endif
364
365
182
    s->bit_rate = avctx->bit_rate;
366
182
    s->width    = avctx->width;
367
182
    s->height   = avctx->height;
368
182
    if (avctx->gop_size > 600 &&
369
        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
370
        av_log(avctx, AV_LOG_WARNING,
371
               "keyframe interval too large!, reducing it from %d to %d\n",
372
               avctx->gop_size, 600);
373
        avctx->gop_size = 600;
374
    }
375
182
    s->gop_size     = avctx->gop_size;
376
182
    s->avctx        = avctx;
377
182
    if (avctx->max_b_frames > MAX_B_FRAMES) {
378
        av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
379
               "is %d.\n", MAX_B_FRAMES);
380
        avctx->max_b_frames = MAX_B_FRAMES;
381
    }
382
182
    s->max_b_frames = avctx->max_b_frames;
383
182
    s->codec_id     = avctx->codec->id;
384
182
    s->strict_std_compliance = avctx->strict_std_compliance;
385
182
    s->quarter_sample     = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
386
182
    s->rtp_mode           = !!s->rtp_payload_size;
387
182
    s->intra_dc_precision = avctx->intra_dc_precision;
388
389
    // workaround some differences between how applications specify dc precision
390
182
    if (s->intra_dc_precision < 0) {
391
        s->intra_dc_precision += 8;
392
182
    } else if (s->intra_dc_precision >= 8)
393
1
        s->intra_dc_precision -= 8;
394
395
182
    if (s->intra_dc_precision < 0) {
396
        av_log(avctx, AV_LOG_ERROR,
397
                "intra dc precision must be positive, note some applications use"
398
                " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
399
        return AVERROR(EINVAL);
400
    }
401
402

182
    if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
403
16
        s->huffman = 0;
404
405

182
    if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
406
        av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
407
        return AVERROR(EINVAL);
408
    }
409
182
    s->user_specified_pts = AV_NOPTS_VALUE;
410
411
182
    if (s->gop_size <= 1) {
412
1
        s->intra_only = 1;
413
1
        s->gop_size   = 12;
414
    } else {
415
181
        s->intra_only = 0;
416
    }
417
418
    /* Fixed QSCALE */
419
182
    s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
420
421
546
    s->adaptive_quant = (s->avctx->lumi_masking ||
422
182
                         s->avctx->dark_masking ||
423
182
                         s->avctx->temporal_cplx_masking ||
424
182
                         s->avctx->spatial_cplx_masking  ||
425
178
                         s->avctx->p_masking      ||
426
178
                         s->border_masking ||
427

376
                         (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
428
16
                        !s->fixed_qscale;
429
430
182
    s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
431
432

182
    if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
433
        switch(avctx->codec_id) {
434
        case AV_CODEC_ID_MPEG1VIDEO:
435
        case AV_CODEC_ID_MPEG2VIDEO:
436
            avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
437
            break;
438
        case AV_CODEC_ID_MPEG4:
439
        case AV_CODEC_ID_MSMPEG4V1:
440
        case AV_CODEC_ID_MSMPEG4V2:
441
        case AV_CODEC_ID_MSMPEG4V3:
442
            if       (avctx->rc_max_rate >= 15000000) {
443
                avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
444
            } else if(avctx->rc_max_rate >=  2000000) {
445
                avctx->rc_buffer_size =  80 + (avctx->rc_max_rate -  2000000LL) * (320- 80) / (15000000 -  2000000);
446
            } else if(avctx->rc_max_rate >=   384000) {
447
                avctx->rc_buffer_size =  40 + (avctx->rc_max_rate -   384000LL) * ( 80- 40) / ( 2000000 -   384000);
448
            } else
449
                avctx->rc_buffer_size = 40;
450
            avctx->rc_buffer_size *= 16384;
451
            break;
452
        }
453
        if (avctx->rc_buffer_size) {
454
            av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
455
        }
456
    }
457
458
182
    if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
459
        av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
460
        return AVERROR(EINVAL);
461
    }
462
463

182
    if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
464
        av_log(avctx, AV_LOG_INFO,
465
               "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
466
    }
467
468

182
    if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
469
        av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
470
        return AVERROR(EINVAL);
471
    }
472
473

182
    if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
474
        av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
475
        return AVERROR(EINVAL);
476
    }
477
478
182
    if (avctx->rc_max_rate &&
479
1
        avctx->rc_max_rate == avctx->bit_rate &&
480
1
        avctx->rc_max_rate != avctx->rc_min_rate) {
481
        av_log(avctx, AV_LOG_INFO,
482
               "impossible bitrate constraints, this will fail\n");
483
    }
484
485
182
    if (avctx->rc_buffer_size &&
486
1
        avctx->bit_rate * (int64_t)avctx->time_base.num >
487
1
            avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
488
        av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
489
        return AVERROR(EINVAL);
490
    }
491
492
182
    if (!s->fixed_qscale &&
493
32
        avctx->bit_rate * av_q2d(avctx->time_base) >
494
32
            avctx->bit_rate_tolerance) {
495
        av_log(avctx, AV_LOG_WARNING,
496
               "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
497
        avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
498
    }
499
500
182
    if (s->avctx->rc_max_rate &&
501
1
        s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
502
1
        (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
503
1
         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
504
1
        90000LL * (avctx->rc_buffer_size - 1) >
505
1
            s->avctx->rc_max_rate * 0xFFFFLL) {
506
        av_log(avctx, AV_LOG_INFO,
507
               "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
508
               "specified vbv buffer is too large for the given bitrate!\n");
509
    }
510
511

182
    if ((s->avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
512
        s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
513
        s->codec_id != AV_CODEC_ID_FLV1) {
514
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
515
        return AVERROR(EINVAL);
516
    }
517
518

182
    if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
519
        av_log(avctx, AV_LOG_ERROR,
520
               "OBMC is only supported with simple mb decision\n");
521
        return AVERROR(EINVAL);
522
    }
523
524

182
    if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
525
        av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
526
        return AVERROR(EINVAL);
527
    }
528
529
182
    if (s->max_b_frames                    &&
530
43
        s->codec_id != AV_CODEC_ID_MPEG4      &&
531
23
        s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
532
19
        s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
533
        av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
534
        return AVERROR(EINVAL);
535
    }
536
182
    if (s->max_b_frames < 0) {
537
        av_log(avctx, AV_LOG_ERROR,
538
               "max b frames must be 0 or positive for mpegvideo based encoders\n");
539
        return AVERROR(EINVAL);
540
    }
541
542
182
    if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
543
124
         s->codec_id == AV_CODEC_ID_H263  ||
544
118
         s->codec_id == AV_CODEC_ID_H263P) &&
545
67
        (avctx->sample_aspect_ratio.num > 255 ||
546
67
         avctx->sample_aspect_ratio.den > 255)) {
547
        av_log(avctx, AV_LOG_WARNING,
548
               "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
549
               avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
550
        av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
551
                   avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
552
    }
553
554
182
    if ((s->codec_id == AV_CODEC_ID_H263  ||
555
176
         s->codec_id == AV_CODEC_ID_H263P) &&
556
9
        (avctx->width  > 2048 ||
557
9
         avctx->height > 1152 )) {
558
        av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
559
        return AVERROR(EINVAL);
560
    }
561
182
    if ((s->codec_id == AV_CODEC_ID_H263  ||
562
176
         s->codec_id == AV_CODEC_ID_H263P) &&
563
9
        ((avctx->width &3) ||
564
9
         (avctx->height&3) )) {
565
        av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
566
        return AVERROR(EINVAL);
567
    }
568
569
182
    if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
570
11
        (avctx->width  > 4095 ||
571
11
         avctx->height > 4095 )) {
572
        av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
573
        return AVERROR(EINVAL);
574
    }
575
576
182
    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
577
37
        (avctx->width  > 16383 ||
578
37
         avctx->height > 16383 )) {
579
        av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
580
        return AVERROR(EINVAL);
581
    }
582
583
182
    if (s->codec_id == AV_CODEC_ID_RV10 &&
584
4
        (avctx->width &15 ||
585
4
         avctx->height&15 )) {
586
        av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
587
        return AVERROR(EINVAL);
588
    }
589
590
182
    if (s->codec_id == AV_CODEC_ID_RV20 &&
591
3
        (avctx->width &3 ||
592
3
         avctx->height&3 )) {
593
        av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
594
        return AVERROR(EINVAL);
595
    }
596
597
182
    if ((s->codec_id == AV_CODEC_ID_WMV1 ||
598
178
         s->codec_id == AV_CODEC_ID_WMV2) &&
599
8
         avctx->width & 1) {
600
        av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
601
        return AVERROR(EINVAL);
602
    }
603
604
182
    if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
605

17
        s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
606
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
607
        return AVERROR(EINVAL);
608
    }
609
610
#if FF_API_PRIVATE_OPT
611
    FF_DISABLE_DEPRECATION_WARNINGS
612
182
    if (avctx->mpeg_quant)
613
        s->mpeg_quant = avctx->mpeg_quant;
614
    FF_ENABLE_DEPRECATION_WARNINGS
615
#endif
616
617
    // FIXME mpeg2 uses that too
618

182
    if (s->mpeg_quant && (   s->codec_id != AV_CODEC_ID_MPEG4
619
                          && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
620
        av_log(avctx, AV_LOG_ERROR,
621
               "mpeg2 style quantization not supported by codec\n");
622
        return AVERROR(EINVAL);
623
    }
624
625

182
    if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
626
        av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
627
        return AVERROR(EINVAL);
628
    }
629
630
182
    if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
631
12
        s->avctx->mb_decision != FF_MB_DECISION_RD) {
632
        av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
633
        return AVERROR(EINVAL);
634
    }
635
636
182
    if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
637
12
            (s->codec_id == AV_CODEC_ID_AMV ||
638
12
             s->codec_id == AV_CODEC_ID_MJPEG)) {
639
        // Used to produce garbage with MJPEG.
640
        av_log(avctx, AV_LOG_ERROR,
641
               "QP RD is no longer compatible with MJPEG or AMV\n");
642
        return AVERROR(EINVAL);
643
    }
644
645
#if FF_API_PRIVATE_OPT
646
FF_DISABLE_DEPRECATION_WARNINGS
647
182
    if (avctx->scenechange_threshold)
648
        s->scenechange_threshold = avctx->scenechange_threshold;
649
FF_ENABLE_DEPRECATION_WARNINGS
650
#endif
651
652
182
    if (s->scenechange_threshold < 1000000000 &&
653
182
        (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
654
        av_log(avctx, AV_LOG_ERROR,
655
               "closed gop with scene change detection are not supported yet, "
656
               "set threshold to 1000000000\n");
657
        return AVERROR_PATCHWELCOME;
658
    }
659
660
182
    if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
661
1
        if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
662
            s->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
663
            av_log(avctx, AV_LOG_ERROR,
664
                   "low delay forcing is only available for mpeg2, "
665
                   "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
666
            return AVERROR(EINVAL);
667
        }
668
1
        if (s->max_b_frames != 0) {
669
            av_log(avctx, AV_LOG_ERROR,
670
                   "B-frames cannot be used with low delay\n");
671
            return AVERROR(EINVAL);
672
        }
673
    }
674
675
182
    if (s->q_scale_type == 1) {
676
1
        if (avctx->qmax > 28) {
677
            av_log(avctx, AV_LOG_ERROR,
678
                   "non linear quant only supports qmax <= 28 currently\n");
679
            return AVERROR_PATCHWELCOME;
680
        }
681
    }
682
683
182
    if (avctx->slices > 1 &&
684

12
        (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
685
        av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
686
        return AVERROR(EINVAL);
687
    }
688
689
182
    if (s->avctx->thread_count > 1         &&
690
12
        s->codec_id != AV_CODEC_ID_MPEG4      &&
691
8
        s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
692
8
        s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
693
        s->codec_id != AV_CODEC_ID_MJPEG      &&
694
        (s->codec_id != AV_CODEC_ID_H263P)) {
695
        av_log(avctx, AV_LOG_ERROR,
696
               "multi threaded encoding not supported by codec\n");
697
        return AVERROR_PATCHWELCOME;
698
    }
699
700
182
    if (s->avctx->thread_count < 1) {
701
        av_log(avctx, AV_LOG_ERROR,
702
               "automatic thread number detection not supported by codec, "
703
               "patch welcome\n");
704
        return AVERROR_PATCHWELCOME;
705
    }
706
707

182
    if (!avctx->time_base.den || !avctx->time_base.num) {
708
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
709
        return AVERROR(EINVAL);
710
    }
711
712
#if FF_API_PRIVATE_OPT
713
FF_DISABLE_DEPRECATION_WARNINGS
714
182
    if (avctx->b_frame_strategy)
715
        s->b_frame_strategy = avctx->b_frame_strategy;
716
182
    if (avctx->b_sensitivity != 40)
717
        s->b_sensitivity = avctx->b_sensitivity;
718
FF_ENABLE_DEPRECATION_WARNINGS
719
#endif
720
721

182
    if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
722
        av_log(avctx, AV_LOG_INFO,
723
               "notice: b_frame_strategy only affects the first pass\n");
724
        s->b_frame_strategy = 0;
725
    }
726
727
182
    i = av_gcd(avctx->time_base.den, avctx->time_base.num);
728
182
    if (i > 1) {
729
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
730
        avctx->time_base.den /= i;
731
        avctx->time_base.num /= i;
732
        //return -1;
733
    }
734
735


182
    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
736
        // (a + x * 3 / 8) / x
737
78
        s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
738
78
        s->inter_quant_bias = 0;
739
    } else {
740
104
        s->intra_quant_bias = 0;
741
        // (a - x / 4) / x
742
104
        s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
743
    }
744
745

182
    if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
746
        av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
747
        return AVERROR(EINVAL);
748
    }
749
750
182
    av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
751
752
182
    if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
753
58
        s->avctx->time_base.den > (1 << 16) - 1) {
754
        av_log(avctx, AV_LOG_ERROR,
755
               "timebase %d/%d not supported by MPEG 4 standard, "
756
               "the maximum admitted value for the timebase denominator "
757
               "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
758
               (1 << 16) - 1);
759
        return AVERROR(EINVAL);
760
    }
761
182
    s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
762
763



182
    switch (avctx->codec->id) {
764
11
    case AV_CODEC_ID_MPEG1VIDEO:
765
11
        s->out_format = FMT_MPEG1;
766
11
        s->low_delay  = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
767
11
        avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
768
11
        break;
769
37
    case AV_CODEC_ID_MPEG2VIDEO:
770
37
        s->out_format = FMT_MPEG1;
771
37
        s->low_delay  = !!(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
772
37
        avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
773
37
        s->rtp_mode   = 1;
774
37
        break;
775
30
    case AV_CODEC_ID_MJPEG:
776
    case AV_CODEC_ID_AMV:
777
30
        s->out_format = FMT_MJPEG;
778
30
        s->intra_only = 1; /* force intra only for jpeg */
779
        if (!CONFIG_MJPEG_ENCODER)
780
            return AVERROR_ENCODER_NOT_FOUND;
781
30
        if ((ret = ff_mjpeg_encode_init(s)) < 0)
782
            return ret;
783
30
        avctx->delay = 0;
784
30
        s->low_delay = 1;
785
30
        break;
786
6
    case AV_CODEC_ID_H261:
787
        if (!CONFIG_H261_ENCODER)
788
            return AVERROR_ENCODER_NOT_FOUND;
789
6
        if (ff_h261_get_picture_format(s->width, s->height) < 0) {
790
            av_log(avctx, AV_LOG_ERROR,
791
                   "The specified picture size of %dx%d is not valid for the "
792
                   "H.261 codec.\nValid sizes are 176x144, 352x288\n",
793
                    s->width, s->height);
794
            return AVERROR(EINVAL);
795
        }
796
6
        s->out_format = FMT_H261;
797
6
        avctx->delay  = 0;
798
6
        s->low_delay  = 1;
799
6
        s->rtp_mode   = 0; /* Sliced encoding not supported */
800
6
        break;
801
6
    case AV_CODEC_ID_H263:
802
        if (!CONFIG_H263_ENCODER)
803
            return AVERROR_ENCODER_NOT_FOUND;
804
6
        if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
805
                             s->width, s->height) == 8) {
806
            av_log(avctx, AV_LOG_ERROR,
807
                   "The specified picture size of %dx%d is not valid for "
808
                   "the H.263 codec.\nValid sizes are 128x96, 176x144, "
809
                   "352x288, 704x576, and 1408x1152. "
810
                   "Try H.263+.\n", s->width, s->height);
811
            return AVERROR(EINVAL);
812
        }
813
6
        s->out_format = FMT_H263;
814
6
        avctx->delay  = 0;
815
6
        s->low_delay  = 1;
816
6
        break;
817
3
    case AV_CODEC_ID_H263P:
818
3
        s->out_format = FMT_H263;
819
3
        s->h263_plus  = 1;
820
        /* Fx */
821
3
        s->h263_aic        = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
822
3
        s->modified_quant  = s->h263_aic;
823
3
        s->loop_filter     = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
824

3
        s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
825
826
        /* /Fx */
827
        /* These are just to be sure */
828
3
        avctx->delay = 0;
829
3
        s->low_delay = 1;
830
3
        break;
831
7
    case AV_CODEC_ID_FLV1:
832
7
        s->out_format      = FMT_H263;
833
7
        s->h263_flv        = 2; /* format = 1; 11-bit codes */
834
7
        s->unrestricted_mv = 1;
835
7
        s->rtp_mode  = 0; /* don't allow GOB */
836
7
        avctx->delay = 0;
837
7
        s->low_delay = 1;
838
7
        break;
839
4
    case AV_CODEC_ID_RV10:
840
4
        s->out_format = FMT_H263;
841
4
        avctx->delay  = 0;
842
4
        s->low_delay  = 1;
843
4
        break;
844
3
    case AV_CODEC_ID_RV20:
845
3
        s->out_format      = FMT_H263;
846
3
        avctx->delay       = 0;
847
3
        s->low_delay       = 1;
848
3
        s->modified_quant  = 1;
849
3
        s->h263_aic        = 1;
850
3
        s->h263_plus       = 1;
851
3
        s->loop_filter     = 1;
852
3
        s->unrestricted_mv = 0;
853
3
        break;
854
58
    case AV_CODEC_ID_MPEG4:
855
58
        s->out_format      = FMT_H263;
856
58
        s->h263_pred       = 1;
857
58
        s->unrestricted_mv = 1;
858
58
        s->low_delay       = s->max_b_frames ? 0 : 1;
859
58
        avctx->delay       = s->low_delay ? 0 : (s->max_b_frames + 1);
860
58
        break;
861
4
    case AV_CODEC_ID_MSMPEG4V2:
862
4
        s->out_format      = FMT_H263;
863
4
        s->h263_pred       = 1;
864
4
        s->unrestricted_mv = 1;
865
4
        s->msmpeg4_version = 2;
866
4
        avctx->delay       = 0;
867
4
        s->low_delay       = 1;
868
4
        break;
869
5
    case AV_CODEC_ID_MSMPEG4V3:
870
5
        s->out_format        = FMT_H263;
871
5
        s->h263_pred         = 1;
872
5
        s->unrestricted_mv   = 1;
873
5
        s->msmpeg4_version   = 3;
874
5
        s->flipflop_rounding = 1;
875
5
        avctx->delay         = 0;
876
5
        s->low_delay         = 1;
877
5
        break;
878
4
    case AV_CODEC_ID_WMV1:
879
4
        s->out_format        = FMT_H263;
880
4
        s->h263_pred         = 1;
881
4
        s->unrestricted_mv   = 1;
882
4
        s->msmpeg4_version   = 4;
883
4
        s->flipflop_rounding = 1;
884
4
        avctx->delay         = 0;
885
4
        s->low_delay         = 1;
886
4
        break;
887
4
    case AV_CODEC_ID_WMV2:
888
4
        s->out_format        = FMT_H263;
889
4
        s->h263_pred         = 1;
890
4
        s->unrestricted_mv   = 1;
891
4
        s->msmpeg4_version   = 5;
892
4
        s->flipflop_rounding = 1;
893
4
        avctx->delay         = 0;
894
4
        s->low_delay         = 1;
895
4
        break;
896
    default:
897
        return AVERROR(EINVAL);
898
    }
899
900
#if FF_API_PRIVATE_OPT
901
    FF_DISABLE_DEPRECATION_WARNINGS
902
182
    if (avctx->noise_reduction)
903
        s->noise_reduction = avctx->noise_reduction;
904
    FF_ENABLE_DEPRECATION_WARNINGS
905
#endif
906
907
182
    avctx->has_b_frames = !s->low_delay;
908
909
182
    s->encoding = 1;
910
911
182
    s->progressive_frame    =
912
347
    s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
913
                                                AV_CODEC_FLAG_INTERLACED_ME) ||
914
165
                                s->alternate_scan);
915
916
    /* init */
917
182
    ff_mpv_idct_init(s);
918
182
    if ((ret = ff_mpv_common_init(s)) < 0)
919
        return ret;
920
921
182
    ff_fdctdsp_init(&s->fdsp, avctx);
922
182
    ff_me_cmp_init(&s->mecc, avctx);
923
182
    ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
924
182
    ff_pixblockdsp_init(&s->pdsp, avctx);
925
182
    ff_qpeldsp_init(&s->qdsp);
926
927
182
    if (s->msmpeg4_version) {
928
17
        int ac_stats_size = 2 * 2 * (MAX_LEVEL + 1) *  (MAX_RUN + 1) * 2 * sizeof(int);
929
17
        if (!(s->ac_stats = av_mallocz(ac_stats_size)))
930
            return AVERROR(ENOMEM);
931
    }
932
933
182
    if (!(s->avctx->stats_out = av_mallocz(256))               ||
934
182
        !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix,          32) ||
935
182
        !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix,   32) ||
936
182
        !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix,          32) ||
937
182
        !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix16,        32) ||
938
182
        !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix16, 32) ||
939
182
        !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16,        32) ||
940
182
        !FF_ALLOCZ_TYPED_ARRAY(s->input_picture,           MAX_PICTURE_COUNT) ||
941
182
        !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_PICTURE_COUNT))
942
        return AVERROR(ENOMEM);
943
944
182
    if (s->noise_reduction) {
945
4
        if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_offset, 2))
946
            return AVERROR(ENOMEM);
947
    }
948
949
182
    ff_dct_encode_init(s);
950
951
182
    if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
952
6
        s->chroma_qscale_table = ff_h263_chroma_qscale_table;
953
954
182
    if (s->slice_context_count > 1) {
955
12
        s->rtp_mode = 1;
956
957
12
        if (avctx->codec_id == AV_CODEC_ID_H263P)
958
            s->h263_slice_structured = 1;
959
    }
960
961
182
    s->quant_precision = 5;
962
963
#if FF_API_PRIVATE_OPT
964
FF_DISABLE_DEPRECATION_WARNINGS
965
182
    if (avctx->frame_skip_threshold)
966
        s->frame_skip_threshold = avctx->frame_skip_threshold;
967
182
    if (avctx->frame_skip_factor)
968
        s->frame_skip_factor = avctx->frame_skip_factor;
969
182
    if (avctx->frame_skip_exp)
970
        s->frame_skip_exp = avctx->frame_skip_exp;
971
182
    if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
972
        s->frame_skip_cmp = avctx->frame_skip_cmp;
973
FF_ENABLE_DEPRECATION_WARNINGS
974
#endif
975
976
182
    ff_set_cmp(&s->mecc, s->mecc.ildct_cmp,      s->avctx->ildct_cmp);
977
182
    ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
978
979
182
    if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
980
6
        ff_h261_encode_init(s);
981
182
    if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
982
98
        ff_h263_encode_init(s);
983
182
    if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
984
17
        if ((ret = ff_msmpeg4_encode_init(s)) < 0)
985
            return ret;
986
182
    if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
987
182
        && s->out_format == FMT_MPEG1)
988
48
        ff_mpeg1_encode_init(s);
989
990
    /* init q matrix */
991
11830
    for (i = 0; i < 64; i++) {
992
11648
        int j = s->idsp.idct_permutation[i];
993
11648
        if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
994
3712
            s->mpeg_quant) {
995
            s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
996
            s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
997

11648
        } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
998
6656
            s->intra_matrix[j] =
999
6656
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1000
        } else {
1001
            /* MPEG-1/2 */
1002
4992
            s->chroma_intra_matrix[j] =
1003
4992
            s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1004
4992
            s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1005
        }
1006
11648
        if (s->avctx->intra_matrix)
1007
            s->intra_matrix[j] = s->avctx->intra_matrix[i];
1008
11648
        if (s->avctx->inter_matrix)
1009
            s->inter_matrix[j] = s->avctx->inter_matrix[i];
1010
    }
1011
1012
    /* precompute matrix */
1013
    /* for mjpeg, we do include qscale in the matrix */
1014
182
    if (s->out_format != FMT_MJPEG) {
1015
152
        ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
1016
152
                          s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1017
                          31, 1);
1018
152
        ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
1019
152
                          s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1020
                          31, 0);
1021
    }
1022
1023
182
    if ((ret = ff_rate_control_init(s)) < 0)
1024
        return ret;
1025
1026
#if FF_API_PRIVATE_OPT
1027
    FF_DISABLE_DEPRECATION_WARNINGS
1028
182
    if (avctx->brd_scale)
1029
        s->brd_scale = avctx->brd_scale;
1030
1031
182
    if (avctx->prediction_method)
1032
        s->pred = avctx->prediction_method + 1;
1033
    FF_ENABLE_DEPRECATION_WARNINGS
1034
#endif
1035
1036
182
    if (s->b_frame_strategy == 2) {
1037
        for (i = 0; i < s->max_b_frames + 2; i++) {
1038
            s->tmp_frames[i] = av_frame_alloc();
1039
            if (!s->tmp_frames[i])
1040
                return AVERROR(ENOMEM);
1041
1042
            s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1043
            s->tmp_frames[i]->width  = s->width  >> s->brd_scale;
1044
            s->tmp_frames[i]->height = s->height >> s->brd_scale;
1045
1046
            ret = av_frame_get_buffer(s->tmp_frames[i], 0);
1047
            if (ret < 0)
1048
                return ret;
1049
        }
1050
    }
1051
1052
182
    cpb_props = ff_add_cpb_side_data(avctx);
1053
182
    if (!cpb_props)
1054
        return AVERROR(ENOMEM);
1055
182
    cpb_props->max_bitrate = avctx->rc_max_rate;
1056
182
    cpb_props->min_bitrate = avctx->rc_min_rate;
1057
182
    cpb_props->avg_bitrate = avctx->bit_rate;
1058
182
    cpb_props->buffer_size = avctx->rc_buffer_size;
1059
1060
182
    return 0;
1061
}
1062
1063
182
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1064
{
1065
182
    MpegEncContext *s = avctx->priv_data;
1066
    int i;
1067
1068
182
    ff_rate_control_uninit(s);
1069
1070
182
    ff_mpv_common_end(s);
1071
182
    if (CONFIG_MJPEG_ENCODER &&
1072
182
        s->out_format == FMT_MJPEG)
1073
30
        ff_mjpeg_encode_close(s);
1074
1075
182
    av_freep(&avctx->extradata);
1076
1077
3458
    for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1078
3276
        av_frame_free(&s->tmp_frames[i]);
1079
1080
182
    ff_free_picture_tables(&s->new_picture);
1081
182
    ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1082
1083
182
    av_freep(&s->avctx->stats_out);
1084
182
    av_freep(&s->ac_stats);
1085
1086
182
    if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1087
182
    if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1088
182
    s->q_chroma_intra_matrix=   NULL;
1089
182
    s->q_chroma_intra_matrix16= NULL;
1090
182
    av_freep(&s->q_intra_matrix);
1091
182
    av_freep(&s->q_inter_matrix);
1092
182
    av_freep(&s->q_intra_matrix16);
1093
182
    av_freep(&s->q_inter_matrix16);
1094
182
    av_freep(&s->input_picture);
1095
182
    av_freep(&s->reordered_input_picture);
1096
182
    av_freep(&s->dct_offset);
1097
1098
182
    return 0;
1099
}
1100
1101
static int get_sae(uint8_t *src, int ref, int stride)
1102
{
1103
    int x,y;
1104
    int acc = 0;
1105
1106
    for (y = 0; y < 16; y++) {
1107
        for (x = 0; x < 16; x++) {
1108
            acc += FFABS(src[x + y * stride] - ref);
1109
        }
1110
    }
1111
1112
    return acc;
1113
}
1114
1115
static int get_intra_count(MpegEncContext *s, uint8_t *src,
1116
                           uint8_t *ref, int stride)
1117
{
1118
    int x, y, w, h;
1119
    int acc = 0;
1120
1121
    w = s->width  & ~15;
1122
    h = s->height & ~15;
1123
1124
    for (y = 0; y < h; y += 16) {
1125
        for (x = 0; x < w; x += 16) {
1126
            int offset = x + y * stride;
1127
            int sad  = s->mecc.sad[0](NULL, src + offset, ref + offset,
1128
                                      stride, 16);
1129
            int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1130
            int sae  = get_sae(src + offset, mean, stride);
1131
1132
            acc += sae + 500 < sad;
1133
        }
1134
    }
1135
    return acc;
1136
}
1137
1138
9007
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1139
{
1140
18014
    return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1141
9007
                            s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1142
                            s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1143
                            &s->linesize, &s->uvlinesize);
1144
}
1145
1146
8553
static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1147
{
1148
8553
    Picture *pic = NULL;
1149
    int64_t pts;
1150
8553
    int i, display_picture_number = 0, ret;
1151
17106
    int encoding_delay = s->max_b_frames ? s->max_b_frames
1152
8553
                                         : (s->low_delay ? 0 : 1);
1153
8553
    int flush_offset = 1;
1154
8553
    int direct = 1;
1155
1156
8553
    if (pic_arg) {
1157
8333
        pts = pic_arg->pts;
1158
8333
        display_picture_number = s->input_picture_number++;
1159
1160
8333
        if (pts != AV_NOPTS_VALUE) {
1161
8333
            if (s->user_specified_pts != AV_NOPTS_VALUE) {
1162
8151
                int64_t last = s->user_specified_pts;
1163
1164
8151
                if (pts <= last) {
1165
                    av_log(s->avctx, AV_LOG_ERROR,
1166
                           "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1167
                           pts, last);
1168
                    return AVERROR(EINVAL);
1169
                }
1170
1171

8151
                if (!s->low_delay && display_picture_number == 1)
1172
67
                    s->dts_delta = pts - last;
1173
            }
1174
8333
            s->user_specified_pts = pts;
1175
        } else {
1176
            if (s->user_specified_pts != AV_NOPTS_VALUE) {
1177
                s->user_specified_pts =
1178
                pts = s->user_specified_pts + 1;
1179
                av_log(s->avctx, AV_LOG_INFO,
1180
                       "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1181
                       pts);
1182
            } else {
1183
                pts = display_picture_number;
1184
            }
1185
        }
1186
1187
8333
        if (!pic_arg->buf[0] ||
1188
8333
            pic_arg->linesize[0] != s->linesize ||
1189
721
            pic_arg->linesize[1] != s->uvlinesize ||
1190
721
            pic_arg->linesize[2] != s->uvlinesize)
1191
7612
            direct = 0;
1192

8333
        if ((s->width & 15) || (s->height & 15))
1193
1625
            direct = 0;
1194
8333
        if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1195
150
            direct = 0;
1196
8333
        if (s->linesize & (STRIDE_ALIGN-1))
1197
            direct = 0;
1198
1199
        ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1200
                pic_arg->linesize[1], s->linesize, s->uvlinesize);
1201
1202
8333
        i = ff_find_unused_picture(s->avctx, s->picture, direct);
1203
8333
        if (i < 0)
1204
            return i;
1205
1206
8333
        pic = &s->picture[i];
1207
8333
        pic->reference = 3;
1208
1209
8333
        if (direct) {
1210
649
            if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1211
                return ret;
1212
        }
1213
8333
        ret = alloc_picture(s, pic, direct);
1214
8333
        if (ret < 0)
1215
            return ret;
1216
1217
8333
        if (!direct) {
1218
7684
            if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1219
                pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1220
                pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1221
                // empty
1222
            } else {
1223
                int h_chroma_shift, v_chroma_shift;
1224
7684
                av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1225
                                                 &h_chroma_shift,
1226
                                                 &v_chroma_shift);
1227
1228
30736
                for (i = 0; i < 3; i++) {
1229
23052
                    int src_stride = pic_arg->linesize[i];
1230
23052
                    int dst_stride = i ? s->uvlinesize : s->linesize;
1231
23052
                    int h_shift = i ? h_chroma_shift : 0;
1232
23052
                    int v_shift = i ? v_chroma_shift : 0;
1233
23052
                    int w = s->width  >> h_shift;
1234
23052
                    int h = s->height >> v_shift;
1235
23052
                    uint8_t *src = pic_arg->data[i];
1236
23052
                    uint8_t *dst = pic->f->data[i];
1237
23052
                    int vpad = 16;
1238
1239
23052
                    if (   s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1240
4530
                        && !s->progressive_sequence
1241
2475
                        && FFALIGN(s->height, 32) - s->height > 16)
1242
600
                        vpad = 32;
1243
1244
23052
                    if (!s->avctx->rc_buffer_size)
1245
22977
                        dst += INPLACE_OFFSET;
1246
1247
23052
                    if (src_stride == dst_stride)
1248
2389
                        memcpy(dst, src, src_stride * h);
1249
                    else {
1250
20663
                        int h2 = h;
1251
20663
                        uint8_t *dst2 = dst;
1252
3363707
                        while (h2--) {
1253
3343044
                            memcpy(dst2, src, w);
1254
3343044
                            dst2 += dst_stride;
1255
3343044
                            src += src_stride;
1256
                        }
1257
                    }
1258

23052
                    if ((s->width & 15) || (s->height & (vpad-1))) {
1259
4875
                        s->mpvencdsp.draw_edges(dst, dst_stride,
1260
                                                w, h,
1261
                                                16 >> h_shift,
1262
                                                vpad >> v_shift,
1263
                                                EDGE_BOTTOM);
1264
                    }
1265
                }
1266
7684
                emms_c();
1267
            }
1268
        }
1269
8333
        ret = av_frame_copy_props(pic->f, pic_arg);
1270
8333
        if (ret < 0)
1271
            return ret;
1272
1273
8333
        pic->f->display_picture_number = display_picture_number;
1274
8333
        pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1275
    } else {
1276
        /* Flushing: When we have not received enough input frames,
1277
         * ensure s->input_picture[0] contains the first picture */
1278
220
        for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1279
220
            if (s->input_picture[flush_offset])
1280
220
                break;
1281
1282
220
        if (flush_offset <= 1)
1283
220
            flush_offset = 1;
1284
        else
1285
            encoding_delay = encoding_delay - flush_offset + 1;
1286
    }
1287
1288
    /* shift buffer entries */
1289
307908
    for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1290
299355
        s->input_picture[i - flush_offset] = s->input_picture[i];
1291
1292
8553
    s->input_picture[encoding_delay] = (Picture*) pic;
1293
1294
8553
    return 0;
1295
}
1296
1297
static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1298
{
1299
    int x, y, plane;
1300
    int score = 0;
1301
    int64_t score64 = 0;
1302
1303
    for (plane = 0; plane < 3; plane++) {
1304
        const int stride = p->f->linesize[plane];
1305
        const int bw = plane ? 1 : 2;
1306
        for (y = 0; y < s->mb_height * bw; y++) {
1307
            for (x = 0; x < s->mb_width * bw; x++) {
1308
                int off = p->shared ? 0 : 16;
1309
                uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1310
                uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1311
                int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1312
1313
                switch (FFABS(s->frame_skip_exp)) {
1314
                case 0: score    =  FFMAX(score, v);          break;
1315
                case 1: score   += FFABS(v);                  break;
1316
                case 2: score64 += v * (int64_t)v;                       break;
1317
                case 3: score64 += FFABS(v * (int64_t)v * v);            break;
1318
                case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);  break;
1319
                }
1320
            }
1321
        }
1322
    }
1323
    emms_c();
1324
1325
    if (score)
1326
        score64 = score;
1327
    if (s->frame_skip_exp < 0)
1328
        score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1329
                      -1.0/s->frame_skip_exp);
1330
1331
    if (score64 < s->frame_skip_threshold)
1332
        return 1;
1333
    if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1334
        return 1;
1335
    return 0;
1336
}
1337
1338
static int encode_frame(AVCodecContext *c, AVFrame *frame)
1339
{
1340
    AVPacket pkt = { 0 };
1341
    int ret;
1342
    int size = 0;
1343
1344
    av_init_packet(&pkt);
1345
1346
    ret = avcodec_send_frame(c, frame);
1347
    if (ret < 0)
1348
        return ret;
1349
1350
    do {
1351
        ret = avcodec_receive_packet(c, &pkt);
1352
        if (ret >= 0) {
1353
            size += pkt.size;
1354
            av_packet_unref(&pkt);
1355
        } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1356
            return ret;
1357
    } while (ret >= 0);
1358
1359
    return size;
1360
}
1361
1362
static int estimate_best_b_count(MpegEncContext *s)
1363
{
1364
    const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1365
    const int scale = s->brd_scale;
1366
    int width  = s->width  >> scale;
1367
    int height = s->height >> scale;
1368
    int i, j, out_size, p_lambda, b_lambda, lambda2;
1369
    int64_t best_rd  = INT64_MAX;
1370
    int best_b_count = -1;
1371
    int ret = 0;
1372
1373
    av_assert0(scale >= 0 && scale <= 3);
1374
1375
    //emms_c();
1376
    //s->next_picture_ptr->quality;
1377
    p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1378
    //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1379
    b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1380
    if (!b_lambda) // FIXME we should do this somewhere else
1381
        b_lambda = p_lambda;
1382
    lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1383
               FF_LAMBDA_SHIFT;
1384
1385
    for (i = 0; i < s->max_b_frames + 2; i++) {
1386
        Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1387
                                                s->next_picture_ptr;
1388
        uint8_t *data[4];
1389
1390
        if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1391
            pre_input = *pre_input_ptr;
1392
            memcpy(data, pre_input_ptr->f->data, sizeof(data));
1393
1394
            if (!pre_input.shared && i) {
1395
                data[0] += INPLACE_OFFSET;
1396
                data[1] += INPLACE_OFFSET;
1397
                data[2] += INPLACE_OFFSET;
1398
            }
1399
1400
            s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1401
                                       s->tmp_frames[i]->linesize[0],
1402
                                       data[0],
1403
                                       pre_input.f->linesize[0],
1404
                                       width, height);
1405
            s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1406
                                       s->tmp_frames[i]->linesize[1],
1407
                                       data[1],
1408
                                       pre_input.f->linesize[1],
1409
                                       width >> 1, height >> 1);
1410
            s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1411
                                       s->tmp_frames[i]->linesize[2],
1412
                                       data[2],
1413
                                       pre_input.f->linesize[2],
1414
                                       width >> 1, height >> 1);
1415
        }
1416
    }
1417
1418
    for (j = 0; j < s->max_b_frames + 1; j++) {
1419
        AVCodecContext *c;
1420
        int64_t rd = 0;
1421
1422
        if (!s->input_picture[j])
1423
            break;
1424
1425
        c = avcodec_alloc_context3(NULL);
1426
        if (!c)
1427
            return AVERROR(ENOMEM);
1428
1429
        c->width        = width;
1430
        c->height       = height;
1431
        c->flags        = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1432
        c->flags       |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1433
        c->mb_decision  = s->avctx->mb_decision;
1434
        c->me_cmp       = s->avctx->me_cmp;
1435
        c->mb_cmp       = s->avctx->mb_cmp;
1436
        c->me_sub_cmp   = s->avctx->me_sub_cmp;
1437
        c->pix_fmt      = AV_PIX_FMT_YUV420P;
1438
        c->time_base    = s->avctx->time_base;
1439
        c->max_b_frames = s->max_b_frames;
1440
1441
        ret = avcodec_open2(c, codec, NULL);
1442
        if (ret < 0)
1443
            goto fail;
1444
1445
        s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1446
        s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
1447
1448
        out_size = encode_frame(c, s->tmp_frames[0]);
1449
        if (out_size < 0) {
1450
            ret = out_size;
1451
            goto fail;
1452
        }
1453
1454
        //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1455
1456
        for (i = 0; i < s->max_b_frames + 1; i++) {
1457
            int is_p = i % (j + 1) == j || i == s->max_b_frames;
1458
1459
            s->tmp_frames[i + 1]->pict_type = is_p ?
1460
                                     AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1461
            s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
1462
1463
            out_size = encode_frame(c, s->tmp_frames[i + 1]);
1464
            if (out_size < 0) {
1465
                ret = out_size;
1466
                goto fail;
1467
            }
1468
1469
            rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1470
        }
1471
1472
        /* get the delayed frames */
1473
        out_size = encode_frame(c, NULL);
1474
        if (out_size < 0) {
1475
            ret = out_size;
1476
            goto fail;
1477
        }
1478
        rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1479
1480
        rd += c->error[0] + c->error[1] + c->error[2];
1481
1482
        if (rd < best_rd) {
1483
            best_rd = rd;
1484
            best_b_count = j;
1485
        }
1486
1487
fail:
1488
        avcodec_free_context(&c);
1489
        if (ret < 0)
1490
            return ret;
1491
    }
1492
1493
    return best_b_count;
1494
}
1495
1496
8553
static int select_input_picture(MpegEncContext *s)
1497
{
1498
    int i, ret;
1499
1500
307908
    for (i = 1; i < MAX_PICTURE_COUNT; i++)
1501
299355
        s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1502
8553
    s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1503
1504
    /* set next picture type & ordering */
1505

8553
    if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1506

6986
        if (s->frame_skip_threshold || s->frame_skip_factor) {
1507
            if (s->picture_in_gop_number < s->gop_size &&
1508
                s->next_picture_ptr &&
1509
                skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1510
                // FIXME check that the gop check above is +-1 correct
1511
                av_frame_unref(s->input_picture[0]->f);
1512
1513
                ff_vbv_update(s, 0);
1514
1515
                goto no_output_pic;
1516
            }
1517
        }
1518
1519
6986
        if (/*s->picture_in_gop_number >= s->gop_size ||*/
1520

6986
            !s->next_picture_ptr || s->intra_only) {
1521
1614
            s->reordered_input_picture[0] = s->input_picture[0];
1522
1614
            s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1523
1614
            s->reordered_input_picture[0]->f->coded_picture_number =
1524
1614
                s->coded_picture_number++;
1525
        } else {
1526
5372
            int b_frames = 0;
1527
1528
5372
            if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1529
                for (i = 0; i < s->max_b_frames + 1; i++) {
1530
                    int pict_num = s->input_picture[0]->f->display_picture_number + i;
1531
1532
                    if (pict_num >= s->rc_context.num_entries)
1533
                        break;
1534
                    if (!s->input_picture[i]) {
1535
                        s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1536
                        break;
1537
                    }
1538
1539
                    s->input_picture[i]->f->pict_type =
1540
                        s->rc_context.entry[pict_num].new_pict_type;
1541
                }
1542
            }
1543
1544
5372
            if (s->b_frame_strategy == 0) {
1545
5372
                b_frames = s->max_b_frames;
1546

5457
                while (b_frames && !s->input_picture[b_frames])
1547
85
                    b_frames--;
1548
            } else if (s->b_frame_strategy == 1) {
1549
                for (i = 1; i < s->max_b_frames + 1; i++) {
1550
                    if (s->input_picture[i] &&
1551
                        s->input_picture[i]->b_frame_score == 0) {
1552
                        s->input_picture[i]->b_frame_score =
1553
                            get_intra_count(s,
1554
                                            s->input_picture[i    ]->f->data[0],
1555
                                            s->input_picture[i - 1]->f->data[0],
1556
                                            s->linesize) + 1;
1557
                    }
1558
                }
1559
                for (i = 0; i < s->max_b_frames + 1; i++) {
1560
                    if (!s->input_picture[i] ||
1561
                        s->input_picture[i]->b_frame_score - 1 >
1562
                            s->mb_num / s->b_sensitivity)
1563
                        break;
1564
                }
1565
1566
                b_frames = FFMAX(0, i - 1);
1567
1568
                /* reset scores */
1569
                for (i = 0; i < b_frames + 1; i++) {
1570
                    s->input_picture[i]->b_frame_score = 0;
1571
                }
1572
            } else if (s->b_frame_strategy == 2) {
1573
                b_frames = estimate_best_b_count(s);
1574
                if (b_frames < 0)
1575
                    return b_frames;
1576
            }
1577
1578
5372
            emms_c();
1579
1580
6719
            for (i = b_frames - 1; i >= 0; i--) {
1581
1347
                int type = s->input_picture[i]->f->pict_type;
1582

1347
                if (type && type != AV_PICTURE_TYPE_B)
1583
                    b_frames = i;
1584
            }
1585
5372
            if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1586
                b_frames == s->max_b_frames) {
1587
                av_log(s->avctx, AV_LOG_ERROR,
1588
                       "warning, too many B-frames in a row\n");
1589
            }
1590
1591
5372
            if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1592
537
                if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1593
                    s->gop_size > s->picture_in_gop_number) {
1594
                    b_frames = s->gop_size - s->picture_in_gop_number - 1;
1595
                } else {
1596
537
                    if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1597
                        b_frames = 0;
1598
537
                    s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1599
                }
1600
            }
1601
1602

5372
            if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1603
                s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1604
                b_frames--;
1605
1606
5372
            s->reordered_input_picture[0] = s->input_picture[b_frames];
1607
5372
            if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1608
4833
                s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1609
5372
            s->reordered_input_picture[0]->f->coded_picture_number =
1610
5372
                s->coded_picture_number++;
1611
6719
            for (i = 0; i < b_frames; i++) {
1612
1347
                s->reordered_input_picture[i + 1] = s->input_picture[i];
1613
1347
                s->reordered_input_picture[i + 1]->f->pict_type =
1614
                    AV_PICTURE_TYPE_B;
1615
1347
                s->reordered_input_picture[i + 1]->f->coded_picture_number =
1616
1347
                    s->coded_picture_number++;
1617
            }
1618
        }
1619
    }
1620
6939
no_output_pic:
1621
8553
    ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1622
1623
8553
    if (s->reordered_input_picture[0]) {
1624
8333
        s->reordered_input_picture[0]->reference =
1625
8333
           s->reordered_input_picture[0]->f->pict_type !=
1626
8333
               AV_PICTURE_TYPE_B ? 3 : 0;
1627
1628
8333
        if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1629
            return ret;
1630
1631

8333
        if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1632
            // input is a shared pix, so we can't modify it -> allocate a new
1633
            // one & ensure that the shared one is reuseable
1634
1635
            Picture *pic;
1636
674
            int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1637
674
            if (i < 0)
1638
                return i;
1639
674
            pic = &s->picture[i];
1640
1641
674
            pic->reference = s->reordered_input_picture[0]->reference;
1642
674
            if (alloc_picture(s, pic, 0) < 0) {
1643
                return -1;
1644
            }
1645
1646
674
            ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1647
674
            if (ret < 0)
1648
                return ret;
1649
1650
            /* mark us unused / free shared pic */
1651
674
            av_frame_unref(s->reordered_input_picture[0]->f);
1652
674
            s->reordered_input_picture[0]->shared = 0;
1653
1654
674
            s->current_picture_ptr = pic;
1655
        } else {
1656
            // input is not a shared pix -> reuse buffer for current_pix
1657
7659
            s->current_picture_ptr = s->reordered_input_picture[0];
1658
38295
            for (i = 0; i < 4; i++) {
1659
30636
                s->new_picture.f->data[i] += INPLACE_OFFSET;
1660
            }
1661
        }
1662
8333
        ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1663
8333
        if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1664
                                       s->current_picture_ptr)) < 0)
1665
            return ret;
1666
1667
8333
        s->picture_number = s->new_picture.f->display_picture_number;
1668
    }
1669
8553
    return 0;
1670
}
1671
1672
8458
static void frame_end(MpegEncContext *s)
1673
{
1674
8458
    if (s->unrestricted_mv &&
1675
3855
        s->current_picture.reference &&
1676
3215
        !s->intra_only) {
1677
3215
        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1678
3215
        int hshift = desc->log2_chroma_w;
1679
3215
        int vshift = desc->log2_chroma_h;
1680
3215
        s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
1681
3215
                                s->current_picture.f->linesize[0],
1682
                                s->h_edge_pos, s->v_edge_pos,
1683
                                EDGE_WIDTH, EDGE_WIDTH,
1684
                                EDGE_TOP | EDGE_BOTTOM);
1685
3215
        s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
1686
3215
                                s->current_picture.f->linesize[1],
1687
3215
                                s->h_edge_pos >> hshift,
1688
3215
                                s->v_edge_pos >> vshift,
1689
                                EDGE_WIDTH >> hshift,
1690
                                EDGE_WIDTH >> vshift,
1691
                                EDGE_TOP | EDGE_BOTTOM);
1692
3215
        s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
1693
3215
                                s->current_picture.f->linesize[2],
1694
3215
                                s->h_edge_pos >> hshift,
1695
3215
                                s->v_edge_pos >> vshift,
1696
                                EDGE_WIDTH >> hshift,
1697
                                EDGE_WIDTH >> vshift,
1698
                                EDGE_TOP | EDGE_BOTTOM);
1699
    }
1700
1701
8458
    emms_c();
1702
1703
8458
    s->last_pict_type                 = s->pict_type;
1704
8458
    s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1705
8458
    if (s->pict_type!= AV_PICTURE_TYPE_B)
1706
7111
        s->last_non_b_pict_type = s->pict_type;
1707
1708
#if FF_API_CODED_FRAME
1709
FF_DISABLE_DEPRECATION_WARNINGS
1710
8458
    av_frame_unref(s->avctx->coded_frame);
1711
8458
    av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1712
FF_ENABLE_DEPRECATION_WARNINGS
1713
#endif
1714
#if FF_API_ERROR_FRAME
1715
FF_DISABLE_DEPRECATION_WARNINGS
1716
8458
    memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1717
           sizeof(s->current_picture.encoding_error));
1718
FF_ENABLE_DEPRECATION_WARNINGS
1719
#endif
1720
8458
}
1721
1722
200
static void update_noise_reduction(MpegEncContext *s)
1723
{
1724
    int intra, i;
1725
1726
600
    for (intra = 0; intra < 2; intra++) {
1727
400
        if (s->dct_count[intra] > (1 << 16)) {
1728
520
            for (i = 0; i < 64; i++) {
1729
512
                s->dct_error_sum[intra][i] >>= 1;
1730
            }
1731
8
            s->dct_count[intra] >>= 1;
1732
        }
1733
1734
26000
        for (i = 0; i < 64; i++) {
1735
25600
            s->dct_offset[intra][i] = (s->noise_reduction *
1736
25600
                                       s->dct_count[intra] +
1737
25600
                                       s->dct_error_sum[intra][i] / 2) /
1738
25600
                                      (s->dct_error_sum[intra][i] + 1);
1739
        }
1740
    }
1741
200
}
1742
1743
8333
static int frame_start(MpegEncContext *s)
1744
{
1745
    int ret;
1746
1747
    /* mark & release old frames */
1748

8333
    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1749
6622
        s->last_picture_ptr != s->next_picture_ptr &&
1750
6622
        s->last_picture_ptr->f->buf[0]) {
1751
6622
        ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1752
    }
1753
1754
8333
    s->current_picture_ptr->f->pict_type = s->pict_type;
1755
8333
    s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1756
1757
8333
    ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1758
8333
    if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1759
                                   s->current_picture_ptr)) < 0)
1760
        return ret;
1761
1762
8333
    if (s->pict_type != AV_PICTURE_TYPE_B) {
1763
6986
        s->last_picture_ptr = s->next_picture_ptr;
1764
6986
        if (!s->droppable)
1765
6986
            s->next_picture_ptr = s->current_picture_ptr;
1766
    }
1767
1768
8333
    if (s->last_picture_ptr) {
1769
8151
        ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1770

16302
        if (s->last_picture_ptr->f->buf[0] &&
1771
8151
            (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1772
                                       s->last_picture_ptr)) < 0)
1773
            return ret;
1774
    }
1775
8333
    if (s->next_picture_ptr) {
1776
8333
        ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1777

16666
        if (s->next_picture_ptr->f->buf[0] &&
1778
8333
            (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1779
                                       s->next_picture_ptr)) < 0)
1780
            return ret;
1781
    }
1782
1783
8333
    if (s->picture_structure!= PICT_FRAME) {
1784
        int i;
1785
        for (i = 0; i < 4; i++) {
1786
            if (s->picture_structure == PICT_BOTTOM_FIELD) {
1787
                s->current_picture.f->data[i] +=
1788
                    s->current_picture.f->linesize[i];
1789
            }
1790
            s->current_picture.f->linesize[i] *= 2;
1791
            s->last_picture.f->linesize[i]    *= 2;
1792
            s->next_picture.f->linesize[i]    *= 2;
1793
        }
1794
    }
1795
1796

8333
    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1797
1635
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1798
1635
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1799

6698
    } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1800
4780
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1801
4780
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1802
    } else {
1803
1918
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1804
1918
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1805
    }
1806
1807
8333
    if (s->dct_error_sum) {
1808
        av_assert2(s->noise_reduction && s->encoding);
1809
200
        update_noise_reduction(s);
1810
    }
1811
1812
8333
    return 0;
1813
}
1814
1815
8553
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1816
                          const AVFrame *pic_arg, int *got_packet)
1817
{
1818
8553
    MpegEncContext *s = avctx->priv_data;
1819
    int i, stuffing_count, ret;
1820
8553
    int context_count = s->slice_context_count;
1821
1822
8553
    s->vbv_ignore_qmax = 0;
1823
1824
8553
    s->picture_in_gop_number++;
1825
1826
8553
    if (load_input_picture(s, pic_arg) < 0)
1827
        return -1;
1828
1829
8553
    if (select_input_picture(s) < 0) {
1830
        return -1;
1831
    }
1832
1833
    /* output? */
1834
8553
    if (s->new_picture.f->data[0]) {
1835

8333
        int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1836
15666
        int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1837
8333
                                              :
1838
1000
                                              s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1839
8333
        if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1840
            return ret;
1841
8333
        if (s->mb_info) {
1842
            s->mb_info_ptr = av_packet_new_side_data(pkt,
1843
                                 AV_PKT_DATA_H263_MB_INFO,
1844
                                 s->mb_width*s->mb_height*12);
1845
            s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1846
        }
1847
1848
17266
        for (i = 0; i < context_count; i++) {
1849
8933
            int start_y = s->thread_context[i]->start_mb_y;
1850
8933
            int   end_y = s->thread_context[i]->  end_mb_y;
1851
8933
            int h       = s->mb_height;
1852
8933
            uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1853
8933
            uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);
1854
1855
8933
            init_put_bits(&s->thread_context[i]->pb, start, end - start);
1856
        }
1857
1858
8333
        s->pict_type = s->new_picture.f->pict_type;
1859
        //emms_c();
1860
8333
        ret = frame_start(s);
1861
8333
        if (ret < 0)
1862
            return ret;
1863
8333
vbv_retry:
1864
8458
        ret = encode_picture(s, s->picture_number);
1865
8458
        if (growing_buffer) {
1866
7458
            av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1867
7458
            pkt->data = s->pb.buf;
1868
7458
            pkt->size = avctx->internal->byte_buffer_size;
1869
        }
1870
8458
        if (ret < 0)
1871
            return -1;
1872
1873
#if FF_API_STAT_BITS
1874
FF_DISABLE_DEPRECATION_WARNINGS
1875
8458
        avctx->header_bits = s->header_bits;
1876
8458
        avctx->mv_bits     = s->mv_bits;
1877
8458
        avctx->misc_bits   = s->misc_bits;
1878
8458
        avctx->i_tex_bits  = s->i_tex_bits;
1879
8458
        avctx->p_tex_bits  = s->p_tex_bits;
1880
8458
        avctx->i_count     = s->i_count;
1881
        // FIXME f/b_count in avctx
1882
8458
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count;
1883
8458
        avctx->skip_count  = s->skip_count;
1884
FF_ENABLE_DEPRECATION_WARNINGS
1885
#endif
1886
1887
8458
        frame_end(s);
1888
1889
8458
        if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1890
1438
            ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1891
1892
8458
        if (avctx->rc_buffer_size) {
1893
150
            RateControlContext *rcc = &s->rc_context;
1894
150
            int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1895

150
            int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
1896
150
            int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1897
1898
150
            if (put_bits_count(&s->pb) > max_size &&
1899
125
                s->lambda < s->lmax) {
1900
125
                s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1901
                                       (s->qscale + 1) / s->qscale);
1902
125
                if (s->adaptive_quant) {
1903
                    int i;
1904
                    for (i = 0; i < s->mb_height * s->mb_stride; i++)
1905
                        s->lambda_table[i] =
1906
                            FFMAX(s->lambda_table[i] + min_step,
1907
                                  s->lambda_table[i] * (s->qscale + 1) /
1908
                                  s->qscale);
1909
                }
1910
125
                s->mb_skipped = 0;        // done in frame_start()
1911
                // done in encode_picture() so we must undo it
1912
125
                if (s->pict_type == AV_PICTURE_TYPE_P) {
1913
                    if (s->flipflop_rounding          ||
1914
                        s->codec_id == AV_CODEC_ID_H263P ||
1915
                        s->codec_id == AV_CODEC_ID_MPEG4)
1916
                        s->no_rounding ^= 1;
1917
                }
1918
125
                if (s->pict_type != AV_PICTURE_TYPE_B) {
1919
125
                    s->time_base       = s->last_time_base;
1920
125
                    s->last_non_b_time = s->time - s->pp_time;
1921
                }
1922
250
                for (i = 0; i < context_count; i++) {
1923
125
                    PutBitContext *pb = &s->thread_context[i]->pb;
1924
125
                    init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1925
                }
1926
125
                s->vbv_ignore_qmax = 1;
1927
125
                av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1928
125
                goto vbv_retry;
1929
            }
1930
1931
25
            av_assert0(s->avctx->rc_max_rate);
1932
        }
1933
1934
8333
        if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1935
            ff_write_pass1_stats(s);
1936
1937
41665
        for (i = 0; i < 4; i++) {
1938
33332
            s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1939
33332
            avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1940
        }
1941
8333
        ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
1942
8333
                                       s->current_picture_ptr->encoding_error,
1943
8333
                                       (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1944
                                       s->pict_type);
1945
1946
8333
        if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
1947
            assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1948
                                             s->misc_bits + s->i_tex_bits +
1949
                                             s->p_tex_bits);
1950
8333
        flush_put_bits(&s->pb);
1951
8333
        s->frame_bits  = put_bits_count(&s->pb);
1952
1953
8333
        stuffing_count = ff_vbv_update(s, s->frame_bits);
1954
8333
        s->stuffing_bits = 8*stuffing_count;
1955
8333
        if (stuffing_count) {
1956
25
            if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1957
25
                    stuffing_count + 50) {
1958
                av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1959
                return -1;
1960
            }
1961
1962
25
            switch (s->codec_id) {
1963
25
            case AV_CODEC_ID_MPEG1VIDEO:
1964
            case AV_CODEC_ID_MPEG2VIDEO:
1965
124340
                while (stuffing_count--) {
1966
124315
                    put_bits(&s->pb, 8, 0);
1967
                }
1968
25
            break;
1969
            case AV_CODEC_ID_MPEG4:
1970
                put_bits(&s->pb, 16, 0);
1971
                put_bits(&s->pb, 16, 0x1C3);
1972
                stuffing_count -= 4;
1973
                while (stuffing_count--) {
1974
                    put_bits(&s->pb, 8, 0xFF);
1975
                }
1976
            break;
1977
            default:
1978
                av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1979
            }
1980
25
            flush_put_bits(&s->pb);
1981
25
            s->frame_bits  = put_bits_count(&s->pb);
1982
        }
1983
1984
        /* update MPEG-1/2 vbv_delay for CBR */
1985
8333
        if (s->avctx->rc_max_rate                          &&
1986
25
            s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1987
25
            s->out_format == FMT_MPEG1                     &&
1988
25
            90000LL * (avctx->rc_buffer_size - 1) <=
1989
25
                s->avctx->rc_max_rate * 0xFFFFLL) {
1990
            AVCPBProperties *props;
1991
            size_t props_size;
1992
1993
            int vbv_delay, min_delay;
1994
50
            double inbits  = s->avctx->rc_max_rate *
1995
25
                             av_q2d(s->avctx->time_base);
1996
25
            int    minbits = s->frame_bits - 8 *
1997
25
                             (s->vbv_delay_ptr - s->pb.buf - 1);
1998
25
            double bits    = s->rc_context.buffer_index + minbits - inbits;
1999
2000
25
            if (bits < 0)
2001
                av_log(s->avctx, AV_LOG_ERROR,
2002
                       "Internal error, negative bits\n");
2003
2004
            av_assert1(s->repeat_first_field == 0);
2005
2006
25
            vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
2007
25
            min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
2008
25
                        s->avctx->rc_max_rate;
2009
2010
25
            vbv_delay = FFMAX(vbv_delay, min_delay);
2011
2012
25
            av_assert0(vbv_delay < 0xFFFF);
2013
2014
25
            s->vbv_delay_ptr[0] &= 0xF8;
2015
25
            s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2016
25
            s->vbv_delay_ptr[1]  = vbv_delay >> 5;
2017
25
            s->vbv_delay_ptr[2] &= 0x07;
2018
25
            s->vbv_delay_ptr[2] |= vbv_delay << 3;
2019
2020
25
            props = av_cpb_properties_alloc(&props_size);
2021
25
            if (!props)
2022
                return AVERROR(ENOMEM);
2023
25
            props->vbv_delay = vbv_delay * 300;
2024
2025
25
            ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2026
                                          (uint8_t*)props, props_size);
2027
25
            if (ret < 0) {
2028
                av_freep(&props);
2029
                return ret;
2030
            }
2031
2032
#if FF_API_VBV_DELAY
2033
FF_DISABLE_DEPRECATION_WARNINGS
2034
25
            avctx->vbv_delay     = vbv_delay * 300;
2035
FF_ENABLE_DEPRECATION_WARNINGS
2036
#endif
2037
        }
2038
8333
        s->total_bits     += s->frame_bits;
2039
#if FF_API_STAT_BITS
2040
FF_DISABLE_DEPRECATION_WARNINGS
2041
8333
        avctx->frame_bits  = s->frame_bits;
2042
FF_ENABLE_DEPRECATION_WARNINGS
2043
#endif
2044
2045
2046
8333
        pkt->pts = s->current_picture.f->pts;
2047

8333
        if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2048
1743
            if (!s->current_picture.f->coded_picture_number)
2049
67
                pkt->dts = pkt->pts - s->dts_delta;
2050
            else
2051
1676
                pkt->dts = s->reordered_pts;
2052
1743
            s->reordered_pts = pkt->pts;
2053
        } else
2054
6590
            pkt->dts = pkt->pts;
2055
8333
        if (s->current_picture.f->key_frame)
2056
2185
            pkt->flags |= AV_PKT_FLAG_KEY;
2057
8333
        if (s->mb_info)
2058
            av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2059
    } else {
2060
220
        s->frame_bits = 0;
2061
    }
2062
2063
    /* release non-reference frames */
2064
316461
    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2065
307908
        if (!s->picture[i].reference)
2066
285199
            ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2067
    }
2068
2069
    av_assert1((s->frame_bits & 7) == 0);
2070
2071
8553
    pkt->size = s->frame_bits / 8;
2072
8553
    *got_packet = !!pkt->size;
2073
8553
    return 0;
2074
}
2075
2076
static inline void dct_single_coeff_elimination(MpegEncContext *s,
2077
                                                int n, int threshold)
2078
{
2079
    static const char tab[64] = {
2080
        3, 2, 2, 1, 1, 1, 1, 1,
2081
        1, 1, 1, 1, 1, 1, 1, 1,
2082
        1, 1, 1, 1, 1, 1, 1, 1,
2083
        0, 0, 0, 0, 0, 0, 0, 0,
2084
        0, 0, 0, 0, 0, 0, 0, 0,
2085
        0, 0, 0, 0, 0, 0, 0, 0,
2086
        0, 0, 0, 0, 0, 0, 0, 0,
2087
        0, 0, 0, 0, 0, 0, 0, 0
2088
    };
2089
    int score = 0;
2090
    int run = 0;
2091
    int i;
2092
    int16_t *block = s->block[n];
2093
    const int last_index = s->block_last_index[n];
2094
    int skip_dc;
2095
2096
    if (threshold < 0) {
2097
        skip_dc = 0;
2098
        threshold = -threshold;
2099
    } else
2100
        skip_dc = 1;
2101
2102
    /* Are all we could set to zero already zero? */
2103
    if (last_index <= skip_dc - 1)
2104
        return;
2105
2106
    for (i = 0; i <= last_index; i++) {
2107
        const int j = s->intra_scantable.permutated[i];
2108
        const int level = FFABS(block[j]);
2109
        if (level == 1) {
2110
            if (skip_dc && i == 0)
2111
                continue;
2112
            score += tab[run];
2113
            run = 0;
2114
        } else if (level > 1) {
2115
            return;
2116
        } else {
2117
            run++;
2118
        }
2119
    }
2120
    if (score >= threshold)
2121
        return;
2122
    for (i = skip_dc; i <= last_index; i++) {
2123
        const int j = s->intra_scantable.permutated[i];
2124
        block[j] = 0;
2125
    }
2126
    if (block[0])
2127
        s->block_last_index[n] = 0;
2128
    else
2129
        s->block_last_index[n] = -1;
2130
}
2131
2132
static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2133
                               int last_index)
2134
{
2135
    int i;
2136
    const int maxlevel = s->max_qcoeff;
2137
    const int minlevel = s->min_qcoeff;
2138
    int overflow = 0;
2139
2140
    if (s->mb_intra) {
2141
        i = 1; // skip clipping of intra dc
2142
    } else
2143
        i = 0;
2144
2145
    for (; i <= last_index; i++) {
2146
        const int j = s->intra_scantable.permutated[i];
2147
        int level = block[j];
2148
2149
        if (level > maxlevel) {
2150
            level = maxlevel;
2151
            overflow++;
2152
        } else if (level < minlevel) {
2153
            level = minlevel;
2154
            overflow++;
2155
        }
2156
2157
        block[j] = level;
2158
    }
2159
2160
    if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2161
        av_log(s->avctx, AV_LOG_INFO,
2162
               "warning, clipping %d dct coefficients to %d..%d\n",
2163
               overflow, minlevel, maxlevel);
2164
}
2165
2166
static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2167
{
2168
    int x, y;
2169
    // FIXME optimize
2170
    for (y = 0; y < 8; y++) {
2171
        for (x = 0; x < 8; x++) {
2172
            int x2, y2;
2173
            int sum = 0;
2174
            int sqr = 0;
2175
            int count = 0;
2176
2177
            for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2178
                for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2179
                    int v = ptr[x2 + y2 * stride];
2180
                    sum += v;
2181
                    sqr += v * v;
2182
                    count++;
2183
                }
2184
            }
2185
            weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2186
        }
2187
    }
2188
}
2189
2190
4564054
static av_always_inline void encode_mb_internal(MpegEncContext *s,
2191
                                                int motion_x, int motion_y,
2192
                                                int mb_block_height,
2193
                                                int mb_block_width,
2194
                                                int mb_block_count)
2195
{
2196
    int16_t weight[12][64];
2197
    int16_t orig[12][64];
2198
4564054
    const int mb_x = s->mb_x;
2199
4564054
    const int mb_y = s->mb_y;
2200
    int i;
2201
    int skip_dct[12];
2202
4564054
    int dct_offset = s->linesize * 8; // default for progressive frames
2203
4564054
    int uv_dct_offset = s->uvlinesize * 8;
2204
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2205
    ptrdiff_t wrap_y, wrap_c;
2206
2207
33713408
    for (i = 0; i < mb_block_count; i++)
2208
29149354
        skip_dct[i] = s->skipdct;
2209
2210
4564054
    if (s->adaptive_quant) {
2211
1271769
        const int last_qp = s->qscale;
2212
1271769
        const int mb_xy = mb_x + mb_y * s->mb_stride;
2213
2214
1271769
        s->lambda = s->lambda_table[mb_xy];
2215
1271769
        update_qscale(s);
2216
2217
1271769
        if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2218
232420
            s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2219
232420
            s->dquant = s->qscale - last_qp;
2220
2221
232420
            if (s->out_format == FMT_H263) {
2222
232420
                s->dquant = av_clip(s->dquant, -2, 2);
2223
2224
232420
                if (s->codec_id == AV_CODEC_ID_MPEG4) {
2225
232420
                    if (!s->mb_intra) {
2226
221829
                        if (s->pict_type == AV_PICTURE_TYPE_B) {
2227

177110
                            if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2228
69152
                                s->dquant = 0;
2229
                        }
2230
221829
                        if (s->mv_type == MV_TYPE_8X8)
2231
31669
                            s->dquant = 0;
2232
                    }
2233
                }
2234
            }
2235
        }
2236
1271769
        ff_set_qscale(s, last_qp + s->dquant);
2237
3292285
    } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2238
        ff_set_qscale(s, s->qscale + s->dquant);
2239
2240
4564054
    wrap_y = s->linesize;
2241
4564054
    wrap_c = s->uvlinesize;
2242
4564054
    ptr_y  = s->new_picture.f->data[0] +
2243
4564054
             (mb_y * 16 * wrap_y)              + mb_x * 16;
2244
4564054
    ptr_cb = s->new_picture.f->data[1] +
2245
4564054
             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2246
4564054
    ptr_cr = s->new_picture.f->data[2] +
2247
4564054
             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2248
2249

4564054
    if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2250
20323
        uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2251
20323
        int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
2252
20323
        int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2253
20323
        s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2254
                                 wrap_y, wrap_y,
2255
                                 16, 16, mb_x * 16, mb_y * 16,
2256
                                 s->width, s->height);
2257
20323
        ptr_y = ebuf;
2258
20323
        s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2259
                                 wrap_c, wrap_c,
2260
                                 mb_block_width, mb_block_height,
2261
                                 mb_x * mb_block_width, mb_y * mb_block_height,
2262
                                 cw, ch);
2263
20323
        ptr_cb = ebuf + 16 * wrap_y;
2264
20323
        s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2265
                                 wrap_c, wrap_c,
2266
                                 mb_block_width, mb_block_height,
2267
                                 mb_x * mb_block_width, mb_y * mb_block_height,
2268
                                 cw, ch);
2269
20323
        ptr_cr = ebuf + 16 * wrap_y + 16;
2270
    }
2271
2272
4564054
    if (s->mb_intra) {
2273
1185216
        if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2274
            int progressive_score, interlaced_score;
2275
2276
317596
            s->interlaced_dct = 0;
2277
317596
            progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2278
317596
                                s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2279
                                                     NULL, wrap_y, 8) - 400;
2280
2281
317596
            if (progressive_score > 0) {
2282
298126
                interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2283
                                                        NULL, wrap_y * 2, 8) +
2284
298126
                                   s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2285
                                                        NULL, wrap_y * 2, 8);
2286
298126
                if (progressive_score > interlaced_score) {
2287
364
                    s->interlaced_dct = 1;
2288
2289
364
                    dct_offset = wrap_y;
2290
364
                    uv_dct_offset = wrap_c;
2291
364
                    wrap_y <<= 1;
2292
364
                    if (s->chroma_format == CHROMA_422 ||
2293
185
                        s->chroma_format == CHROMA_444)
2294
179
                        wrap_c <<= 1;
2295
                }
2296
            }
2297
        }
2298
2299
1185216
        s->pdsp.get_pixels(s->block[0], ptr_y,                  wrap_y);
2300
1185216
        s->pdsp.get_pixels(s->block[1], ptr_y + 8,              wrap_y);
2301
1185216
        s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset,     wrap_y);
2302
1185216
        s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2303
2304
1185216
        if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2305
            skip_dct[4] = 1;
2306
            skip_dct[5] = 1;
2307
        } else {
2308
1185216
            s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2309
1185216
            s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2310

1185216
            if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2311
355360
                s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2312
355360
                s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2313

829856
            } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2314
59850
                s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2315
59850
                s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2316
59850
                s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2317
59850
                s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2318
59850
                s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2319
59850
                s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2320
            }
2321
        }
2322
    } else {
2323
        op_pixels_func (*op_pix)[4];
2324
        qpel_mc_func (*op_qpix)[16];
2325
        uint8_t *dest_y, *dest_cb, *dest_cr;
2326
2327
3378838
        dest_y  = s->dest[0];
2328
3378838
        dest_cb = s->dest[1];
2329
3378838
        dest_cr = s->dest[2];
2330
2331

3378838
        if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2332
2818939
            op_pix  = s->hdsp.put_pixels_tab;
2333
2818939
            op_qpix = s->qdsp.put_qpel_pixels_tab;
2334
        } else {
2335
559899
            op_pix  = s->hdsp.put_no_rnd_pixels_tab;
2336
559899
            op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2337
        }
2338
2339
3378838
        if (s->mv_dir & MV_DIR_FORWARD) {
2340
3028772
            ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2341
3028772
                          s->last_picture.f->data,
2342
                          op_pix, op_qpix);
2343
3028772
            op_pix  = s->hdsp.avg_pixels_tab;
2344
3028772
            op_qpix = s->qdsp.avg_qpel_pixels_tab;
2345
        }
2346
3378838
        if (s->mv_dir & MV_DIR_BACKWARD) {
2347
1023258
            ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2348
1023258
                          s->next_picture.f->data,
2349
                          op_pix, op_qpix);
2350
        }
2351
2352
3378838
        if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2353
            int progressive_score, interlaced_score;
2354
2355
505519
            s->interlaced_dct = 0;
2356
505519
            progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2357
505519
                                s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2358
505519
                                                     ptr_y + wrap_y * 8,
2359
                                                     wrap_y, 8) - 400;
2360
2361
505519
            if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2362
                progressive_score -= 400;
2363
2364
505519
            if (progressive_score > 0) {
2365
451992
                interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2366
                                                        wrap_y * 2, 8) +
2367
451992
                                   s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2368
                                                        ptr_y + wrap_y,
2369
                                                        wrap_y * 2, 8);
2370
2371
451992
                if (progressive_score > interlaced_score) {
2372
11826
                    s->interlaced_dct = 1;
2373
2374
11826
                    dct_offset = wrap_y;
2375
11826
                    uv_dct_offset = wrap_c;
2376
11826
                    wrap_y <<= 1;
2377
11826
                    if (s->chroma_format == CHROMA_422)
2378
8280
                        wrap_c <<= 1;
2379
                }
2380
            }
2381
        }
2382
2383
3378838
        s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2384
3378838
        s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2385
3378838
        s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2386
3378838
                            dest_y + dct_offset, wrap_y);
2387
3378838
        s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2388
3378838
                            dest_y + dct_offset + 8, wrap_y);
2389
2390
3378838
        if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2391
            skip_dct[4] = 1;
2392
            skip_dct[5] = 1;
2393
        } else {
2394
3378838
            s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2395
3378838
            s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2396
3378838
            if (!s->chroma_y_shift) { /* 422 */
2397
347605
                s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2398
347605
                                    dest_cb + uv_dct_offset, wrap_c);
2399
347605
                s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2400
347605
                                    dest_cr + uv_dct_offset, wrap_c);
2401
            }
2402
        }
2403
        /* pre quantization */
2404
3378838
        if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2405
3378838
                2 * s->qscale * s->qscale) {
2406
            // FIXME optimize
2407
2804683
            if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2408
832451
                skip_dct[0] = 1;
2409
2804683
            if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2410
850443
                skip_dct[1] = 1;
2411
2804683
            if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2412
2804683
                               wrap_y, 8) < 20 * s->qscale)
2413
851645
                skip_dct[2] = 1;
2414
2804683
            if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2415
2804683
                               wrap_y, 8) < 20 * s->qscale)
2416
824528
                skip_dct[3] = 1;
2417
2804683
            if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2418
1176912
                skip_dct[4] = 1;
2419
2804683
            if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2420
1142090
                skip_dct[5] = 1;
2421
2804683
            if (!s->chroma_y_shift) { /* 422 */
2422
294319
                if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2423
                                   dest_cb + uv_dct_offset,
2424
294319
                                   wrap_c, 8) < 20 * s->qscale)
2425
153422
                    skip_dct[6] = 1;
2426
294319
                if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2427
                                   dest_cr + uv_dct_offset,
2428
294319
                                   wrap_c, 8) < 20 * s->qscale)
2429
147975
                    skip_dct[7] = 1;
2430
            }
2431
        }
2432
    }
2433
2434
4564054
    if (s->quantizer_noise_shaping) {
2435
        if (!skip_dct[0])
2436
            get_visual_weight(weight[0], ptr_y                 , wrap_y);
2437
        if (!skip_dct[1])
2438
            get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
2439
        if (!skip_dct[2])
2440
            get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
2441
        if (!skip_dct[3])
2442
            get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2443
        if (!skip_dct[4])
2444
            get_visual_weight(weight[4], ptr_cb                , wrap_c);
2445
        if (!skip_dct[5])
2446
            get_visual_weight(weight[5], ptr_cr                , wrap_c);
2447
        if (!s->chroma_y_shift) { /* 422 */
2448
            if (!skip_dct[6])
2449
                get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2450
                                  wrap_c);
2451
            if (!skip_dct[7])
2452
                get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2453
                                  wrap_c);
2454
        }
2455
        memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2456
    }
2457
2458
    /* DCT & quantize */
2459
    av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2460
    {
2461
33713408
        for (i = 0; i < mb_block_count; i++) {
2462
29149354
            if (!skip_dct[i]) {
2463
                int overflow;
2464
23169888
                s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2465
                // FIXME we could decide to change to quantizer instead of
2466
                // clipping
2467
                // JS: I don't think that would be a good idea it could lower
2468
                //     quality instead of improve it. Just INTRADC clipping
2469
                //     deserves changes in quantizer
2470
23169888
                if (overflow)
2471
                    clip_coeffs(s, s->block[i], s->block_last_index[i]);
2472
            } else
2473
5979466
                s->block_last_index[i] = -1;
2474
        }
2475
4564054
        if (s->quantizer_noise_shaping) {
2476
            for (i = 0; i < mb_block_count; i++) {
2477
                if (!skip_dct[i]) {
2478
                    s->block_last_index[i] =
2479
                        dct_quantize_refine(s, s->block[i], weight[i],
2480
                                            orig[i], i, s->qscale);
2481
                }
2482
            }
2483
        }
2484
2485

4564054
        if (s->luma_elim_threshold && !s->mb_intra)
2486
            for (i = 0; i < 4; i++)
2487
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2488

4564054
        if (s->chroma_elim_threshold && !s->mb_intra)
2489
            for (i = 4; i < mb_block_count; i++)
2490
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2491
2492
4564054
        if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2493
            for (i = 0; i < mb_block_count; i++) {
2494
                if (s->block_last_index[i] == -1)
2495
                    s->coded_score[i] = INT_MAX / 256;
2496
            }
2497
        }
2498
    }
2499
2500

4564054
    if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2501
        s->block_last_index[4] =
2502
        s->block_last_index[5] = 0;
2503
        s->block[4][0] =
2504
        s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2505
        if (!s->chroma_y_shift) { /* 422 / 444 */
2506
            for (i=6; i<12; i++) {
2507
                s->block_last_index[i] = 0;
2508
                s->block[i][0] = s->block[4][0];
2509
            }
2510
        }
2511
    }
2512
2513
    // non c quantize code returns incorrect block_last_index FIXME
2514

4564054
    if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2515
        for (i = 0; i < mb_block_count; i++) {
2516
            int j;
2517
            if (s->block_last_index[i] > 0) {
2518
                for (j = 63; j > 0; j--) {
2519
                    if (s->block[i][s->intra_scantable.permutated[j]])
2520
                        break;
2521
                }
2522
                s->block_last_index[i] = j;
2523
            }
2524
        }
2525
    }
2526
2527
    /* huffman encode */
2528


4564054
    switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2529
1567917
    case AV_CODEC_ID_MPEG1VIDEO:
2530
    case AV_CODEC_ID_MPEG2VIDEO:
2531
        if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2532
1567917
            ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2533
1567917
        break;
2534
1750611
    case AV_CODEC_ID_MPEG4:
2535
        if (CONFIG_MPEG4_ENCODER)
2536
1750611
            ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2537
1750611
        break;
2538
189450
    case AV_CODEC_ID_MSMPEG4V2:
2539
    case AV_CODEC_ID_MSMPEG4V3:
2540
    case AV_CODEC_ID_WMV1:
2541
        if (CONFIG_MSMPEG4_ENCODER)
2542
189450
            ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2543
189450
        break;
2544
59850
    case AV_CODEC_ID_WMV2:
2545
        if (CONFIG_WMV2_ENCODER)
2546
59850
            ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2547
59850
        break;
2548
133678
    case AV_CODEC_ID_H261:
2549
        if (CONFIG_H261_ENCODER)
2550
133678
            ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2551
133678
        break;
2552
428550
    case AV_CODEC_ID_H263:
2553
    case AV_CODEC_ID_H263P:
2554
    case AV_CODEC_ID_FLV1:
2555
    case AV_CODEC_ID_RV10:
2556
    case AV_CODEC_ID_RV20:
2557
        if (CONFIG_H263_ENCODER)
2558
428550
            ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2559
428550
        break;
2560
433998
    case AV_CODEC_ID_MJPEG:
2561
    case AV_CODEC_ID_AMV:
2562
        if (CONFIG_MJPEG_ENCODER)
2563
433998
            ff_mjpeg_encode_mb(s, s->block);
2564
433998
        break;
2565
4564054
    default:
2566
        av_assert1(0);
2567
    }
2568
4564054
}
2569
2570
4564054
static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2571
{
2572
4564054
    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 8, 6);
2573
762815
    else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2574
59850
    else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2575
4564054
}
2576
2577
2583315
static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2578
    int i;
2579
2580
2583315
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2581
2582
    /* MPEG-1 */
2583
2583315
    d->mb_skip_run= s->mb_skip_run;
2584
10333260
    for(i=0; i<3; i++)
2585
7749945
        d->last_dc[i] = s->last_dc[i];
2586
2587
    /* statistics */
2588
2583315
    d->mv_bits= s->mv_bits;
2589
2583315
    d->i_tex_bits= s->i_tex_bits;
2590
2583315
    d->p_tex_bits= s->p_tex_bits;
2591
2583315
    d->i_count= s->i_count;
2592
2583315
    d->f_count= s->f_count;
2593
2583315
    d->b_count= s->b_count;
2594
2583315
    d->skip_count= s->skip_count;
2595
2583315
    d->misc_bits= s->misc_bits;
2596
2583315
    d->last_bits= 0;
2597
2598
2583315
    d->mb_skipped= 0;
2599
2583315
    d->qscale= s->qscale;
2600
2583315
    d->dquant= s->dquant;
2601
2602
2583315
    d->esc3_level_length= s->esc3_level_length;
2603
2583315
}
2604
2605
1525818
static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2606
    int i;
2607
2608
1525818
    memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2609
1525818
    memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2610
2611
    /* MPEG-1 */
2612
1525818
    d->mb_skip_run= s->mb_skip_run;
2613
6103272
    for(i=0; i<3; i++)
2614
4577454
        d->last_dc[i] = s->last_dc[i];
2615
2616
    /* statistics */
2617
1525818
    d->mv_bits= s->mv_bits;
2618
1525818
    d->i_tex_bits= s->i_tex_bits;
2619
1525818
    d->p_tex_bits= s->p_tex_bits;
2620
1525818
    d->i_count= s->i_count;
2621
1525818
    d->f_count= s->f_count;
2622
1525818
    d->b_count= s->b_count;
2623
1525818
    d->skip_count= s->skip_count;
2624
1525818
    d->misc_bits= s->misc_bits;
2625
2626
1525818
    d->mb_intra= s->mb_intra;
2627
1525818
    d->mb_skipped= s->mb_skipped;
2628
1525818
    d->mv_type= s->mv_type;
2629
1525818
    d->mv_dir= s->mv_dir;
2630
1525818
    d->pb= s->pb;
2631
1525818
    if(s->data_partitioning){
2632
373903
        d->pb2= s->pb2;
2633
373903
        d->tex_pb= s->tex_pb;
2634
    }
2635
1525818
    d->block= s->block;
2636
13732362
    for(i=0; i<8; i++)
2637
12206544
        d->block_last_index[i]= s->block_last_index[i];
2638
1525818
    d->interlaced_dct= s->interlaced_dct;
2639
1525818
    d->qscale= s->qscale;
2640
2641
1525818
    d->esc3_level_length= s->esc3_level_length;
2642
1525818
}
2643
2644
2051423
static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2645
                           PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2646
                           int *dmin, int *next_block, int motion_x, int motion_y)
2647
{
2648
    int score;
2649
    uint8_t *dest_backup[3];
2650
2651
2051423
    copy_context_before_encode(s, backup, type);
2652
2653
2051423
    s->block= s->blocks[*next_block];
2654
2051423
    s->pb= pb[*next_block];
2655
2051423
    if(s->data_partitioning){
2656
376394
        s->pb2   = pb2   [*next_block];
2657
376394
        s->tex_pb= tex_pb[*next_block];
2658
    }
2659
2660
2051423
    if(*next_block){
2661
1083400
        memcpy(dest_backup, s->dest, sizeof(s->dest));
2662
1083400
        s->dest[0] = s->sc.rd_scratchpad;
2663
1083400
        s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2664
1083400
        s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2665
1083400
        av_assert0(s->linesize >= 32); //FIXME
2666
    }
2667
2668
2051423
    encode_mb(s, motion_x, motion_y);
2669
2670
2051423
    score= put_bits_count(&s->pb);
2671
2051423
    if(s->data_partitioning){
2672
376394
        score+= put_bits_count(&s->pb2);
2673
376394
        score+= put_bits_count(&s->tex_pb);
2674
    }
2675
2676
2051423
    if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2677
1674464
        ff_mpv_reconstruct_mb(s, s->block);
2678
2679
1674464
        score *= s->lambda2;
2680
1674464
        score += sse_mb(s) << FF_LAMBDA_SHIFT;
2681
    }
2682
2683
2051423
    if(*next_block){
2684
1083400
        memcpy(s->dest, dest_backup, sizeof(s->dest));
2685
    }
2686
2687
2051423
    if(score<*dmin){
2688
993926
        *dmin= score;
2689
993926
        *next_block^=1;
2690
2691
993926
        copy_context_after_encode(best, s, type);
2692
    }
2693
2051423
}
2694
2695
24804
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2696
24804
    const uint32_t *sq = ff_square_tab + 256;
2697
24804
    int acc=0;
2698
    int x,y;
2699
2700

24804
    if(w==16 && h==16)
2701
        return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2702

24804
    else if(w==8 && h==8)
2703
        return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2704
2705
132172
    for(y=0; y<h; y++){
2706
397486
        for(x=0; x<w; x++){
2707
290118
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2708
        }
2709
    }
2710
2711
    av_assert2(acc>=0);
2712
2713
24804
    return acc;
2714
}
2715
2716
1674464
static int sse_mb(MpegEncContext *s){
2717
1674464
    int w= 16;
2718
1674464
    int h= 16;
2719
2720
1674464
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2721
1674464
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2722
2723

1674464
    if(w==16 && h==16)
2724
1666196
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
2725
        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) +
2726
               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) +
2727
               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);
2728
      }else{
2729
1666196
        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) +
2730
3332392
               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) +
2731
1666196
               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);
2732
      }
2733
    else
2734
8268
        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)
2735
8268
               +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)
2736
8268
               +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);
2737
}
2738
2739
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2740
    MpegEncContext *s= *(void**)arg;
2741
2742
2743
    s->me.pre_pass=1;
2744
    s->me.dia_size= s->avctx->pre_dia_size;
2745
    s->first_slice_line=1;
2746
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2747
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2748
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2749
        }
2750
        s->first_slice_line=0;
2751
    }
2752
2753
    s->me.pre_pass=0;
2754
2755
    return 0;
2756
}
2757
2758
6722
static int estimate_motion_thread(AVCodecContext *c, void *arg){
2759
6722
    MpegEncContext *s= *(void**)arg;
2760
2761
6722
    ff_check_alignment();
2762
2763
6722
    s->me.dia_size= s->avctx->dia_size;
2764
6722
    s->first_slice_line=1;
2765
102293
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2766
95571
        s->mb_x=0; //for block init below
2767
95571
        ff_init_block_index(s);
2768
2206530
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2769
2110959
            s->block_index[0]+=2;
2770
2110959
            s->block_index[1]+=2;
2771
2110959
            s->block_index[2]+=2;
2772
2110959
            s->block_index[3]+=2;
2773
2774
            /* compute motion vector & mb_type and store in context */
2775
2110959
            if(s->pict_type==AV_PICTURE_TYPE_B)
2776
408312
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2777
            else
2778
1702647
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2779
        }
2780
95571
        s->first_slice_line=0;
2781
    }
2782
6722
    return 0;
2783
}
2784
2785
366
static int mb_var_thread(AVCodecContext *c, void *arg){
2786
366
    MpegEncContext *s= *(void**)arg;
2787
    int mb_x, mb_y;
2788
2789
366
    ff_check_alignment();
2790
2791
5357
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2792
112814
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2793
107823
            int xx = mb_x * 16;
2794
107823
            int yy = mb_y * 16;
2795
107823
            uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2796
            int varc;
2797
107823
            int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2798
2799
107823
            varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2800
107823
                    (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2801
2802
107823
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2803
107823
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2804
107823
            s->me.mb_var_sum_temp    += varc;
2805
        }
2806
    }
2807
366
    return 0;
2808
}
2809
2810
301048
static void write_slice_end(MpegEncContext *s){
2811
301048
    if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2812
5813
        if(s->partitioned_frame){
2813
1760
            ff_mpeg4_merge_partitions(s);
2814
        }
2815
2816
5813
        ff_mpeg4_stuffing(&s->pb);
2817
295235
    }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2818
1438
        ff_mjpeg_encode_stuffing(s);
2819
    }
2820
2821
301048
    avpriv_align_put_bits(&s->pb);
2822
301048
    flush_put_bits(&s->pb);
2823
2824

301048
    if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2825
        s->misc_bits+= get_bits_diff(s);
2826
301048
}
2827
2828
static void write_mb_info(MpegEncContext *s)
2829
{
2830
    uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2831
    int offset = put_bits_count(&s->pb);
2832
    int mba  = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2833
    int gobn = s->mb_y / s->gob_index;
2834
    int pred_x, pred_y;
2835
    if (CONFIG_H263_ENCODER)
2836
        ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2837
    bytestream_put_le32(&ptr, offset);
2838
    bytestream_put_byte(&ptr, s->qscale);
2839
    bytestream_put_byte(&ptr, gobn);
2840
    bytestream_put_le16(&ptr, mba);
2841
    bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2842
    bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2843
    /* 4MV not implemented */
2844
    bytestream_put_byte(&ptr, 0); /* hmv2 */
2845
    bytestream_put_byte(&ptr, 0); /* vmv2 */
2846
}
2847
2848
3337113
static void update_mb_info(MpegEncContext *s, int startcode)
2849
{
2850
3337113
    if (!s->mb_info)
2851
3337113
        return;
2852
    if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2853
        s->mb_info_size += 12;
2854
        s->prev_mb_info = s->last_mb_info;
2855
    }
2856
    if (startcode) {
2857
        s->prev_mb_info = put_bits_count(&s->pb)/8;
2858
        /* This might have incremented mb_info_size above, and we return without
2859
         * actually writing any info into that slot yet. But in that case,
2860
         * this will be called again at the start of the after writing the
2861
         * start code, actually writing the mb info. */
2862
        return;
2863
    }
2864
2865
    s->last_mb_info = put_bits_count(&s->pb)/8;
2866
    if (!s->mb_info_size)
2867
        s->mb_info_size += 12;
2868
    write_mb_info(s);
2869
}
2870
2871
3047199
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2872
{
2873
3047199
    if (   s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2874
25
        && s->slice_context_count == 1
2875
25
        && s->pb.buf == s->avctx->internal->byte_buffer) {
2876
25
        int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2877
25
        int vbv_pos     = s->vbv_delay_ptr - s->pb.buf;
2878
2879
25
        uint8_t *new_buffer = NULL;
2880
25
        int new_buffer_size = 0;
2881
2882
25
        if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2883
            av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2884
            return AVERROR(ENOMEM);
2885
        }
2886
2887
25
        emms_c();
2888
2889
25
        av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2890
25
                              s->avctx->internal->byte_buffer_size + size_increase);
2891
25
        if (!new_buffer)
2892
            return AVERROR(ENOMEM);
2893
2894
25
        memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2895
25
        av_free(s->avctx->internal->byte_buffer);
2896
25
        s->avctx->internal->byte_buffer      = new_buffer;
2897
25
        s->avctx->internal->byte_buffer_size = new_buffer_size;
2898
25
        rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2899
25
        s->ptr_lastgob   = s->pb.buf + lastgob_pos;
2900
25
        s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2901
    }
2902
3047199
    if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2903
        return AVERROR(EINVAL);
2904
3047199
    return 0;
2905
}
2906
2907
9058
static int encode_thread(AVCodecContext *c, void *arg){
2908
9058
    MpegEncContext *s= *(void**)arg;
2909
    int mb_x, mb_y;
2910
9058
    int chr_h= 16>>s->chroma_y_shift;
2911
    int i, j;
2912
9058
    MpegEncContext best_s = { 0 }, backup_s;
2913
    uint8_t bit_buf[2][MAX_MB_BYTES];
2914
    uint8_t bit_buf2[2][MAX_MB_BYTES];
2915
    uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2916
    PutBitContext pb[2], pb2[2], tex_pb[2];
2917
2918
9058
    ff_check_alignment();
2919
2920
27174
    for(i=0; i<2; i++){
2921
18116
        init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
2922
18116
        init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
2923
18116
        init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2924
    }
2925
2926
9058
    s->last_bits= put_bits_count(&s->pb);
2927
9058
    s->mv_bits=0;
2928
9058
    s->misc_bits=0;
2929
9058
    s->i_tex_bits=0;
2930
9058
    s->p_tex_bits=0;
2931
9058
    s->i_count=0;
2932
9058
    s->f_count=0;
2933
9058
    s->b_count=0;
2934
9058
    s->skip_count=0;
2935
2936
36232
    for(i=0; i<3; i++){
2937
        /* init last dc values */
2938
        /* note: quant matrix value (8) is implied here */
2939
27174
        s->last_dc[i] = 128 << s->intra_dc_precision;
2940
2941
27174
        s->current_picture.encoding_error[i] = 0;
2942
    }
2943
9058
    if(s->codec_id==AV_CODEC_ID_AMV){
2944
200
        s->last_dc[0] = 128*8/13;
2945
200
        s->last_dc[1] = 128*8/14;
2946
200
        s->last_dc[2] = 128*8/14;
2947
    }
2948
9058
    s->mb_skip_run = 0;
2949
9058
    memset(s->last_mv, 0, sizeof(s->last_mv));
2950
2951
9058
    s->last_mv_dir = 0;
2952
2953
9058
    switch(s->codec_id){
2954
840
    case AV_CODEC_ID_H263:
2955
    case AV_CODEC_ID_H263P:
2956
    case AV_CODEC_ID_FLV1:
2957
        if (CONFIG_H263_ENCODER)
2958

840
            s->gob_index = H263_GOB_HEIGHT(s->height);
2959
840
        break;
2960
2690
    case AV_CODEC_ID_MPEG4:
2961
2690
        if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2962
544
            ff_mpeg4_init_partitions(s);
2963
2690
        break;
2964
    }
2965
2966
9058
    s->resync_mb_x=0;
2967
9058
    s->resync_mb_y=0;
2968
9058
    s->first_slice_line = 1;
2969
9058
    s->ptr_lastgob = s->pb.buf;
2970
141867
    for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2971
132809
        s->mb_x=0;
2972
132809
        s->mb_y= mb_y;
2973
2974
132809
        ff_set_qscale(s, s->qscale);
2975
132809
        ff_init_block_index(s);
2976
2977
3177332
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2978
3044523
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2979
3044523
            int mb_type= s->mb_type[xy];
2980
//            int d;
2981
3044523
            int dmin= INT_MAX;
2982
            int dir;
2983
3044523
            int size_increase =  s->avctx->internal->byte_buffer_size/4
2984
3044523
                               + s->mb_width*MAX_MB_BYTES;
2985
2986
3044523
            ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
2987
3044523
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2988
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2989
                return -1;
2990
            }
2991
3044523
            if(s->data_partitioning){
2992
179550
                if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
2993
179550
                   || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2994
                    av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
2995
                    return -1;
2996
                }
2997
            }
2998
2999
3044523
            s->mb_x = mb_x;
3000
3044523
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
3001
3044523
            ff_update_block_index(s);
3002
3003
3044523
            if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3004
118800
                ff_h261_reorder_mb_index(s);
3005
118800
                xy= s->mb_y*s->mb_stride + s->mb_x;
3006
118800
                mb_type= s->mb_type[xy];
3007
            }
3008
3009
            /* write gob / video packet header  */
3010
3044523
            if(s->rtp_mode){
3011
                int current_packet_size, is_gob_start;
3012
3013
1147830
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3014
3015
2850960
                is_gob_start = s->rtp_payload_size &&
3016

1457851
                               current_packet_size >= s->rtp_payload_size &&
3017
310021
                               mb_y + mb_x > 0;
3018
3019

1147830
                if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3020
3021

1147830
                switch(s->codec_id){
3022
59400
                case AV_CODEC_ID_H263:
3023
                case AV_CODEC_ID_H263P:
3024
59400
                    if(!s->h263_slice_structured)
3025

59400
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3026
59400
                    break;
3027
849030
                case AV_CODEC_ID_MPEG2VIDEO:
3028

849030
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3029
                case AV_CODEC_ID_MPEG1VIDEO:
3030
908880
                    if(s->mb_skip_run) is_gob_start=0;
3031
908880
                    break;
3032
                case AV_CODEC_ID_MJPEG:
3033
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3034
                    break;
3035
                }
3036
3037
1147830
                if(is_gob_start){
3038

292590
                    if(s->start_mb_y != mb_y || mb_x!=0){
3039
291990
                        write_slice_end(s);
3040
3041

291990
                        if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3042
1216
                            ff_mpeg4_init_partitions(s);
3043
                        }
3044
                    }
3045
3046
                    av_assert2((put_bits_count(&s->pb)&7) == 0);
3047
292590
                    current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3048
3049

292590
                    if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3050
287
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3051
287
                        int d = 100 / s->error_rate;
3052
287
                        if(r % d == 0){
3053
32
                            current_packet_size=0;
3054
32
                            s->pb.buf_ptr= s->ptr_lastgob;
3055
                            av_assert1(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3056
                        }
3057
                    }
3058
3059
#if FF_API_RTP_CALLBACK
3060
FF_DISABLE_DEPRECATION_WARNINGS
3061
292590
                    if (s->avctx->rtp_callback){
3062
                        int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3063
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3064
                    }
3065
FF_ENABLE_DEPRECATION_WARNINGS
3066
#endif
3067
292590
                    update_mb_info(s, 1);
3068
3069

292590
                    switch(s->codec_id){
3070
3323
                    case AV_CODEC_ID_MPEG4:
3071
                        if (CONFIG_MPEG4_ENCODER) {
3072
3323
                            ff_mpeg4_encode_video_packet_header(s);
3073
3323
                            ff_mpeg4_clean_buffers(s);
3074
                        }
3075
3323
                    break;
3076
286723
                    case AV_CODEC_ID_MPEG1VIDEO:
3077
                    case AV_CODEC_ID_MPEG2VIDEO:
3078
                        if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3079
286723
                            ff_mpeg1_encode_slice_header(s);
3080
286723
                            ff_mpeg1_clean_buffers(s);
3081
                        }
3082
286723
                    break;
3083
2544
                    case AV_CODEC_ID_H263:
3084
                    case AV_CODEC_ID_H263P:
3085
                        if (CONFIG_H263_ENCODER)
3086
2544
                            ff_h263_encode_gob_header(s, mb_y);
3087
2544
                    break;
3088
                    }
3089
3090
292590
                    if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3091
                        int bits= put_bits_count(&s->pb);
3092
                        s->misc_bits+= bits - s->last_bits;
3093
                        s->last_bits= bits;
3094
                    }
3095
3096
292590
                    s->ptr_lastgob += current_packet_size;
3097
292590
                    s->first_slice_line=1;
3098
292590
                    s->resync_mb_x=mb_x;
3099
292590
                    s->resync_mb_y=mb_y;
3100
                }
3101
            }
3102
3103
3044523
            if(  (s->resync_mb_x   == s->mb_x)
3104
390552
               && s->resync_mb_y+1 == s->mb_y){
3105
8403
                s->first_slice_line=0;
3106
            }
3107
3108
3044523
            s->mb_skipped=0;
3109
3044523
            s->dquant=0; //only for QP_RD
3110
3111
3044523
            update_mb_info(s, 0);
3112
3113

3576415
            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
3114
531892
                int next_block=0;
3115
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3116
3117
531892
                copy_context_before_encode(&backup_s, s, -1);
3118
531892
                backup_s.pb= s->pb;
3119
531892
                best_s.data_partitioning= s->data_partitioning;
3120
531892
                best_s.partitioned_frame= s->partitioned_frame;
3121
531892
                if(s->data_partitioning){
3122
141085
                    backup_s.pb2= s->pb2;
3123
141085
                    backup_s.tex_pb= s->tex_pb;
3124
                }
3125
3126
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
3127
282073
                    s->mv_dir = MV_DIR_FORWARD;
3128
282073
                    s->mv_type = MV_TYPE_16X16;
3129
282073
                    s->mb_intra= 0;
3130
282073
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3131
282073
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3132
282073
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3133
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3134
                }
3135
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3136
13502
                    s->mv_dir = MV_DIR_FORWARD;
3137
13502
                    s->mv_type = MV_TYPE_FIELD;
3138
13502
                    s->mb_intra= 0;
3139
40506
                    for(i=0; i<2; i++){
3140
27004
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3141
27004
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3142
27004
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3143
                    }
3144
13502
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3145
                                 &dmin, &next_block, 0, 0);
3146
                }
3147
531892
                if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3148
60612
                    s->mv_dir = MV_DIR_FORWARD;
3149
60612
                    s->mv_type = MV_TYPE_16X16;
3150
60612
                    s->mb_intra= 0;
3151
60612
                    s->mv[0][0][0] = 0;
3152
60612
                    s->mv[0][0][1] = 0;
3153
60612
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3154
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3155
                }
3156
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3157
209210
                    s->mv_dir = MV_DIR_FORWARD;
3158
209210
                    s->mv_type = MV_TYPE_8X8;
3159
209210
                    s->mb_intra= 0;
3160
1046050
                    for(i=0; i<4; i++){
3161
836840
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3162
836840
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3163
                    }
3164
209210
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3165
                                 &dmin, &next_block, 0, 0);
3166
                }
3167
531892
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3168
229850
                    s->mv_dir = MV_DIR_FORWARD;
3169
229850
                    s->mv_type = MV_TYPE_16X16;
3170
229850
                    s->mb_intra= 0;
3171
229850
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3172
229850
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3173
229850
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3174
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3175
                }
3176
531892
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3177
229850
                    s->mv_dir = MV_DIR_BACKWARD;
3178
229850
                    s->mv_type = MV_TYPE_16X16;
3179
229850
                    s->mb_intra= 0;
3180
229850
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3181
229850
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3182
229850
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3183
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3184
                }
3185
531892
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3186
229850
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3187
229850
                    s->mv_type = MV_TYPE_16X16;
3188
229850
                    s->mb_intra= 0;
3189
229850
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3190
229850
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3191
229850
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3192
229850
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3193
229850
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3194
                                 &dmin, &next_block, 0, 0);
3195
                }
3196
531892
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3197
31700
                    s->mv_dir = MV_DIR_FORWARD;
3198
31700
                    s->mv_type = MV_TYPE_FIELD;
3199
31700
                    s->mb_intra= 0;
3200
95100
                    for(i=0; i<2; i++){
3201
63400
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3202
63400
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3203
63400
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3204
                    }
3205
31700
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3206
                                 &dmin, &next_block, 0, 0);
3207
                }
3208
531892
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3209
31688
                    s->mv_dir = MV_DIR_BACKWARD;
3210
31688
                    s->mv_type = MV_TYPE_FIELD;
3211
31688
                    s->mb_intra= 0;
3212
95064
                    for(i=0; i<2; i++){
3213
63376
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3214
63376
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3215
63376
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3216
                    }
3217
31688
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3218
                                 &dmin, &next_block, 0, 0);
3219
                }
3220
531892
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3221
26999
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3222
26999
                    s->mv_type = MV_TYPE_FIELD;
3223
26999
                    s->mb_intra= 0;
3224
80997
                    for(dir=0; dir<2; dir++){
3225
161994
                        for(i=0; i<2; i++){
3226
107996
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3227
107996
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3228
107996
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3229
                        }
3230
                    }
3231
26999
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3232
                                 &dmin, &next_block, 0, 0);
3233
                }
3234
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3235
115405
                    s->mv_dir = 0;
3236
115405
                    s->mv_type = MV_TYPE_16X16;
3237
115405
                    s->mb_intra= 1;
3238
115405
                    s->mv[0][0][0] = 0;
3239
115405
                    s->mv[0][0][1] = 0;
3240
115405
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3241
                                 &dmin, &next_block, 0, 0);
3242

115405
                    if(s->h263_pred || s->h263_aic){
3243
77193
                        if(best_s.mb_intra)
3244
19644
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3245
                        else
3246
57549
                            ff_clean_intra_table_entries(s); //old mode?
3247
                    }
3248
                }
3249
3250

531892
                if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3251
179660
                    if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3252
161759
                        const int last_qp= backup_s.qscale;
3253
                        int qpi, qp, dc[6];
3254
                        int16_t ac[6][16];
3255
161759
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3256
                        static const int dquant_tab[4]={-1,1,-2,2};
3257

161759
                        int storecoefs = s->mb_intra && s->dc_val[0];
3258
3259
                        av_assert2(backup_s.dquant == 0);
3260
3261
                        //FIXME intra
3262
161759
                        s->mv_dir= best_s.mv_dir;
3263
161759
                        s->mv_type = MV_TYPE_16X16;
3264
161759
                        s->mb_intra= best_s.mb_intra;
3265
161759
                        s->mv[0][0][0] = best_s.mv[0][0][0];
3266
161759
                        s->mv[0][0][1] = best_s.mv[0][0][1];
3267
161759
                        s->mv[1][0][0] = best_s.mv[1][0][0];
3268
161759
                        s->mv[1][0][1] = best_s.mv[1][0][1];
3269
3270
161759
                        qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3271
593063
                        for(; qpi<4; qpi++){
3272
431304
                            int dquant= dquant_tab[qpi];
3273
431304
                            qp= last_qp + dquant;
3274

431304
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3275
41171
                                continue;
3276
390133
                            backup_s.dquant= dquant;
3277
390133
                            if(storecoefs){
3278
261618
                                for(i=0; i<6; i++){
3279
224244
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
3280
224244
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3281
                                }
3282
                            }
3283
3284
390133
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3285
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3286
390133
                            if(best_s.qscale != qp){
3287
357862
                                if(storecoefs){
3288
235802
                                    for(i=0; i<6; i++){
3289
202116
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
3290
202116
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3291
                                    }
3292
                                }
3293
                            }
3294
                        }
3295
                    }
3296
                }
3297
531892
                if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3298
153046
                    int mx= s->b_direct_mv_table[xy][0];
3299
153046
                    int my= s->b_direct_mv_table[xy][1];
3300
3301
153046
                    backup_s.dquant = 0;
3302
153046
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3303
153046
                    s->mb_intra= 0;
3304
153046
                    ff_mpeg4_set_direct_mv(s, mx, my);
3305
153046
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3306
                                 &dmin, &next_block, mx, my);
3307
                }
3308
531892
                if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3309
47505
                    backup_s.dquant = 0;
3310
47505
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3311
47505
                    s->mb_intra= 0;
3312
47505
                    ff_mpeg4_set_direct_mv(s, 0, 0);
3313
47505
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3314
                                 &dmin, &next_block, 0, 0);
3315
                }
3316

531892
                if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3317
                    int coded=0;
3318
                    for(i=0; i<6; i++)
3319
                        coded |= s->block_last_index[i];
3320
                    if(coded){
3321
                        int mx,my;
3322
                        memcpy(s->mv, best_s.mv, sizeof(s->mv));
3323
                        if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3324
                            mx=my=0; //FIXME find the one we actually used
3325
                            ff_mpeg4_set_direct_mv(s, mx, my);
3326
                        }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3327
                            mx= s->mv[1][0][0];
3328
                            my= s->mv[1][0][1];
3329
                        }else{
3330
                            mx= s->mv[0][0][0];
3331
                            my= s->mv[0][0][1];
3332
                        }
3333
3334
                        s->mv_dir= best_s.mv_dir;
3335
                        s->mv_type = best_s.mv_type;
3336
                        s->mb_intra= 0;
3337
/*                        s->mv[0][0][0] = best_s.mv[0][0][0];
3338
                        s->mv[0][0][1] = best_s.mv[0][0][1];
3339
                        s->mv[1][0][0] = best_s.mv[1][0][0];
3340
                        s->mv[1][0][1] = best_s.mv[1][0][1];*/
3341
                        backup_s.dquant= 0;
3342
                        s->skipdct=1;
3343
                        encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3344
                                        &dmin, &next_block, mx, my);
3345
                        s->skipdct=0;
3346
                    }
3347
                }
3348