GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mpegvideo_enc.c Lines: 2016 2931 68.8 %
Date: 2021-01-21 13:05:02 Branches: 1185 1952 60.7 %

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/mem_internal.h"
40
#include "libavutil/pixdesc.h"
41
#include "libavutil/opt.h"
42
#include "avcodec.h"
43
#include "dct.h"
44
#include "idctdsp.h"
45
#include "mpeg12.h"
46
#include "mpegvideo.h"
47
#include "mpegvideodata.h"
48
#include "h261.h"
49
#include "h263.h"
50
#include "h263data.h"
51
#include "mjpegenc_common.h"
52
#include "mathops.h"
53
#include "mpegutils.h"
54
#include "mjpegenc.h"
55
#include "speedhqenc.h"
56
#include "msmpeg4.h"
57
#include "pixblockdsp.h"
58
#include "qpeldsp.h"
59
#include "faandct.h"
60
#include "thread.h"
61
#include "aandcttab.h"
62
#include "flv.h"
63
#include "mpeg4video.h"
64
#include "internal.h"
65
#include "bytestream.h"
66
#include "wmv2.h"
67
#include "rv10.h"
68
#include "packet_internal.h"
69
#include "libxvid.h"
70
#include <limits.h>
71
#include "sp5x.h"
72
73
#define QUANT_BIAS_SHIFT 8
74
75
#define QMAT_SHIFT_MMX 16
76
#define QMAT_SHIFT 21
77
78
static int encode_picture(MpegEncContext *s, int picture_number);
79
static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
80
static int sse_mb(MpegEncContext *s);
81
static void denoise_dct_c(MpegEncContext *s, int16_t *block);
82
static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
83
84
static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
85
static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
86
87
const AVOption ff_mpv_generic_options[] = {
88
    FF_MPV_COMMON_OPTS
89
    { NULL },
90
};
91
92
3712
void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
93
                       uint16_t (*qmat16)[2][64],
94
                       const uint16_t *quant_matrix,
95
                       int bias, int qmin, int qmax, int intra)
96
{
97
3712
    FDCTDSPContext *fdsp = &s->fdsp;
98
    int qscale;
99
3712
    int shift = 0;
100
101
100478
    for (qscale = qmin; qscale <= qmax; qscale++) {
102
        int i;
103
        int qscale2;
104
105
96766
        if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
106
96704
        else                 qscale2 = qscale << 1;
107
108
96766
        if (fdsp->fdct == ff_jpeg_fdct_islow_8  ||
109
#if CONFIG_FAANDCT
110
96466
            fdsp->fdct == ff_faandct            ||
111
#endif /* CONFIG_FAANDCT */
112
96466
            fdsp->fdct == ff_jpeg_fdct_islow_10) {
113
19500
            for (i = 0; i < 64; i++) {
114
19200
                const int j = s->idsp.idct_permutation[i];
115
19200
                int64_t den = (int64_t) qscale2 * quant_matrix[j];
116
                /* 16 <= qscale * quant_matrix[i] <= 7905
117
                 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
118
                 *             19952 <=              x  <= 249205026
119
                 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
120
                 *           3444240 >= (1 << 36) / (x) >= 275 */
121
122
19200
                qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
123
            }
124
96466
        } else if (fdsp->fdct == ff_fdct_ifast) {
125
6270290
            for (i = 0; i < 64; i++) {
126
6173824
                const int j = s->idsp.idct_permutation[i];
127
6173824
                int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
128
                /* 16 <= qscale * quant_matrix[i] <= 7905
129
                 * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
130
                 *             19952 <=              x  <= 249205026
131
                 * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
132
                 *           3444240 >= (1 << 36) / (x) >= 275 */
133
134
6173824
                qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
135
            }
136
        } else {
137
            for (i = 0; i < 64; i++) {
138
                const int j = s->idsp.idct_permutation[i];
139
                int64_t den = (int64_t) qscale2 * quant_matrix[j];
140
                /* We can safely suppose that 16 <= quant_matrix[i] <= 255
141
                 * Assume x = qscale * quant_matrix[i]
142
                 * So             16 <=              x  <= 7905
143
                 * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
144
                 * so          32768 >= (1 << 19) / (x) >= 67 */
145
                qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
146
                //qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) /
147
                //                    (qscale * quant_matrix[i]);
148
                qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
149
150
                if (qmat16[qscale][0][i] == 0 ||
151
                    qmat16[qscale][0][i] == 128 * 256)
152
                    qmat16[qscale][0][i] = 128 * 256 - 1;
153
                qmat16[qscale][1][i] =
154
                    ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
155
                                qmat16[qscale][0][i]);
156
            }
157
        }
158
159
6197585
        for (i = intra; i < 64; i++) {
160
6100819
            int64_t max = 8191;
161
6100819
            if (fdsp->fdct == ff_fdct_ifast) {
162
6081769
                max = (8191LL * ff_aanscales[i]) >> 14;
163
            }
164
6100819
            while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
165
                shift++;
166
            }
167
        }
168
    }
169
3712
    if (shift) {
170
        av_log(s->avctx, AV_LOG_INFO,
171
               "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
172
               QMAT_SHIFT - shift);
173
    }
174
3712
}
175
176
1281842
static inline void update_qscale(MpegEncContext *s)
177
{
178
    if (s->q_scale_type == 1 && 0) {
179
        int i;
180
        int bestdiff=INT_MAX;
181
        int best = 1;
182
183
        for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
184
            int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
185
            if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
186
                (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
187
                continue;
188
            if (diff < bestdiff) {
189
                bestdiff = diff;
190
                best = i;
191
            }
192
        }
193
        s->qscale = best;
194
    } else {
195
1281842
        s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
196
                    (FF_LAMBDA_SHIFT + 7);
197
1281842
        s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
198
    }
199
200
1281842
    s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
201
                 FF_LAMBDA_SHIFT;
202
1281842
}
203
204
760
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
205
{
206
    int i;
207
208
760
    if (matrix) {
209
        put_bits(pb, 1, 1);
210
        for (i = 0; i < 64; i++) {
211
            put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
212
        }
213
    } else
214
760
        put_bits(pb, 1, 0);
215
760
}
216
217
/**
218
 * init s->current_picture.qscale_table from s->lambda_table
219
 */
220
800
void ff_init_qscale_tab(MpegEncContext *s)
221
{
222
800
    int8_t * const qscale_table = s->current_picture.qscale_table;
223
    int i;
224
225
240350
    for (i = 0; i < s->mb_num; i++) {
226
239550
        unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
227
239550
        int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
228
239550
        qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
229
239550
                                                  s->avctx->qmax);
230
    }
231
800
}
232
233
600
static void update_duplicate_context_after_me(MpegEncContext *dst,
234
                                              MpegEncContext *src)
