GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mpegvideo_enc.c Lines: 2013 2898 69.5 %
Date: 2020-04-02 05:41:20 Branches: 1183 1926 61.4 %

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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) {
735
        // (a + x * 3 / 8) / x
736
78
        s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
737
78
        s->inter_quant_bias = 0;
738
    } else {
739
104
        s->intra_quant_bias = 0;
740
        // (a - x / 4) / x
741
104
        s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
742
    }
743
744

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



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

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

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

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

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

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

8592
    if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1509

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

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

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

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

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

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

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

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

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

8333
    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1800
1635
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1801
1635
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1802

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

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

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

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

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

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

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

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

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

4564054
        if (s->luma_elim_threshold && !s->mb_intra)
2489
            for (i = 0; i < 4; i++)
2490
                dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2491

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

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

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


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

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

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

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

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

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

1457851
                               current_packet_size >= s->rtp_payload_size &&
3020
310021
                               mb_y + mb_x > 0;
3021
3022

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

1147830
                switch(s->codec_id){
3025
59400
                case AV_CODEC_ID_H263:
3026
                case AV_CODEC_ID_H263P:
3027
59400
                    if(!s->h263_slice_structured)
3028

59400
                        if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3029
59400
                    break;
3030
849030
                case AV_CODEC_ID_MPEG2VIDEO:
3031

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

292590
                    if(s->start_mb_y != mb_y || mb_x!=0){
3042
291990
                        write_slice_end(s);
3043
3044

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

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

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

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

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

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

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

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

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