235
{
236
#define COPY(a) dst->a= src->a
237
600
    COPY(pict_type);
238
600
    COPY(current_picture);
239
600
    COPY(f_code);
240
600
    COPY(b_code);
241
600
    COPY(qscale);
242
600
    COPY(lambda);
243
600
    COPY(lambda2);
244
600
    COPY(picture_in_gop_number);
245
600
    COPY(gop_picture_number);
246
600
    COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
247
600
    COPY(progressive_frame);    // FIXME don't set in encode_header
248
600
    COPY(partitioned_frame);    // FIXME don't set in encode_header
249
#undef COPY
250
600
}
251
252
/**
253
 * Set the given MpegEncContext to defaults for encoding.
254
 * the changed fields will not depend upon the prior state of the MpegEncContext.
255
 */
256
182
static void mpv_encode_defaults(MpegEncContext *s)
257
{
258
    int i;
259
182
    ff_mpv_common_defaults(s);
260
261
6006
    for (i = -16; i < 16; i++) {
262
5824
        default_fcode_tab[i + MAX_MV] = 1;
263
    }
264
182
    s->me.mv_penalty = default_mv_penalty;
265
182
    s->fcode_tab     = default_fcode_tab;
266
267
182
    s->input_picture_number  = 0;
268
182
    s->picture_in_gop_number = 0;
269
182
}
270
271
255
av_cold int ff_dct_encode_init(MpegEncContext *s)
272
{
273
    if (ARCH_X86)
274
255
        ff_dct_encode_init_x86(s);
275
276
    if (CONFIG_H263_ENCODER)
277
255
        ff_h263dsp_init(&s->h263dsp);
278
255
    if (!s->dct_quantize)
279
255
        s->dct_quantize = ff_dct_quantize_c;
280
255
    if (!s->denoise_dct)
281
255
        s->denoise_dct  = denoise_dct_c;
282
255
    s->fast_dct_quantize = s->dct_quantize;
283
255
    if (s->avctx->trellis)
284
35
        s->dct_quantize  = dct_quantize_trellis_c;
285
286
255
    return 0;
287
}
288
289
/* init video encoder */
290
182
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
291
{
292
182
    MpegEncContext *s = avctx->priv_data;
293
    AVCPBProperties *cpb_props;
294
    int i, ret, format_supported;
295
296
182
    mpv_encode_defaults(s);
297
298

182
    switch (avctx->codec_id) {
299
37
    case AV_CODEC_ID_MPEG2VIDEO:
300
37
        if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
301
5
            avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
302
            av_log(avctx, AV_LOG_ERROR,
303
                   "only YUV420 and YUV422 are supported\n");
304
            return AVERROR(EINVAL);
305
        }
306
37
        break;
307
30
    case AV_CODEC_ID_MJPEG:
308
    case AV_CODEC_ID_AMV:
309
30
        format_supported = 0;
310
        /* JPEG color space */
311
30
        if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
312
8
            avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
313
4
            avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
314
            (avctx->color_range == AVCOL_RANGE_JPEG &&
315
             (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
316
              avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
317
              avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
318
30
            format_supported = 1;
319
        /* MPEG color space */
320
        else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
321
                 (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
322
                  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
323
                  avctx->pix_fmt == AV_PIX_FMT_YUV444P))
324
            format_supported = 1;
325
326
30
        if (!format_supported) {
327
            av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
328
            return AVERROR(EINVAL);
329
        }
330
30
        break;
331
    case AV_CODEC_ID_SPEEDHQ:
332
        if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
333
            avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
334
            avctx->pix_fmt != AV_PIX_FMT_YUV444P) {
335
            av_log(avctx, AV_LOG_ERROR,
336
                   "only YUV420/YUV422/YUV444 are supported (no alpha support yet)\n");
337
            return AVERROR(EINVAL);
338
        }
339
        break;
340
115
    default:
341
115
        if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
342
            av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
343
            return AVERROR(EINVAL);
344
        }
345
    }
346
347
182
    switch (avctx->pix_fmt) {
348
4
    case AV_PIX_FMT_YUVJ444P:
349
    case AV_PIX_FMT_YUV444P:
350
4
        s->chroma_format = CHROMA_444;
351
4
        break;
352
9
    case AV_PIX_FMT_YUVJ422P:
353
    case AV_PIX_FMT_YUV422P:
354
9
        s->chroma_format = CHROMA_422;
355
9
        break;
356
169
    case AV_PIX_FMT_YUVJ420P:
357
    case AV_PIX_FMT_YUV420P:
358
    default:
359
169
        s->chroma_format = CHROMA_420;
360
169
        break;
361
    }
362
363
182
    avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
364
365
#if FF_API_PRIVATE_OPT
366
FF_DISABLE_DEPRECATION_WARNINGS
367
182
    if (avctx->rtp_payload_size)
368
        s->rtp_payload_size = avctx->rtp_payload_size;
369
182
    if (avctx->me_penalty_compensation)
370
182
        s->me_penalty_compensation = avctx->me_penalty_compensation;
371
182
    if (avctx->pre_me)
372
        s->me_pre = avctx->pre_me;
373
FF_ENABLE_DEPRECATION_WARNINGS
374
#endif
375
376
182
    s->bit_rate = avctx->bit_rate;
377
182
    s->width    = avctx->width;
378
182
    s->height   = avctx->height;
379
182
    if (avctx->gop_size > 600 &&
380
        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
381
        av_log(avctx, AV_LOG_WARNING,
382
               "keyframe interval too large!, reducing it from %d to %d\n",
383
               avctx->gop_size, 600);
384
        avctx->gop_size = 600;
385
    }
386
182
    s->gop_size     = avctx->gop_size;
387
182
    s->avctx        = avctx;
388
182
    if (avctx->max_b_frames > MAX_B_FRAMES) {
389
        av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
390
               "is %d.\n", MAX_B_FRAMES);
391
        avctx->max_b_frames = MAX_B_FRAMES;
392
    }
393
182
    s->max_b_frames = avctx->max_b_frames;
394
182
    s->codec_id     = avctx->codec->id;
395
182
    s->strict_std_compliance = avctx->strict_std_compliance;
396
182
    s->quarter_sample     = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
397
182
    s->rtp_mode           = !!s->rtp_payload_size;
398
182
    s->intra_dc_precision = avctx->intra_dc_precision;
399
400
    // workaround some differences between how applications specify dc precision
401
182
    if (s->intra_dc_precision < 0) {
402
        s->intra_dc_precision += 8;
403
182
    } else if (s->intra_dc_precision >= 8)
404
1
        s->intra_dc_precision -= 8;
405
406
182
    if (s->intra_dc_precision < 0) {
407
        av_log(avctx, AV_LOG_ERROR,
408
                "intra dc precision must be positive, note some applications use"
409
                " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
410
        return AVERROR(EINVAL);
411
    }
412
413

182
    if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
414
16
        s->huffman = 0;
415
416

182
    if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
417
        av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
418
        return AVERROR(EINVAL);
419
    }
420
182
    s->user_specified_pts = AV_NOPTS_VALUE;
421
422
182
    if (s->gop_size <= 1) {
423
1
        s->intra_only = 1;
424
1
        s->gop_size   = 12;
425
    } else {
426
181
        s->intra_only = 0;
427
    }
428
429
    /* Fixed QSCALE */
430
182
    s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
431
432
546
    s->adaptive_quant = (avctx->lumi_masking ||
433
182
                         avctx->dark_masking ||
434
182
                         avctx->temporal_cplx_masking ||
435
182
                         avctx->spatial_cplx_masking  ||
436
178
                         avctx->p_masking      ||
437
178
                         s->border_masking ||
438

376
                         (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
439
16
                        !s->fixed_qscale;
440
441
182
    s->loop_filter = !!(avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
442
443

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

182
    if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
475
        av_log(avctx, AV_LOG_INFO,
476
               "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
477
    }
478
479

182
    if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
480
        av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
481
        return AVERROR(EINVAL);
482
    }
483
484

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

182
    if ((avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
523
        s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
524
        s->codec_id != AV_CODEC_ID_FLV1) {
525
        av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
526
        return AVERROR(EINVAL);
527
    }
528
529

182
    if (s->obmc && avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
530
        av_log(avctx, AV_LOG_ERROR,
531
               "OBMC is only supported with simple mb decision\n");
532
        return AVERROR(EINVAL);
533
    }
534
535

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

17
        s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
617
        av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
618
        return AVERROR(EINVAL);
619
    }
620
621
#if FF_API_PRIVATE_OPT
622
    FF_DISABLE_DEPRECATION_WARNINGS
623
182
    if (avctx->mpeg_quant)
624
        s->mpeg_quant = avctx->mpeg_quant;
625
    FF_ENABLE_DEPRECATION_WARNINGS
626
#endif
627
628
    // FIXME mpeg2 uses that too
629

182
    if (s->mpeg_quant && (   s->codec_id != AV_CODEC_ID_MPEG4
630
                          && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
631
        av_log(avctx, AV_LOG_ERROR,
632
               "mpeg2 style quantization not supported by codec\n");
633
        return AVERROR(EINVAL);
634
    }
635
636

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

12
        (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
696
        av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
697
        return AVERROR(EINVAL);
698
    }
699
700
182
    if (avctx->thread_count > 1         &&
701
12
        s->codec_id != AV_CODEC_ID_MPEG4      &&
702
8
        s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
703
8
        s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
704
        s->codec_id != AV_CODEC_ID_MJPEG      &&
705
        (s->codec_id != AV_CODEC_ID_H263P)) {
706
        av_log(avctx, AV_LOG_ERROR,
707
               "multi threaded encoding not supported by codec\n");
708
        return AVERROR_PATCHWELCOME;
709
    }
710
711
182
    if (avctx->thread_count < 1) {
712
        av_log(avctx, AV_LOG_ERROR,
713
               "automatic thread number detection not supported by codec, "
714
               "patch welcome\n");
715
        return AVERROR_PATCHWELCOME;
716
    }
717
718

182
    if (!avctx->time_base.den || !avctx->time_base.num) {
719
        av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
720
        return AVERROR(EINVAL);
721
    }
722
723
#if FF_API_PRIVATE_OPT
724
FF_DISABLE_DEPRECATION_WARNINGS
725
182
    if (avctx->b_frame_strategy)
726
        s->b_frame_strategy = avctx->b_frame_strategy;
727
182
    if (avctx->b_sensitivity != 40)
728
        s->b_sensitivity = avctx->b_sensitivity;
729
FF_ENABLE_DEPRECATION_WARNINGS
730
#endif
731
732

182
    if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
733
        av_log(avctx, AV_LOG_INFO,
734
               "notice: b_frame_strategy only affects the first pass\n");
735
        s->b_frame_strategy = 0;
736
    }
737
738
182
    i = av_gcd(avctx->time_base.den, avctx->time_base.num);
739
182
    if (i > 1) {
740
        av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
741
        avctx->time_base.den /= i;
742
        avctx->time_base.num /= i;
743
        //return -1;
744
    }
745
746



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 || s->codec_id == AV_CODEC_ID_SPEEDHQ) {
747
        // (a + x * 3 / 8) / x
748
78
        s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
749
78
        s->inter_quant_bias = 0;
750
    } else {
751
104
        s->intra_quant_bias = 0;
752
        // (a - x / 4) / x
753
104
        s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
754
    }
755
756

182
    if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
757
        av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
758
        return AVERROR(EINVAL);
759
    }
760
761
182
    av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
762
763
182
    if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
764
58
        avctx->time_base.den > (1 << 16) - 1) {
765
        av_log(avctx, AV_LOG_ERROR,
766
               "timebase %d/%d not supported by MPEG 4 standard, "
767
               "the maximum admitted value for the timebase denominator "
768
               "is %d\n", avctx->time_base.num, avctx->time_base.den,
769
               (1 << 16) - 1);
770
        return AVERROR(EINVAL);
771
    }
772
182
    s->time_increment_bits = av_log2(avctx->time_base.den - 1) + 1;
773
774




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

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

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

8151
                if (!s->low_delay && display_picture_number == 1)
1196
67
                    s->dts_delta = pts - last;
1197
            }
1198
8333
            s->user_specified_pts = pts;
1199
        } else {
1200
            if (s->user_specified_pts != AV_NOPTS_VALUE) {
1201
                s->user_specified_pts =
1202
                pts = s->user_specified_pts + 1;
1203
                av_log(s->avctx, AV_LOG_INFO,
1204
                       "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1205
                       pts);
1206
            } else {
1207
                pts = display_picture_number;
1208
            }
1209
        }
1210
1211
8333
        if (!pic_arg->buf[0] ||
1212
8333
            pic_arg->linesize[0] != s->linesize ||
1213
721
            pic_arg->linesize[1] != s->uvlinesize ||
1214
721
            pic_arg->linesize[2] != s->uvlinesize)
1215
7612
            direct = 0;
1216

8333
        if ((s->width & 15) || (s->height & 15))
1217
1625
            direct = 0;
1218
8333
        if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1219
150
            direct = 0;
1220
8333
        if (s->linesize & (STRIDE_ALIGN-1))
1221
            direct = 0;
1222
1223
        ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1224
                pic_arg->linesize[1], s->linesize, s->uvlinesize);
1225
1226
8333
        i = ff_find_unused_picture(s->avctx, s->picture, direct);
1227
8333
        if (i < 0)
1228
            return i;
1229
1230
8333
        pic = &s->picture[i];
1231
8333
        pic->reference = 3;
1232
1233
8333
        if (direct) {
1234
649
            if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1235
                return ret;
1236
        }
1237
8333
        ret = alloc_picture(s, pic, direct);
1238
8333
        if (ret < 0)
1239
            return ret;
1240
1241
8333
        if (!direct) {
1242
7684
            if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1243
                pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1244
                pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1245
                // empty
1246
            } else {
1247
                int h_chroma_shift, v_chroma_shift;
1248
7684
                av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1249
                                                 &h_chroma_shift,
1250
                                                 &v_chroma_shift);
1251
1252
30736
                for (i = 0; i < 3; i++) {
1253
23052
                    int src_stride = pic_arg->linesize[i];
1254
23052
                    int dst_stride = i ? s->uvlinesize : s->linesize;
1255
23052
                    int h_shift = i ? h_chroma_shift : 0;
1256
23052
                    int v_shift = i ? v_chroma_shift : 0;
1257
23052
                    int w = s->width  >> h_shift;
1258
23052
                    int h = s->height >> v_shift;
1259
23052
                    uint8_t *src = pic_arg->data[i];
1260
23052
                    uint8_t *dst = pic->f->data[i];
1261
23052
                    int vpad = 16;
1262
1263
23052
                    if (   s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1264
4530
                        && !s->progressive_sequence
1265
2475
                        && FFALIGN(s->height, 32) - s->height > 16)
1266
600
                        vpad = 32;
1267
1268
23052
                    if (!s->avctx->rc_buffer_size)
1269
22977
                        dst += INPLACE_OFFSET;
1270
1271
23052
                    if (src_stride == dst_stride)
1272
2389
                        memcpy(dst, src, src_stride * h);
1273
                    else {
1274
20663
                        int h2 = h;
1275
20663
                        uint8_t *dst2 = dst;
1276
3363707
                        while (h2--) {
1277
3343044
                            memcpy(dst2, src, w);
1278
3343044
                            dst2 += dst_stride;
1279
3343044
                            src += src_stride;
1280
                        }
1281
                    }
1282

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

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

6986
        if (s->frame_skip_threshold || s->frame_skip_factor) {
1531
            if (s->picture_in_gop_number < s->gop_size &&
1532
                s->next_picture_ptr &&
1533
                skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1534
                // FIXME check that the gop check above is +-1 correct
1535
                av_frame_unref(s->input_picture[0]->f);
1536
1537
                ff_vbv_update(s, 0);
1538
1539
                goto no_output_pic;
1540
            }
1541
        }
1542
1543
6986
        if (/*s->picture_in_gop_number >= s->gop_size ||*/
1544

6986
            !s->next_picture_ptr || s->intra_only) {
1545
1614
            s->reordered_input_picture[0] = s->input_picture[0];
1546
1614
            s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1547
1614
            s->reordered_input_picture[0]->f->coded_picture_number =
1548
1614
                s->coded_picture_number++;
1549
        } else {
1550
5372
            int b_frames = 0;
1551
1552
5372
            if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1553
                for (i = 0; i < s->max_b_frames + 1; i++) {
1554
                    int pict_num = s->input_picture[0]->f->display_picture_number + i;
1555
1556
                    if (pict_num >= s->rc_context.num_entries)
1557
                        break;
1558
                    if (!s->input_picture[i]) {
1559
                        s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1560
                        break;
1561
                    }
1562
1563
                    s->input_picture[i]->f->pict_type =
1564
                        s->rc_context.entry[pict_num].new_pict_type;
1565
                }
1566
            }
1567
1568
5372
            if (s->b_frame_strategy == 0) {
1569
5372
                b_frames = s->max_b_frames;
1570

5457
                while (b_frames && !s->input_picture[b_frames])
1571
85
                    b_frames--;
1572
            } else if (s->b_frame_strategy == 1) {
1573
                for (i = 1; i < s->max_b_frames + 1; i++) {
1574
                    if (s->input_picture[i] &&
1575
                        s->input_picture[i]->b_frame_score == 0) {
1576
                        s->input_picture[i]->b_frame_score =
1577
                            get_intra_count(s,
1578
                                            s->input_picture[i    ]->f->data[0],
1579
                                            s->input_picture[i - 1]->f->data[0],
1580
                                            s->linesize) + 1;
1581
                    }
1582
                }
1583
                for (i = 0; i < s->max_b_frames + 1; i++) {
1584
                    if (!s->input_picture[i] ||
1585
                        s->input_picture[i]->b_frame_score - 1 >
1586
                            s->mb_num / s->b_sensitivity)
1587
                        break;
1588
                }
1589
1590
                b_frames = FFMAX(0, i - 1);
1591
1592
                /* reset scores */
1593
                for (i = 0; i < b_frames + 1; i++) {
1594
                    s->input_picture[i]->b_frame_score = 0;
1595
                }
1596
            } else if (s->b_frame_strategy == 2) {
1597
                b_frames = estimate_best_b_count(s);
1598
                if (b_frames < 0)
1599
                    return b_frames;
1600
            }
1601
1602
5372
            emms_c();
1603
1604
6719
            for (i = b_frames - 1; i >= 0; i--) {
1605
1347
                int type = s->input_picture[i]->f->pict_type;
1606

1347
                if (type && type != AV_PICTURE_TYPE_B)
1607
                    b_frames = i;
1608
            }
1609
5372
            if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1610
                b_frames == s->max_b_frames) {
1611
                av_log(s->avctx, AV_LOG_ERROR,
1612
                       "warning, too many B-frames in a row\n");
1613
            }
1614
1615
5372
            if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1616
537
                if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1617
                    s->gop_size > s->picture_in_gop_number) {
1618
                    b_frames = s->gop_size - s->picture_in_gop_number - 1;
1619
                } else {
1620
537
                    if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1621
                        b_frames = 0;
1622
537
                    s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1623
                }
1624
            }
1625
1626

5372
            if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1627
                s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1628
                b_frames--;
1629
1630
5372
            s->reordered_input_picture[0] = s->input_picture[b_frames];
1631
5372
            if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1632
4833
                s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1633
5372
            s->reordered_input_picture[0]->f->coded_picture_number =
1634
5372
                s->coded_picture_number++;
1635
6719
            for (i = 0; i < b_frames; i++) {
1636
1347
                s->reordered_input_picture[i + 1] = s->input_picture[i];
1637
1347
                s->reordered_input_picture[i + 1]->f->pict_type =
1638
                    AV_PICTURE_TYPE_B;
1639
1347
                s->reordered_input_picture[i + 1]->f->coded_picture_number =
1640
1347
                    s->coded_picture_number++;
1641
            }
1642
        }
1643
    }
1644
6939
no_output_pic:
1645
8553
    ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1646
1647
8553
    if (s->reordered_input_picture[0]) {
1648
8333
        s->reordered_input_picture[0]->reference =
1649
8333
           s->reordered_input_picture[0]->f->pict_type !=
1650
8333
               AV_PICTURE_TYPE_B ? 3 : 0;
1651
1652
8333
        if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1653
            return ret;
1654
1655

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

8333
    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1773
6622
        s->last_picture_ptr != s->next_picture_ptr &&
1774
6622
        s->last_picture_ptr->f->buf[0]) {
1775
6622
        ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1776
    }
1777
1778
8333
    s->current_picture_ptr->f->pict_type = s->pict_type;
1779
8333
    s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1780
1781
8333
    ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1782
8333
    if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1783
                                   s->current_picture_ptr)) < 0)
1784
        return ret;
1785
1786
8333
    if (s->pict_type != AV_PICTURE_TYPE_B) {
1787
6986
        s->last_picture_ptr = s->next_picture_ptr;
1788
6986
        if (!s->droppable)
1789
6986
            s->next_picture_ptr = s->current_picture_ptr;
1790
    }
1791
1792
8333
    if (s->last_picture_ptr) {
1793
8151
        ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1794

16302
        if (s->last_picture_ptr->f->buf[0] &&
1795
8151
            (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1796
                                       s->last_picture_ptr)) < 0)
1797
            return ret;
1798
    }
1799
8333
    if (s->next_picture_ptr) {
1800
8333
        ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1801

16666
        if (s->next_picture_ptr->f->buf[0] &&
1802
8333
            (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1803
                                       s->next_picture_ptr)) < 0)
1804
            return ret;
1805
    }
1806
1807
8333
    if (s->picture_structure!= PICT_FRAME) {
1808
        int i;
1809
        for (i = 0; i < 4; i++) {
1810
            if (s->picture_structure == PICT_BOTTOM_FIELD) {
1811
                s->current_picture.f->data[i] +=
1812
                    s->current_picture.f->linesize[i];
1813
            }
1814
            s->current_picture.f->linesize[i] *= 2;
1815
            s->last_picture.f->linesize[i]    *= 2;
1816
            s->next_picture.f->linesize[i]    *= 2;
1817
        }
1818
    }
1819
1820

8333
    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1821
1635
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1822
1635
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1823

6698
    } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1824
4780
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1825
4780
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1826
    } else {
1827
1918
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1828
1918
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1829
    }
1830
1831
8333
    if (s->dct_error_sum) {
1832
        av_assert2(s->noise_reduction && s->encoding);
1833
200
        update_noise_reduction(s);
1834
    }
1835
1836
8333
    return 0;
1837
}
1838
1839
8553
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1840
                          const AVFrame *pic_arg, int *got_packet)
1841
{
1842
8553
    MpegEncContext *s = avctx->priv_data;
1843
    int i, stuffing_count, ret;
1844
8553
    int context_count = s->slice_context_count;
1845
1846
8553
    s->vbv_ignore_qmax = 0;
1847
1848
8553
    s->picture_in_gop_number++;
1849
1850
8553
    if (load_input_picture(s, pic_arg) < 0)
1851
        return -1;
1852
1853
8553
    if (select_input_picture(s) < 0) {
1854
        return -1;
1855
    }
1856
1857
    /* output? */
1858
8553
    if (s->new_picture.f->data[0]) {
1859

8333
        int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1860
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
1861
8333
                                              :
1862
1000
                                              s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1863
8333
        if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1864
            return ret;
1865
8333
        if (s->mb_info) {
1866
            s->mb_info_ptr = av_packet_new_side_data(pkt,
1867
                                 AV_PKT_DATA_H263_MB_INFO,
1868
                                 s->mb_width*s->mb_height*12);
1869
            s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1870
        }
1871
1872
17266
        for (i = 0; i < context_count; i++) {
1873
8933
            int start_y = s->thread_context[i]->start_mb_y;
1874
8933
            int   end_y = s->thread_context[i]->  end_mb_y;
1875
8933
            int h       = s->mb_height;
1876
8933
            uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1877
8933
            uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);
1878
1879
8933
            init_put_bits(&s->thread_context[i]->pb, start, end - start);
1880
        }
1881
1882
8333
        s->pict_type = s->new_picture.f->pict_type;
1883
        //emms_c();
1884
8333
        ret = frame_start(s);
1885
8333
        if (ret < 0)
1886
            return ret;
1887
8333
vbv_retry:
1888
8458
        ret = encode_picture(s, s->picture_number);
1889
8458
        if (growing_buffer) {
1890
7458
            av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1891
7458
            pkt->data = s->pb.buf;
1892
7458
            pkt->size = avctx->internal->byte_buffer_size;
1893
        }
1894
8458
        if (ret < 0)
1895
            return -1;
1896
1897
#if FF_API_STAT_BITS
1898
FF_DISABLE_DEPRECATION_WARNINGS
1899
8458
        avctx->header_bits = s->header_bits;
1900
8458
        avctx->mv_bits     = s->mv_bits;
1901
8458
        avctx->misc_bits   = s->misc_bits;
1902
8458
        avctx->i_tex_bits  = s->i_tex_bits;
1903
8458
        avctx->p_tex_bits  = s->p_tex_bits;
1904
8458
        avctx->i_count     = s->i_count;
1905
        // FIXME f/b_count in avctx
1906
8458
        avctx->p_count     = s->mb_num - s->i_count - s->skip_count;
1907
8458
        avctx->skip_count  = s->skip_count;
1908
FF_ENABLE_DEPRECATION_WARNINGS
1909
#endif
1910
1911
8458
        frame_end(s);
1912
1913
8458
        if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1914
1438
            ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1915
1916
8458
        if (avctx->rc_buffer_size) {
1917
150
            RateControlContext *rcc = &s->rc_context;
1918
150
            int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1919

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

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

177110
                            if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2252
69152
                                s->dquant = 0;
2253
                        }
2254
221829
                        if (s->mv_type == MV_TYPE_8X8)
2255
31669
                            s->dquant = 0;
2256
                    }
2257
                }
2258
            }
2259
        }
2260
1271769
        ff_set_qscale(s, last_qp + s->dquant);
2261
3292285
    } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2262
        ff_set_qscale(s, s->qscale + s->dquant);
2263
2264
4564054
    wrap_y = s->linesize;
2265
4564054
    wrap_c = s->uvlinesize;
2266
4564054
    ptr_y  = s->new_picture.f->data[0] +
2267
4564054
             (mb_y * 16 * wrap_y)              + mb_x * 16;
2268
4564054
    ptr_cb = s->new_picture.f->data[1] +
2269
4564054
             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2270
4564054
    ptr_cr = s->new_picture.f->data[2] +
2271
4564054
             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2272
2273

4564054
    if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2274
20323
        uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2275
20323
        int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
2276
20323
        int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2277
20323
        s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2278
                                 wrap_y, wrap_y,
2279
                                 16, 16, mb_x * 16, mb_y * 16,
2280
                                 s->width, s->height);
2281
20323
        ptr_y = ebuf;
2282
20323
        s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2283
                                 wrap_c, wrap_c,
2284
                                 mb_block_width, mb_block_height,
2285
                                 mb_x * mb_block_width, mb_y * mb_block_height,
2286
                                 cw, ch);
2287
20323
        ptr_cb = ebuf + 16 * wrap_y;
2288
20323
        s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2289
                                 wrap_c, wrap_c,
2290
                                 mb_block_width, mb_block_height,
2291
                                 mb_x * mb_block_width, mb_y * mb_block_height,
2292
                                 cw, ch);
2293
20323
        ptr_cr = ebuf + 16 * wrap_y + 16;
2294
    }
2295
2296
4564054
    if (s->mb_intra) {
2297
1185216
        if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2298
            int progressive_score, interlaced_score;
2299
2300
317596
            s->interlaced_dct = 0;
2301
317596
            progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2302
317596
                                s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2303
                                                     NULL, wrap_y, 8) - 400;
2304
2305
317596
            if (progressive_score > 0) {
2306
298126
                interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2307
                                                        NULL, wrap_y * 2, 8) +
2308
298126
                                   s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2309
                                                        NULL, wrap_y * 2, 8);
2310
298126
                if (progressive_score > interlaced_score) {
2311
364
                    s->interlaced_dct = 1;
2312
2313
364
                    dct_offset = wrap_y;
2314
364
                    uv_dct_offset = wrap_c;
2315
364
                    wrap_y <<= 1;
2316
364
                    if (s->chroma_format == CHROMA_422 ||
2317
185
                        s->chroma_format == CHROMA_444)
2318
179
                        wrap_c <<= 1;
2319
                }
2320
            }
2321
        }
2322
2323
1185216
        s->pdsp.get_pixels(s->block[0], ptr_y,                  wrap_y);
2324
1185216
        s->pdsp.get_pixels(s->block[1], ptr_y + 8,              wrap_y);
2325
1185216
        s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset,     wrap_y);
2326
1185216
        s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2327
2328
1185216
        if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2329
            skip_dct[4] = 1;
2330
            skip_dct[5] = 1;
2331
        } else {
2332
1185216
            s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2333
1185216
            s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2334

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

829856
            } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2338
59850
                s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2339
59850
                s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2340
59850
                s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2341
59850
                s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2342
59850
                s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2343
59850
                s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2344
            }
2345
        }
2346
    } else {
2347
        op_pixels_func (*op_pix)[4];
2348
        qpel_mc_func (*op_qpix)[16];
2349
        uint8_t *dest_y, *dest_cb, *dest_cr;
2350
2351
3378838
        dest_y  = s->dest[0];
2352
3378838
        dest_cb = s->dest[1];
2353
3378838
        dest_cr = s->dest[2];
2354
2355

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

4564054
        if (s->luma_elim_threshold && !s->mb_intra)
2510
            for (i = 0; i < 4; i++)
2511
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2512

4564054
        if (s->chroma_elim_threshold && !s->mb_intra)
2513
            for (i = 4; i < mb_block_count; i++)
2514
                dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2515
2516
4564054
        if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2517
            for (i = 0; i < mb_block_count; i++) {
2518
                if (s->block_last_index[i] == -1)
2519
                    s->coded_score[i] = INT_MAX / 256;
2520
            }
2521
        }
2522
    }
2523
2524

4564054
    if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2525
        s->block_last_index[4] =
2526
        s->block_last_index[5] = 0;
2527
        s->block[4][0] =
2528
        s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2529
        if (!s->chroma_y_shift) { /* 422 / 444 */
2530
            for (i=6; i<12; i++) {
2531
                s->block_last_index[i] = 0;
2532
                s->block[i][0] = s->block[4][0];
2533
            }
2534
        }
2535
    }
2536
2537
    // non c quantize code returns incorrect block_last_index FIXME
2538

4564054
    if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2539
        for (i = 0; i < mb_block_count; i++) {
2540
            int j;
2541
            if (s->block_last_index[i] > 0) {
2542
                for (j = 63; j > 0; j--) {
2543
                    if (s->block[i][s->intra_scantable.permutated[j]])
2544
                        break;
2545
                }
2546
                s->block_last_index[i] = j;
2547
            }
2548
        }
2549
    }
2550
2551
    /* huffman encode */
2552


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

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

24804
    else if(w==8 && h==8)
2731
        return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2732
2733
132172
    for(y=0; y<h; y++){
2734
397486
        for(x=0; x<w; x++){
2735
290118
            acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2736
        }
2737
    }
2738
2739
    av_assert2(acc>=0);
2740
2741
24804
    return acc;
2742
}
2743
2744
1674464
static int sse_mb(MpegEncContext *s){
2745
1674464
    int w= 16;
2746
1674464
    int h= 16;
2747
2748
1674464
    if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2749
1674464
    if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2750
2751

1674464
    if(w==16 && h==16)
2752
1666196
      if(s->avctx->mb_cmp == FF_CMP_NSSE){
2753
        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) +
2754
               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) +
2755
               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);
2756
      }else{
2757
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) +
2758
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) +
2759
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);
2760
      }
2761
    else
2762
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)
2763
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)
2764
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);
2765
}
2766
2767
static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2768
    MpegEncContext *s= *(void**)arg;
2769
2770
2771
    s->me.pre_pass=1;
2772
    s->me.dia_size= s->avctx->pre_dia_size;
2773
    s->first_slice_line=1;
2774
    for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2775
        for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2776
            ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2777
        }
2778
        s->first_slice_line=0;
2779
    }
2780
2781
    s->me.pre_pass=0;
2782
2783
    return 0;
2784
}
2785
2786
6722
static int estimate_motion_thread(AVCodecContext *c, void *arg){
2787
6722
    MpegEncContext *s= *(void**)arg;
2788
2789
6722
    ff_check_alignment();
2790
2791
6722
    s->me.dia_size= s->avctx->dia_size;
2792
6722
    s->first_slice_line=1;
2793
102293
    for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2794
95571
        s->mb_x=0; //for block init below
2795
95571
        ff_init_block_index(s);
2796
2206530
        for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2797
2110959
            s->block_index[0]+=2;
2798
2110959
            s->block_index[1]+=2;
2799
2110959
            s->block_index[2]+=2;
2800
2110959
            s->block_index[3]+=2;
2801
2802
            /* compute motion vector & mb_type and store in context */
2803
2110959
            if(s->pict_type==AV_PICTURE_TYPE_B)
2804
408312
                ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2805
            else
2806
1702647
                ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2807
        }
2808
95571
        s->first_slice_line=0;
2809
    }
2810
6722
    return 0;
2811
}
2812
2813
366
static int mb_var_thread(AVCodecContext *c, void *arg){
2814
366
    MpegEncContext *s= *(void**)arg;
2815
    int mb_x, mb_y;
2816
2817
366
    ff_check_alignment();
2818
2819
5357
    for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2820
112814
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2821
107823
            int xx = mb_x * 16;
2822
107823
            int yy = mb_y * 16;
2823
107823
            uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2824
            int varc;
2825
107823
            int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2826
2827
107823
            varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2828
107823
                    (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2829
2830
107823
            s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2831
107823
            s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2832
107823
            s->me.mb_var_sum_temp    += varc;
2833
        }
2834
    }
2835
366
    return 0;
2836
}
2837
2838
301048
static void write_slice_end(MpegEncContext *s){
2839
301048
    if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2840
5813
        if(s->partitioned_frame){
2841
1760
            ff_mpeg4_merge_partitions(s);
2842
        }
2843
2844
5813
        ff_mpeg4_stuffing(&s->pb);
2845
295235
    }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2846
1438
        ff_mjpeg_encode_stuffing(s);
2847
293797
    } else if (CONFIG_SPEEDHQ_ENCODER && s->out_format == FMT_SPEEDHQ) {
2848
        ff_speedhq_end_slice(s);
2849
    }
2850
2851
301048
    flush_put_bits(&s->pb);
2852
2853

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

840
            s->gob_index = H263_GOB_HEIGHT(s->height);
2988
840
        break;
2989
2690
    case AV_CODEC_ID_MPEG4:
2990
2690
        if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2991
544
            ff_mpeg4_init_partitions(s);
2992
2690
        break;
2993
    }
2994
2995
9058
    s->resync_mb_x=0;
2996
9058
    s->resync_mb_y=0;
2997
9058
    s->first_slice_line = 1;
2998
9058
    s->ptr_lastgob = s->pb.buf;
2999
141867
    for (mb_y_order = s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3000
132809
        if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
3001
            int first_in_slice;
3002
            mb_y = ff_speedhq_mb_y_order_to_mb(mb_y_order, s->mb_height, &first_in_slice);
3003
            if (first_in_slice && mb_y_order != s->start_mb_y)
3004
                ff_speedhq_end_slice(s);
3005
            s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 1024 << s->intra_dc_precision;
3006
        } else {
3007
132809
            mb_y = mb_y_order;
3008
        }
3009
132809
        s->mb_x=0;
3010
132809
        s->mb_y= mb_y;
3011
3012
132809
        ff_set_qscale(s, s->qscale);
3013
132809
        ff_init_block_index(s);
3014
3015
3177332
        for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3016
3044523
            int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3017
3044523
            int mb_type= s->mb_type[xy];
3018
//            int d;
3019
3044523
            int dmin= INT_MAX;
3020
            int dir;
3021
3044523
            int size_increase =  s->avctx->internal->byte_buffer_size/4
3022
3044523
                               + s->mb_width*MAX_MB_BYTES;
3023
3024
3044523
            ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3025
3044523
            if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3026
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3027
                return -1;
3028
            }
3029
3044523
            if(s->data_partitioning){
3030
179550
                if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
3031
179550
                   || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3032
                    av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3033
                    return -1;
3034
                }
3035
            }
3036
3037
3044523
            s->mb_x = mb_x;
3038
3044523
            s->mb_y = mb_y;  // moved into loop, can get changed by H.261
3039
3044523
            ff_update_block_index(s);
3040
3041
3044523
            if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3042
118800
                ff_h261_reorder_mb_index(s);
3043
118800
                xy= s->mb_y*s->mb_stride + s->mb_x;
3044
118800
                mb_type= s->mb_type[xy];
3045
            }
3046
3047
            /* write gob / video packet header  */
3048
3044523
            if(s->rtp_mode){
3049
                int current_packet_size, is_gob_start;
3050
3051
1147830
                current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
3052
3053
2850960
                is_gob_start = s->rtp_payload_size &&
3054

1457851
                               current_packet_size >= s->rtp_payload_size &&
3055
310021
                               mb_y + mb_x > 0;
3056
3057

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

1147830
                switch(s->codec_id){
3060
59400
                case AV_CODEC_ID_H263:
3061
                case AV_CODEC_ID_H263P:
3062
59400
                    if(!s->h263_slice_structured)
3063

59400
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3064
59400
                    break;
3065
849030
                case AV_CODEC_ID_MPEG2VIDEO:
3066

849030
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3067
                case AV_CODEC_ID_MPEG1VIDEO:
3068
908880
                    if(s->mb_skip_run) is_gob_start=0;
3069
908880
                    break;
3070
                case AV_CODEC_ID_MJPEG:
3071
                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3072
                    break;
3073
                }
3074
3075
1147830
                if(is_gob_start){
3076

292590
                    if(s->start_mb_y != mb_y || mb_x!=0){
3077
291990
                        write_slice_end(s);
3078
3079

291990
                        if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3080
1216
                            ff_mpeg4_init_partitions(s);
3081
                        }
3082
                    }
3083
3084
                    av_assert2((put_bits_count(&s->pb)&7) == 0);
3085
292590
                    current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3086
3087

292590
                    if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3088
287
                        int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
3089
287
                        int d = 100 / s->error_rate;
3090
287
                        if(r % d == 0){
3091
32
                            current_packet_size=0;
3092
32
                            s->pb.buf_ptr= s->ptr_lastgob;
3093
                            av_assert1(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3094
                        }
3095
                    }
3096
3097
#if FF_API_RTP_CALLBACK
3098
FF_DISABLE_DEPRECATION_WARNINGS
3099
292590
                    if (s->avctx->rtp_callback){
3100
                        int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3101
                        s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3102
                    }
3103
FF_ENABLE_DEPRECATION_WARNINGS
3104
#endif
3105
292590
                    update_mb_info(s, 1);
3106
3107

292590
                    switch(s->codec_id){
3108
3323
                    case AV_CODEC_ID_MPEG4:
3109
                        if (CONFIG_MPEG4_ENCODER) {
3110
3323
                            ff_mpeg4_encode_video_packet_header(s);
3111
3323
                            ff_mpeg4_clean_buffers(s);
3112
                        }
3113
3323
                    break;
3114
286723
                    case AV_CODEC_ID_MPEG1VIDEO:
3115
                    case AV_CODEC_ID_MPEG2VIDEO:
3116
                        if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3117
286723
                            ff_mpeg1_encode_slice_header(s);
3118
286723
                            ff_mpeg1_clean_buffers(s);
3119
                        }
3120
286723
                    break;
3121
2544
                    case AV_CODEC_ID_H263:
3122
                    case AV_CODEC_ID_H263P:
3123
                        if (CONFIG_H263_ENCODER)
3124
2544
                            ff_h263_encode_gob_header(s, mb_y);
3125
2544
                    break;
3126
                    }
3127
3128
292590
                    if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3129
                        int bits= put_bits_count(&s->pb);
3130
                        s->misc_bits+= bits - s->last_bits;
3131
                        s->last_bits= bits;
3132
                    }
3133
3134
292590
                    s->ptr_lastgob += current_packet_size;
3135
292590
                    s->first_slice_line=1;
3136
292590
                    s->resync_mb_x=mb_x;
3137
292590
                    s->resync_mb_y=mb_y;
3138
                }
3139
            }
3140
3141
3044523
            if(  (s->resync_mb_x   == s->mb_x)
3142
390552
               && s->resync_mb_y+1 == s->mb_y){
3143
8403
                s->first_slice_line=0;
3144
            }
3145
3146
3044523
            s->mb_skipped=0;
3147
3044523
            s->dquant=0; //only for QP_RD
3148
3149
3044523
            update_mb_info(s, 0);
3150
3151

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
3152
531892
                int next_block=0;
3153
                int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3154
3155
531892
                copy_context_before_encode(&backup_s, s, -1);
3156
531892
                backup_s.pb= s->pb;
3157
531892
                best_s.data_partitioning= s->data_partitioning;
3158
531892
                best_s.partitioned_frame= s->partitioned_frame;
3159
531892
                if(s->data_partitioning){
3160
141085
                    backup_s.pb2= s->pb2;
3161
141085
                    backup_s.tex_pb= s->tex_pb;
3162
                }
3163
3164
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTER){
3165
282073
                    s->mv_dir = MV_DIR_FORWARD;
3166
282073
                    s->mv_type = MV_TYPE_16X16;
3167
282073
                    s->mb_intra= 0;
3168
282073
                    s->mv[0][0][0] = s->p_mv_table[xy][0];
3169
282073
                    s->mv[0][0][1] = s->p_mv_table[xy][1];
3170
282073
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3171
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3172
                }
3173
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3174
13502
                    s->mv_dir = MV_DIR_FORWARD;
3175
13502
                    s->mv_type = MV_TYPE_FIELD;
3176
13502
                    s->mb_intra= 0;
3177
40506
                    for(i=0; i<2; i++){
3178
27004
                        j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3179
27004
                        s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3180
27004
                        s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3181
                    }
3182
13502
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3183
                                 &dmin, &next_block, 0, 0);
3184
                }
3185
531892
                if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3186
60612
                    s->mv_dir = MV_DIR_FORWARD;
3187
60612
                    s->mv_type = MV_TYPE_16X16;
3188
60612
                    s->mb_intra= 0;
3189
60612
                    s->mv[0][0][0] = 0;
3190
60612
                    s->mv[0][0][1] = 0;
3191
60612
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3192
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3193
                }
3194
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3195
209210
                    s->mv_dir = MV_DIR_FORWARD;
3196
209210
                    s->mv_type = MV_TYPE_8X8;
3197
209210
                    s->mb_intra= 0;
3198
1046050
                    for(i=0; i<4; i++){
3199
836840
                        s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3200
836840
                        s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3201
                    }
3202
209210
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3203
                                 &dmin, &next_block, 0, 0);
3204
                }
3205
531892
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3206
229850
                    s->mv_dir = MV_DIR_FORWARD;
3207
229850
                    s->mv_type = MV_TYPE_16X16;
3208
229850
                    s->mb_intra= 0;
3209
229850
                    s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3210
229850
                    s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3211
229850
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3212
                                 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3213
                }
3214
531892
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3215
229850
                    s->mv_dir = MV_DIR_BACKWARD;
3216
229850
                    s->mv_type = MV_TYPE_16X16;
3217
229850
                    s->mb_intra= 0;
3218
229850
                    s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3219
229850
                    s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3220
229850
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3221
                                 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3222
                }
3223
531892
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3224
229850
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3225
229850
                    s->mv_type = MV_TYPE_16X16;
3226
229850
                    s->mb_intra= 0;
3227
229850
                    s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3228
229850
                    s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3229
229850
                    s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3230
229850
                    s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3231
229850
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3232
                                 &dmin, &next_block, 0, 0);
3233
                }
3234
531892
                if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3235
31700
                    s->mv_dir = MV_DIR_FORWARD;
3236
31700
                    s->mv_type = MV_TYPE_FIELD;
3237
31700
                    s->mb_intra= 0;
3238
95100
                    for(i=0; i<2; i++){
3239
63400
                        j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3240
63400
                        s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3241
63400
                        s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3242
                    }
3243
31700
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3244
                                 &dmin, &next_block, 0, 0);
3245
                }
3246
531892
                if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3247
31688
                    s->mv_dir = MV_DIR_BACKWARD;
3248
31688
                    s->mv_type = MV_TYPE_FIELD;
3249
31688
                    s->mb_intra= 0;
3250
95064
                    for(i=0; i<2; i++){
3251
63376
                        j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3252
63376
                        s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3253
63376
                        s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3254
                    }
3255
31688
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3256
                                 &dmin, &next_block, 0, 0);
3257
                }
3258
531892
                if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3259
26999
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3260
26999
                    s->mv_type = MV_TYPE_FIELD;
3261
26999
                    s->mb_intra= 0;
3262
80997
                    for(dir=0; dir<2; dir++){
3263
161994
                        for(i=0; i<2; i++){
3264
107996
                            j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3265
107996
                            s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3266
107996
                            s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3267
                        }
3268
                    }
3269
26999
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3270
                                 &dmin, &next_block, 0, 0);
3271
                }
3272
531892
                if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3273
115405
                    s->mv_dir = 0;
3274
115405
                    s->mv_type = MV_TYPE_16X16;
3275
115405
                    s->mb_intra= 1;
3276
115405
                    s->mv[0][0][0] = 0;
3277
115405
                    s->mv[0][0][1] = 0;
3278
115405
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3279
                                 &dmin, &next_block, 0, 0);
3280

115405
                    if(s->h263_pred || s->h263_aic){
3281
77193
                        if(best_s.mb_intra)
3282
19644
                            s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3283
                        else
3284
57549
                            ff_clean_intra_table_entries(s); //old mode?
3285
                    }
3286
                }
3287
3288

531892
                if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3289
179660
                    if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3290
161759
                        const int last_qp= backup_s.qscale;
3291
                        int qpi, qp, dc[6];
3292
                        int16_t ac[6][16];
3293
161759
                        const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3294
                        static const int dquant_tab[4]={-1,1,-2,2};
3295

161759
                        int storecoefs = s->mb_intra && s->dc_val[0];
3296
3297
                        av_assert2(backup_s.dquant == 0);
3298
3299
                        //FIXME intra
3300
161759
                        s->mv_dir= best_s.mv_dir;
3301
161759
                        s->mv_type = MV_TYPE_16X16;
3302
161759
                        s->mb_intra= best_s.mb_intra;
3303
161759
                        s->mv[0][0][0] = best_s.mv[0][0][0];
3304
161759
                        s->mv[0][0][1] = best_s.mv[0][0][1];
3305
161759
                        s->mv[1][0][0] = best_s.mv[1][0][0];
3306
161759
                        s->mv[1][0][1] = best_s.mv[1][0][1];
3307
3308
161759
                        qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3309
593063
                        for(; qpi<4; qpi++){
3310
431304
                            int dquant= dquant_tab[qpi];
3311
431304
                            qp= last_qp + dquant;
3312

431304
                            if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3313
41171
                                continue;
3314
390133
                            backup_s.dquant= dquant;
3315
390133
                            if(storecoefs){
3316
261618
                                for(i=0; i<6; i++){
3317
224244
                                    dc[i]= s->dc_val[0][ s->block_index[i] ];
3318
224244
                                    memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3319
                                }
3320
                            }
3321
3322
390133
                            encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3323
                                         &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3324
390133
                            if(best_s.qscale != qp){
3325
357862
                                if(storecoefs){
3326
235802
                                    for(i=0; i<6; i++){
3327
202116
                                        s->dc_val[0][ s->block_index[i] ]= dc[i];
3328
202116
                                        memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3329
                                    }
3330
                                }
3331
                            }
3332
                        }
3333
                    }
3334
                }
3335
531892
                if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3336
153046
                    int mx= s->b_direct_mv_table[xy][0];
3337
153046
                    int my= s->b_direct_mv_table[xy][1];
3338
3339
153046
                    backup_s.dquant = 0;
3340
153046
                    s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3341
153046
                    s->mb_intra= 0;
3342
153046
                    ff_mpeg4_set_direct_mv(s, mx, my);
3343
153046
                    encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3344
                                 &dmin, &next_block, mx, my);
3345
                }
3346
531892
                if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3347
47505
                    backup_s.dquant = 0;
3348