GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mpegvideo.c Lines: 994 1364 72.9 %
Date: 2019-11-18 18:00:01 Branches: 459 864 53.1 %

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
 * @file
27
 * The simplest mpeg encoder (well, it was the simplest!).
28
 */
29
30
#include "libavutil/attributes.h"
31
#include "libavutil/avassert.h"
32
#include "libavutil/imgutils.h"
33
#include "libavutil/internal.h"
34
#include "libavutil/motion_vector.h"
35
#include "libavutil/timer.h"
36
#include "avcodec.h"
37
#include "blockdsp.h"
38
#include "h264chroma.h"
39
#include "idctdsp.h"
40
#include "internal.h"
41
#include "mathops.h"
42
#include "mpeg_er.h"
43
#include "mpegutils.h"
44
#include "mpegvideo.h"
45
#include "mpegvideodata.h"
46
#include "mjpegenc.h"
47
#include "msmpeg4.h"
48
#include "qpeldsp.h"
49
#include "thread.h"
50
#include "wmv2.h"
51
#include <limits.h>
52
53
126126
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
54
                                   int16_t *block, int n, int qscale)
55
{
56
    int i, level, nCoeffs;
57
    const uint16_t *quant_matrix;
58
59
126126
    nCoeffs= s->block_last_index[n];
60
61
126126
    block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
62
    /* XXX: only MPEG-1 */
63
126126
    quant_matrix = s->intra_matrix;
64
3042075
    for(i=1;i<=nCoeffs;i++) {
65
2915949
        int j= s->intra_scantable.permutated[i];
66
2915949
        level = block[j];
67
2915949
        if (level) {
68
1215436
            if (level < 0) {
69
604537
                level = -level;
70
604537
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
71
604537
                level = (level - 1) | 1;
72
604537
                level = -level;
73
            } else {
74
610899
                level = (int)(level * qscale * quant_matrix[j]) >> 3;
75
610899
                level = (level - 1) | 1;
76
            }
77
1215436
            block[j] = level;
78
        }
79
    }
80
126126
}
81
82
285535
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
83
                                   int16_t *block, int n, int qscale)
84
{
85
    int i, level, nCoeffs;
86
    const uint16_t *quant_matrix;
87
88
285535
    nCoeffs= s->block_last_index[n];
89
90
285535
    quant_matrix = s->inter_matrix;
91
9502845
    for(i=0; i<=nCoeffs; i++) {
92
9217310
        int j= s->intra_scantable.permutated[i];
93
9217310
        level = block[j];
94
9217310
        if (level) {
95
2101549
            if (level < 0) {
96
1052132
                level = -level;
97
1052132
                level = (((level << 1) + 1) * qscale *
98
1052132
                         ((int) (quant_matrix[j]))) >> 4;
99
1052132
                level = (level - 1) | 1;
100
1052132
                level = -level;
101
            } else {
102
1049417
                level = (((level << 1) + 1) * qscale *
103
1049417
                         ((int) (quant_matrix[j]))) >> 4;
104
1049417
                level = (level - 1) | 1;
105
            }
106
2101549
            block[j] = level;
107
        }
108
    }
109
285535
}
110
111
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
112
                                   int16_t *block, int n, int qscale)
113
{
114
    int i, level, nCoeffs;
115
    const uint16_t *quant_matrix;
116
117
    if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
118
    else                 qscale <<= 1;
119
120
    if(s->alternate_scan) nCoeffs= 63;
121
    else nCoeffs= s->block_last_index[n];
122
123
    block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
124
    quant_matrix = s->intra_matrix;
125
    for(i=1;i<=nCoeffs;i++) {
126
        int j= s->intra_scantable.permutated[i];
127
        level = block[j];
128
        if (level) {
129
            if (level < 0) {
130
                level = -level;
131
                level = (int)(level * qscale * quant_matrix[j]) >> 4;
132
                level = -level;
133
            } else {
134
                level = (int)(level * qscale * quant_matrix[j]) >> 4;
135
            }
136
            block[j] = level;
137
        }
138
    }
139
}
140
141
1004864
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
142
                                   int16_t *block, int n, int qscale)
143
{
144
    int i, level, nCoeffs;
145
    const uint16_t *quant_matrix;
146
1004864
    int sum=-1;
147
148
1004864
    if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
149
1004864
    else                 qscale <<= 1;
150
151
1004864
    if(s->alternate_scan) nCoeffs= 63;
152
1004864
    else nCoeffs= s->block_last_index[n];
153
154
1004864
    block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
155
1004864
    sum += block[0];
156
1004864
    quant_matrix = s->intra_matrix;
157
19033337
    for(i=1;i<=nCoeffs;i++) {
158
18028473
        int j= s->intra_scantable.permutated[i];
159
18028473
        level = block[j];
160
18028473
        if (level) {
161
8890498
            if (level < 0) {
162
4472731
                level = -level;
163
4472731
                level = (int)(level * qscale * quant_matrix[j]) >> 4;
164
4472731
                level = -level;
165
            } else {
166
4417767
                level = (int)(level * qscale * quant_matrix[j]) >> 4;
167
            }
168
8890498
            block[j] = level;
169
8890498
            sum+=level;
170
        }
171
    }
172
1004864
    block[63]^=sum&1;
173
1004864
}
174
175
2577120
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
176
                                   int16_t *block, int n, int qscale)
177
{
178
    int i, level, nCoeffs;
179
    const uint16_t *quant_matrix;
180
2577120
    int sum=-1;
181
182
2577120
    if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
183
2577120
    else                 qscale <<= 1;
184
185
2577120
    if(s->alternate_scan) nCoeffs= 63;
186
2577120
    else nCoeffs= s->block_last_index[n];
187
188
2577120
    quant_matrix = s->inter_matrix;
189
65294556
    for(i=0; i<=nCoeffs; i++) {
190
62717436
        int j= s->intra_scantable.permutated[i];
191
62717436
        level = block[j];
192
62717436
        if (level) {
193
22179210
            if (level < 0) {
194
11115371
                level = -level;
195
11115371
                level = (((level << 1) + 1) * qscale *
196
11115371
                         ((int) (quant_matrix[j]))) >> 5;
197
11115371
                level = -level;
198
            } else {
199
11063839
                level = (((level << 1) + 1) * qscale *
200
11063839
                         ((int) (quant_matrix[j]))) >> 5;
201
            }
202
22179210
            block[j] = level;
203
22179210
            sum+=level;
204
        }
205
    }
206
2577120
    block[63]^=sum&1;
207
2577120
}
208
209
3363228
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
210
                                  int16_t *block, int n, int qscale)
211
{
212
    int i, level, qmul, qadd;
213
    int nCoeffs;
214
215
    av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
216
217
3363228
    qmul = qscale << 1;
218
219
3363228
    if (!s->h263_aic) {
220
3190032
        block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
221
3190032
        qadd = (qscale - 1) | 1;
222
    }else{
223
173196
        qadd = 0;
224
    }
225
3363228
    if(s->ac_pred)
226
68304
        nCoeffs=63;
227
    else
228
3294924
        nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
229
230
120195275
    for(i=1; i<=nCoeffs; i++) {
231
116832047
        level = block[i];
232
116832047
        if (level) {
233
35700964
            if (level < 0) {
234
17877171
                level = level * qmul - qadd;
235
            } else {
236
17823793
                level = level * qmul + qadd;
237
            }
238
35700964
            block[i] = level;
239
        }
240
    }
241
3363228
}
242
243
6014662
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
244
                                  int16_t *block, int n, int qscale)
245
{
246
    int i, level, qmul, qadd;
247
    int nCoeffs;
248
249
    av_assert2(s->block_last_index[n]>=0);
250
251
6014662
    qadd = (qscale - 1) | 1;
252
6014662
    qmul = qscale << 1;
253
254
6014662
    nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
255
256
235641304
    for(i=0; i<=nCoeffs; i++) {
257
229626642
        level = block[i];
258
229626642
        if (level) {
259
48213622
            if (level < 0) {
260
24027915
                level = level * qmul - qadd;
261
            } else {
262
24185707
                level = level * qmul + qadd;
263
            }
264
48213622
            block[i] = level;
265
        }
266
    }
267
6014662
}
268
269
270
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
271
{
272
    while(h--)
273
        memset(dst + h*linesize, 128, 16);
274
}
275
276
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
277
{
278
    while(h--)
279
        memset(dst + h*linesize, 128, 8);
280
}
281
282
/* init common dct for both encoder and decoder */
283
744
static av_cold int dct_init(MpegEncContext *s)
284
{
285
744
    ff_blockdsp_init(&s->bdsp, s->avctx);
286
744
    ff_h264chroma_init(&s->h264chroma, 8); //for lowres
287
744
    ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
288
744
    ff_mpegvideodsp_init(&s->mdsp);
289
744
    ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
290
291
744
    if (s->avctx->debug & FF_DEBUG_NOMC) {
292
        int i;
293
        for (i=0; i<4; i++) {
294
            s->hdsp.avg_pixels_tab[0][i] = gray16;
295
            s->hdsp.put_pixels_tab[0][i] = gray16;
296
            s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
297
298
            s->hdsp.avg_pixels_tab[1][i] = gray8;
299
            s->hdsp.put_pixels_tab[1][i] = gray8;
300
            s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
301
        }
302
    }
303
304
744
    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
305
744
    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
306
744
    s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
307
744
    s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
308
744
    s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
309
744
    if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
310
537
        s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
311
744
    s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
312
313
    if (HAVE_INTRINSICS_NEON)
314
        ff_mpv_common_init_neon(s);
315
316
    if (ARCH_ALPHA)
317
        ff_mpv_common_init_axp(s);
318
    if (ARCH_ARM)
319
        ff_mpv_common_init_arm(s);
320
    if (ARCH_PPC)
321
        ff_mpv_common_init_ppc(s);
322
    if (ARCH_X86)
323
744
        ff_mpv_common_init_x86(s);
324
    if (ARCH_MIPS)
325
        ff_mpv_common_init_mips(s);
326
327
744
    return 0;
328
}
329
330
1071
av_cold void ff_mpv_idct_init(MpegEncContext *s)
331
{
332
1071
    if (s->codec_id == AV_CODEC_ID_MPEG4)
333
219
        s->idsp.mpeg4_studio_profile = s->studio_profile;
334
1071
    ff_idctdsp_init(&s->idsp, s->avctx);
335
336
    /* load & permutate scantables
337
     * note: only wmv uses different ones
338
     */
339
1071
    if (s->alternate_scan) {
340
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
341
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
342
    } else {
343
1071
        ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
344
1071
        ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
345
    }
346
1071
    ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
347
1071
    ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
348
1071
}
349
350
10832
static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
351
{
352
21664
    return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 0,
353
10832
                            s->chroma_x_shift, s->chroma_y_shift, s->out_format,
354
                            s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
355
                            &s->linesize, &s->uvlinesize);
356
}
357
358
818
static int init_duplicate_context(MpegEncContext *s)
359
{
360
818
    int y_size = s->b8_stride * (2 * s->mb_height + 1);
361
818
    int c_size = s->mb_stride * (s->mb_height + 1);
362
818
    int yc_size = y_size + 2 * c_size;
363
    int i;
364
365
818
    if (s->mb_height & 1)
366
144
        yc_size += 2*s->b8_stride + 2*s->mb_stride;
367
368
818
    s->sc.edge_emu_buffer =
369
818
    s->me.scratchpad   =
370
818
    s->me.temp         =
371
818
    s->sc.rd_scratchpad   =
372
818
    s->sc.b_scratchpad    =
373
818
    s->sc.obmc_scratchpad = NULL;
374
375
818
    if (s->encoding) {
376
194
        FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
377
                          ME_MAP_SIZE * sizeof(uint32_t), fail)
378
194
        FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
379
                          ME_MAP_SIZE * sizeof(uint32_t), fail)
380
194
        if (s->noise_reduction) {
381
4
            FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
382
                              2 * 64 * sizeof(int), fail)
383
        }
384
    }
385
818
    FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
386
818
    s->block = s->blocks[0];
387
388
10634
    for (i = 0; i < 12; i++) {
389
9816
        s->pblocks[i] = &s->block[i];
390
    }
391
392
818
    FF_ALLOCZ_OR_GOTO(s->avctx, s->block32, sizeof(*s->block32), fail)
393
818
    s->dpcm_direction = 0;
394
818
    FF_ALLOCZ_OR_GOTO(s->avctx, s->dpcm_macroblock, sizeof(*s->dpcm_macroblock), fail)
395
396
818
    if (s->avctx->codec_tag == AV_RL32("VCR2")) {
397
        // exchange uv
398
4
        FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
399
    }
400
401
818
    if (s->out_format == FMT_H263) {
402
        /* ac values */
403

451
        FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
404
                          yc_size * sizeof(int16_t) * 16, fail);
405
451
        s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
406
451
        s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
407
451
        s->ac_val[2] = s->ac_val[1] + c_size;
408
    }
409
410
818
    return 0;
411
fail:
412
    return -1; // free() through ff_mpv_common_end()
413
}
414
415
837
static void free_duplicate_context(MpegEncContext *s)
416
{
417
837
    if (!s)
418
        return;
419
420
837
    av_freep(&s->sc.edge_emu_buffer);
421
837
    av_freep(&s->me.scratchpad);
422
837
    s->me.temp =
423
837
    s->sc.rd_scratchpad =
424
837
    s->sc.b_scratchpad =
425
837
    s->sc.obmc_scratchpad = NULL;
426
427
837
    av_freep(&s->dct_error_sum);
428
837
    av_freep(&s->me.map);
429
837
    av_freep(&s->me.score_map);
430
837
    av_freep(&s->blocks);
431
837
    av_freep(&s->block32);
432
837
    av_freep(&s->dpcm_macroblock);
433
837
    av_freep(&s->ac_val_base);
434
837
    s->block = NULL;
435
}
436
437
8752
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
438
{
439
#define COPY(a) bak->a = src->a
440
8752
    COPY(sc.edge_emu_buffer);
441
8752
    COPY(me.scratchpad);
442
8752
    COPY(me.temp);
443
8752
    COPY(sc.rd_scratchpad);
444
8752
    COPY(sc.b_scratchpad);
445
8752
    COPY(sc.obmc_scratchpad);
446
8752
    COPY(me.map);
447
8752
    COPY(me.score_map);
448
8752
    COPY(blocks);
449
8752
    COPY(block);
450
8752
    COPY(block32);
451
8752
    COPY(dpcm_macroblock);
452
8752
    COPY(dpcm_direction);
453
8752
    COPY(start_mb_y);
454
8752
    COPY(end_mb_y);
455
8752
    COPY(me.map_generation);
456
8752
    COPY(pb);
457
8752
    COPY(dct_error_sum);
458
8752
    COPY(dct_count[0]);
459
8752
    COPY(dct_count[1]);
460
8752
    COPY(ac_val_base);
461
8752
    COPY(ac_val[0]);
462
8752
    COPY(ac_val[1]);
463
8752
    COPY(ac_val[2]);
464
#undef COPY
465
8752
}
466
467
4376
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
468
{
469
    MpegEncContext bak;
470
    int i, ret;
471
    // FIXME copy only needed parts
472
    // START_TIMER
473
4376
    backup_duplicate_context(&bak, dst);
474
4376
    memcpy(dst, src, sizeof(MpegEncContext));
475
4376
    backup_duplicate_context(dst, &bak);
476
56888
    for (i = 0; i < 12; i++) {
477
52512
        dst->pblocks[i] = &dst->block[i];
478
    }
479
4376
    if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
480
        // exchange uv
481
        FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
482
    }
483

4412
    if (!dst->sc.edge_emu_buffer &&
484
36
        (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
485
36
                                       &dst->sc, dst->linesize)) < 0) {
486
        av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
487
               "scratch buffers.\n");
488
        return ret;
489
    }
490
    // STOP_TIMER("update_duplicate_context")
491
    // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
492
4376
    return 0;
493
}
494
495
int ff_mpeg_update_thread_context(AVCodecContext *dst,
496
                                  const AVCodecContext *src)
497
{
498
    int i, ret;
499
    MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
500
501
    if (dst == src)
502
        return 0;
503
504
    av_assert0(s != s1);
505
506
    // FIXME can parameters change on I-frames?
507
    // in that case dst may need a reinit
508
    if (!s->context_initialized) {
509
        int err;
510
        memcpy(s, s1, sizeof(MpegEncContext));
511
512
        s->avctx                 = dst;
513
        s->bitstream_buffer      = NULL;
514
        s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
515
516
        if (s1->context_initialized){
517
//             s->picture_range_start  += MAX_PICTURE_COUNT;
518
//             s->picture_range_end    += MAX_PICTURE_COUNT;
519
            ff_mpv_idct_init(s);
520
            if((err = ff_mpv_common_init(s)) < 0){
521
                memset(s, 0, sizeof(MpegEncContext));
522
                s->avctx = dst;
523
                return err;
524
            }
525
        }
526
    }
527
528
    if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
529
        s->context_reinit = 0;
530
        s->height = s1->height;
531
        s->width  = s1->width;
532
        if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
533
            return ret;
534
    }
535
536
    s->avctx->coded_height  = s1->avctx->coded_height;
537
    s->avctx->coded_width   = s1->avctx->coded_width;
538
    s->avctx->width         = s1->avctx->width;
539
    s->avctx->height        = s1->avctx->height;
540
541
    s->quarter_sample       = s1->quarter_sample;
542
543
    s->coded_picture_number = s1->coded_picture_number;
544
    s->picture_number       = s1->picture_number;
545
546
    av_assert0(!s->picture || s->picture != s1->picture);
547
    if(s->picture)
548
    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
549
        ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
550
        if (s1->picture && s1->picture[i].f->buf[0] &&
551
            (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
552
            return ret;
553
    }
554
555
#define UPDATE_PICTURE(pic)\
556
do {\
557
    ff_mpeg_unref_picture(s->avctx, &s->pic);\
558
    if (s1->pic.f && s1->pic.f->buf[0])\
559
        ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
560
    else\
561
        ret = ff_update_picture_tables(&s->pic, &s1->pic);\
562
    if (ret < 0)\
563
        return ret;\
564
} while (0)
565
566
    UPDATE_PICTURE(current_picture);
567
    UPDATE_PICTURE(last_picture);
568
    UPDATE_PICTURE(next_picture);
569
570
#define REBASE_PICTURE(pic, new_ctx, old_ctx)                                 \
571
    ((pic && pic >= old_ctx->picture &&                                       \
572
      pic < old_ctx->picture + MAX_PICTURE_COUNT) ?                           \
573
        &new_ctx->picture[pic - old_ctx->picture] : NULL)
574
575
    s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
576
    s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
577
    s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
578
579
    // Error/bug resilience
580
    s->next_p_frame_damaged = s1->next_p_frame_damaged;
581
    s->workaround_bugs      = s1->workaround_bugs;
582
    s->padding_bug_score    = s1->padding_bug_score;
583
584
    // MPEG-4 timing info
585
    memcpy(&s->last_time_base, &s1->last_time_base,
586
           (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
587
           (char *) &s1->last_time_base);
588
589
    // B-frame info
590
    s->max_b_frames = s1->max_b_frames;
591
    s->low_delay    = s1->low_delay;
592
    s->droppable    = s1->droppable;
593
594
    // DivX handling (doesn't work)
595
    s->divx_packed  = s1->divx_packed;
596
597
    if (s1->bitstream_buffer) {
598
        if (s1->bitstream_buffer_size +
599
            AV_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
600
            av_fast_malloc(&s->bitstream_buffer,
601
                           &s->allocated_bitstream_buffer_size,
602
                           s1->allocated_bitstream_buffer_size);
603
            if (!s->bitstream_buffer) {
604
                s->bitstream_buffer_size = 0;
605
                return AVERROR(ENOMEM);
606
            }
607
        }
608
        s->bitstream_buffer_size = s1->bitstream_buffer_size;
609
        memcpy(s->bitstream_buffer, s1->bitstream_buffer,
610
               s1->bitstream_buffer_size);
611
        memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
612
               AV_INPUT_BUFFER_PADDING_SIZE);
613
    }
614
615
    // linesize-dependent scratch buffer allocation
616
    if (!s->sc.edge_emu_buffer)
617
        if (s1->linesize) {
618
            if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
619
                                        &s->sc, s1->linesize) < 0) {
620
                av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
621
                       "scratch buffers.\n");
622
                return AVERROR(ENOMEM);
623
            }
624
        } else {
625
            av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
626
                   "be allocated due to unknown size.\n");
627
        }
628
629
    // MPEG-2/interlacing info
630
    memcpy(&s->progressive_sequence, &s1->progressive_sequence,
631
           (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
632
633
    if (!s1->first_field) {
634
        s->last_pict_type = s1->pict_type;
635
        if (s1->current_picture_ptr)
636
            s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
637
    }
638
639
    return 0;
640
}
641
642
/**
643
 * Set the given MpegEncContext to common defaults
644
 * (same for encoding and decoding).
645
 * The changed fields will not depend upon the
646
 * prior state of the MpegEncContext.
647
 */
648
760
void ff_mpv_common_defaults(MpegEncContext *s)
649
{
650
760
    s->y_dc_scale_table      =
651
760
    s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
652
760
    s->chroma_qscale_table   = ff_default_chroma_qscale_table;
653
760
    s->progressive_frame     = 1;
654
760
    s->progressive_sequence  = 1;
655
760
    s->picture_structure     = PICT_FRAME;
656
657
760
    s->coded_picture_number  = 0;
658
760
    s->picture_number        = 0;
659
660
760
    s->f_code                = 1;
661
760
    s->b_code                = 1;
662
663
760
    s->slice_context_count   = 1;
664
760
}
665
666
/**
667
 * Set the given MpegEncContext to defaults for decoding.
668
 * the changed fields will not depend upon
669
 * the prior state of the MpegEncContext.
670
 */
671
578
void ff_mpv_decode_defaults(MpegEncContext *s)
672
{
673
578
    ff_mpv_common_defaults(s);
674
578
}
675
676
578
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
677
{
678
578
    s->avctx           = avctx;
679
578
    s->width           = avctx->coded_width;
680
578
    s->height          = avctx->coded_height;
681
578
    s->codec_id        = avctx->codec->id;
682
578
    s->workaround_bugs = avctx->workaround_bugs;
683
684
    /* convert fourcc to upper case */
685
578
    s->codec_tag          = avpriv_toupper4(avctx->codec_tag);
686
578
}
687
688
/**
689
 * Initialize and allocates MpegEncContext fields dependent on the resolution.
690
 */
691
782
static int init_context_frame(MpegEncContext *s)
692
{
693
    int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
694
695
782
    s->mb_width   = (s->width + 15) / 16;
696
782
    s->mb_stride  = s->mb_width + 1;
697
782
    s->b8_stride  = s->mb_width * 2 + 1;
698
782
    mb_array_size = s->mb_height * s->mb_stride;
699
782
    mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
700
701
    /* set default edge pos, will be overridden
702
     * in decode_header if needed */
703
782
    s->h_edge_pos = s->mb_width * 16;
704
782
    s->v_edge_pos = s->mb_height * 16;
705
706
782
    s->mb_num     = s->mb_width * s->mb_height;
707
708
782
    s->block_wrap[0] =
709
782
    s->block_wrap[1] =
710
782
    s->block_wrap[2] =
711
782
    s->block_wrap[3] = s->b8_stride;
712
782
    s->block_wrap[4] =
713
782
    s->block_wrap[5] = s->mb_stride;
714
715
782
    y_size  = s->b8_stride * (2 * s->mb_height + 1);
716
782
    c_size  = s->mb_stride * (s->mb_height + 1);
717
782
    yc_size = y_size + 2   * c_size;
718
719
782
    if (s->mb_height & 1)
720
143
        yc_size += 2*s->b8_stride + 2*s->mb_stride;
721
722

782
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
723
                      fail); // error resilience code looks cleaner with this
724
15183
    for (y = 0; y < s->mb_height; y++)
725
447168
        for (x = 0; x < s->mb_width; x++)
726
432767
            s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
727
728
782
    s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
729
730
782
    if (s->encoding) {
731
        /* Allocate MV tables */
732

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
733

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
734

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
735

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
736

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
737

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
738
182
        s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
739
182
        s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
740
182
        s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
741
182
        s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
742
182
        s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
743
182
        s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
744
745
        /* Allocate MB type table */
746

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
747
748

182
        FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
749
750

182
        FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
751
                         mb_array_size * sizeof(float), fail);
752

182
        FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
753
                         mb_array_size * sizeof(float), fail);
754
755
    }
756
757
782
    if (s->codec_id == AV_CODEC_ID_MPEG4 ||
758
540
        (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
759
        /* interlaced direct mode decoding tables */
760
774
        for (i = 0; i < 2; i++) {
761
            int j, k;
762
1548
            for (j = 0; j < 2; j++) {
763
3096
                for (k = 0; k < 2; k++) {
764

2064
                    FF_ALLOCZ_OR_GOTO(s->avctx,
765
                                      s->b_field_mv_table_base[i][j][k],
766
                                      mv_table_size * 2 * sizeof(int16_t),
767
                                      fail);
768
2064
                    s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
769
2064
                                                   s->mb_stride + 1;
770
                }
771

1032
                FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
772

1032
                FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
773
1032
                s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
774
            }
775

516
            FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
776
        }
777
    }
778
782
    if (s->out_format == FMT_H263) {
779
        /* cbp values */
780

447
        FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
781
447
        s->coded_block = s->coded_block_base + s->b8_stride + 1;
782
783
        /* cbp, ac_pred, pred_dir */
784

447
        FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
785

447
        FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
786
    }
787
788

782
    if (s->h263_pred || s->h263_plus || !s->encoding) {
789
        /* dc values */
790
        // MN: we need these for error resilience of intra-frames
791

681
        FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
792
681
        s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
793
681
        s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
794
681
        s->dc_val[2] = s->dc_val[1] + c_size;
795
2500308
        for (i = 0; i < yc_size; i++)
796
2499627
            s->dc_val_base[i] = 1024;
797
    }
798
799
    /* which mb is an intra block */
800

782
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
801
782
    memset(s->mbintra_table, 1, mb_array_size);
802
803
    /* init macroblock skip table */
804

782
    FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
805
    // Note the + 1 is for a quicker MPEG-4 slice_end detection
806
807
782
    return ff_mpeg_er_init(s);
808
fail:
809
    return AVERROR(ENOMEM);
810
}
811
812
744
static void clear_context(MpegEncContext *s)
813
{
814
    int i, j, k;
815
816
744
    memset(&s->next_picture, 0, sizeof(s->next_picture));
817
744
    memset(&s->last_picture, 0, sizeof(s->last_picture));
818
744
    memset(&s->current_picture, 0, sizeof(s->current_picture));
819
744
    memset(&s->new_picture, 0, sizeof(s->new_picture));
820
821
744
    memset(s->thread_context, 0, sizeof(s->thread_context));
822
823
744
    s->me.map = NULL;
824
744
    s->me.score_map = NULL;
825
744
    s->dct_error_sum = NULL;
826
744
    s->block = NULL;
827
744
    s->blocks = NULL;
828
744
    s->block32 = NULL;
829
744
    memset(s->pblocks, 0, sizeof(s->pblocks));
830
744
    s->dpcm_direction = 0;
831
744
    s->dpcm_macroblock = NULL;
832
744
    s->ac_val_base = NULL;
833
744
    s->ac_val[0] =
834
744
    s->ac_val[1] =
835
744
    s->ac_val[2] =NULL;
836
744
    s->sc.edge_emu_buffer = NULL;
837
744
    s->me.scratchpad = NULL;
838
744
    s->me.temp =
839
744
    s->sc.rd_scratchpad =
840
744
    s->sc.b_scratchpad =
841
744
    s->sc.obmc_scratchpad = NULL;
842
843
844
744
    s->bitstream_buffer = NULL;
845
744
    s->allocated_bitstream_buffer_size = 0;
846
744
    s->picture          = NULL;
847
744
    s->mb_type          = NULL;
848
744
    s->p_mv_table_base  = NULL;
849
744
    s->b_forw_mv_table_base = NULL;
850
744
    s->b_back_mv_table_base = NULL;
851
744
    s->b_bidir_forw_mv_table_base = NULL;
852
744
    s->b_bidir_back_mv_table_base = NULL;
853
744
    s->b_direct_mv_table_base = NULL;
854
744
    s->p_mv_table            = NULL;
855
744
    s->b_forw_mv_table       = NULL;
856
744
    s->b_back_mv_table       = NULL;
857
744
    s->b_bidir_forw_mv_table = NULL;
858
744
    s->b_bidir_back_mv_table = NULL;
859
744
    s->b_direct_mv_table     = NULL;
860
2232
    for (i = 0; i < 2; i++) {
861
4464
        for (j = 0; j < 2; j++) {
862
8928
            for (k = 0; k < 2; k++) {
863
5952
                s->b_field_mv_table_base[i][j][k] = NULL;
864
5952
                s->b_field_mv_table[i][j][k] = NULL;
865
            }
866
2976
            s->b_field_select_table[i][j] = NULL;
867
2976
            s->p_field_mv_table_base[i][j] = NULL;
868
2976
            s->p_field_mv_table[i][j] = NULL;
869
        }
870
1488
        s->p_field_select_table[i] = NULL;
871
    }
872
873
744
    s->dc_val_base = NULL;
874
744
    s->coded_block_base = NULL;
875
744
    s->mbintra_table = NULL;
876
744
    s->cbp_table = NULL;
877
744
    s->pred_dir_table = NULL;
878
879
744
    s->mbskip_table = NULL;
880
881
744
    s->er.error_status_table = NULL;
882
744
    s->er.er_temp_buffer = NULL;
883
744
    s->mb_index2xy = NULL;
884
744
    s->lambda_table = NULL;
885
886
744
    s->cplx_tab = NULL;
887
744
    s->bits_tab = NULL;
888
744
}
889
890
/**
891
 * init common structure for both encoder and decoder.
892
 * this assumes that some variables like width/height are already set
893
 */
894
744
av_cold int ff_mpv_common_init(MpegEncContext *s)
895
{
896
    int i, ret;
897
744
    int nb_slices = (HAVE_THREADS &&
898
744
                     s->avctx->active_thread_type & FF_THREAD_SLICE) ?
899
744
                    s->avctx->thread_count : 1;
900
901
744
    clear_context(s);
902
903

744
    if (s->encoding && s->avctx->slices)
904
12
        nb_slices = s->avctx->slices;
905
906

744
    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
907
129
        s->mb_height = (s->height + 31) / 32 * 2;
908
    else
909
615
        s->mb_height = (s->height + 15) / 16;
910
911
744
    if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
912
        av_log(s->avctx, AV_LOG_ERROR,
913
               "decoding to AV_PIX_FMT_NONE is not supported.\n");
914
        return -1;
915
    }
916
917

744
    if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
918
        int max_slices;
919
        if (s->mb_height)
920
            max_slices = FFMIN(MAX_THREADS, s->mb_height);
921
        else
922
            max_slices = MAX_THREADS;
923
        av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
924
               " reducing to %d\n", nb_slices, max_slices);
925
        nb_slices = max_slices;
926
    }
927
928

1473
    if ((s->width || s->height) &&
929
729
        av_image_check_size(s->width, s->height, 0, s->avctx))
930
        return -1;
931
932
744
    dct_init(s);
933
934
    /* set chroma shifts */
935
744
    ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
936
                                           &s->chroma_x_shift,
937
                                           &s->chroma_y_shift);
938
744
    if (ret)
939
        return ret;
940
941
744
    FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
942
                      MAX_PICTURE_COUNT * sizeof(Picture), fail);
943
27528
    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
944
26784
        s->picture[i].f = av_frame_alloc();
945
26784
        if (!s->picture[i].f)
946
            goto fail;
947
    }
948
744
    s->next_picture.f = av_frame_alloc();
949
744
    if (!s->next_picture.f)
950
        goto fail;
951
744
    s->last_picture.f = av_frame_alloc();
952
744
    if (!s->last_picture.f)
953
        goto fail;
954
744
    s->current_picture.f = av_frame_alloc();
955
744
    if (!s->current_picture.f)
956
        goto fail;
957
744
    s->new_picture.f = av_frame_alloc();
958
744
    if (!s->new_picture.f)
959
        goto fail;
960
961
744
    if (init_context_frame(s))
962
        goto fail;
963
964
744
    s->parse_context.state = -1;
965
966
744
    s->context_initialized = 1;
967
744
    memset(s->thread_context, 0, sizeof(s->thread_context));
968
744
    s->thread_context[0]   = s;
969
970
//     if (s->width && s->height) {
971
744
    if (nb_slices > 1) {
972
66
        for (i = 0; i < nb_slices; i++) {
973
51
            if (i) {
974
36
                s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
975
36
                if (!s->thread_context[i])
976
                    goto fail;
977
            }
978
51
            if (init_duplicate_context(s->thread_context[i]) < 0)
979
                goto fail;
980
51
            s->thread_context[i]->start_mb_y =
981
51
                (s->mb_height * (i) + nb_slices / 2) / nb_slices;
982
51
            s->thread_context[i]->end_mb_y   =
983
51
                (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
984
        }
985
    } else {
986
729
        if (init_duplicate_context(s) < 0)
987
            goto fail;
988
729
        s->start_mb_y = 0;
989
729
        s->end_mb_y   = s->mb_height;
990
    }
991
744
    s->slice_context_count = nb_slices;
992
//     }
993
994
744
    return 0;
995
 fail:
996
    ff_mpv_common_end(s);
997
    return -1;
998
}
999
1000
/**
1001
 * Frees and resets MpegEncContext fields depending on the resolution.
1002
 * Is used during resolution changes to avoid a full reinitialization of the
1003
 * codec.
1004
 */
1005
801
static void free_context_frame(MpegEncContext *s)
1006
{
1007
    int i, j, k;
1008
1009
801
    av_freep(&s->mb_type);
1010
801
    av_freep(&s->p_mv_table_base);
1011
801
    av_freep(&s->b_forw_mv_table_base);
1012
801
    av_freep(&s->b_back_mv_table_base);
1013
801
    av_freep(&s->b_bidir_forw_mv_table_base);
1014
801
    av_freep(&s->b_bidir_back_mv_table_base);
1015
801
    av_freep(&s->b_direct_mv_table_base);
1016
801
    s->p_mv_table            = NULL;
1017
801
    s->b_forw_mv_table       = NULL;
1018
801
    s->b_back_mv_table       = NULL;
1019
801
    s->b_bidir_forw_mv_table = NULL;
1020
801
    s->b_bidir_back_mv_table = NULL;
1021
801
    s->b_direct_mv_table     = NULL;
1022
2403
    for (i = 0; i < 2; i++) {
1023
4806
        for (j = 0; j < 2; j++) {
1024
9612
            for (k = 0; k < 2; k++) {
1025
6408
                av_freep(&s->b_field_mv_table_base[i][j][k]);
1026
6408
                s->b_field_mv_table[i][j][k] = NULL;
1027
            }
1028
3204
            av_freep(&s->b_field_select_table[i][j]);
1029
3204
            av_freep(&s->p_field_mv_table_base[i][j]);
1030
3204
            s->p_field_mv_table[i][j] = NULL;
1031
        }
1032
1602
        av_freep(&s->p_field_select_table[i]);
1033
    }
1034
1035
801
    av_freep(&s->dc_val_base);
1036
801
    av_freep(&s->coded_block_base);
1037
801
    av_freep(&s->mbintra_table);
1038
801
    av_freep(&s->cbp_table);
1039
801
    av_freep(&s->pred_dir_table);
1040
1041
801
    av_freep(&s->mbskip_table);
1042
1043
801
    av_freep(&s->er.error_status_table);
1044
801
    av_freep(&s->er.er_temp_buffer);
1045
801
    av_freep(&s->mb_index2xy);
1046
801
    av_freep(&s->lambda_table);
1047
1048
801
    av_freep(&s->cplx_tab);
1049
801
    av_freep(&s->bits_tab);
1050
1051
801
    s->linesize = s->uvlinesize = 0;
1052
801
}
1053
1054
38
int ff_mpv_common_frame_size_change(MpegEncContext *s)
1055
{
1056
38
    int i, err = 0;
1057
1058
38
    if (!s->context_initialized)
1059
        return AVERROR(EINVAL);
1060
1061
38
    if (s->slice_context_count > 1) {
1062
        for (i = 0; i < s->slice_context_count; i++) {
1063
            free_duplicate_context(s->thread_context[i]);
1064
        }
1065
        for (i = 1; i < s->slice_context_count; i++) {
1066
            av_freep(&s->thread_context[i]);
1067
        }
1068
    } else
1069
38
        free_duplicate_context(s);
1070
1071
38
    free_context_frame(s);
1072
1073
38
    if (s->picture)
1074
1406
        for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1075
1368
                s->picture[i].needs_realloc = 1;
1076
        }
1077
1078
38
    s->last_picture_ptr         =
1079
38
    s->next_picture_ptr         =
1080
38
    s->current_picture_ptr      = NULL;
1081
1082
    // init
1083

38
    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1084
        s->mb_height = (s->height + 31) / 32 * 2;
1085
    else
1086
38
        s->mb_height = (s->height + 15) / 16;
1087
1088

76
    if ((s->width || s->height) &&
1089
38
        (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1090
        goto fail;
1091
1092
38
    if ((err = init_context_frame(s)))
1093
        goto fail;
1094
1095
38
    memset(s->thread_context, 0, sizeof(s->thread_context));
1096
38
    s->thread_context[0]   = s;
1097
1098

38
    if (s->width && s->height) {
1099
38
        int nb_slices = s->slice_context_count;
1100
38
        if (nb_slices > 1) {
1101
            for (i = 0; i < nb_slices; i++) {
1102
                if (i) {
1103
                    s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
1104
                    if (!s->thread_context[i]) {
1105
                        err = AVERROR(ENOMEM);
1106
                        goto fail;
1107
                    }
1108
                }
1109
                if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1110
                    goto fail;
1111
                s->thread_context[i]->start_mb_y =
1112
                    (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1113
                s->thread_context[i]->end_mb_y   =
1114
                    (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1115
            }
1116
        } else {
1117
38
            err = init_duplicate_context(s);
1118
38
            if (err < 0)
1119
                goto fail;
1120
38
            s->start_mb_y = 0;
1121
38
            s->end_mb_y   = s->mb_height;
1122
        }
1123
38
        s->slice_context_count = nb_slices;
1124
    }
1125
1126
38
    return 0;
1127
 fail:
1128
    ff_mpv_common_end(s);
1129
    return err;
1130
}
1131
1132
/* init common structure for both encoder and decoder */
1133
763
void ff_mpv_common_end(MpegEncContext *s)
1134
{
1135
    int i;
1136
1137
763
    if (!s)
1138
        return ;
1139
1140
763
    if (s->slice_context_count > 1) {
1141
66
        for (i = 0; i < s->slice_context_count; i++) {
1142
51
            free_duplicate_context(s->thread_context[i]);
1143
        }
1144
51
        for (i = 1; i < s->slice_context_count; i++) {
1145
36
            av_freep(&s->thread_context[i]);
1146
        }
1147
15
        s->slice_context_count = 1;
1148
748
    } else free_duplicate_context(s);
1149
1150
763
    av_freep(&s->parse_context.buffer);
1151
763
    s->parse_context.buffer_size = 0;
1152
1153
763
    av_freep(&s->bitstream_buffer);
1154
763
    s->allocated_bitstream_buffer_size = 0;
1155
1156
763
    if (s->picture) {
1157
27528
        for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1158
26784
            ff_free_picture_tables(&s->picture[i]);
1159
26784
            ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1160
26784
            av_frame_free(&s->picture[i].f);
1161
        }
1162
    }
1163
763
    av_freep(&s->picture);
1164
763
    ff_free_picture_tables(&s->last_picture);
1165
763
    ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1166
763
    av_frame_free(&s->last_picture.f);
1167
763
    ff_free_picture_tables(&s->current_picture);
1168
763
    ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1169
763
    av_frame_free(&s->current_picture.f);
1170
763
    ff_free_picture_tables(&s->next_picture);
1171
763
    ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1172
763
    av_frame_free(&s->next_picture.f);
1173
763
    ff_free_picture_tables(&s->new_picture);
1174
763
    ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1175
763
    av_frame_free(&s->new_picture.f);
1176
1177
763
    free_context_frame(s);
1178
1179
763
    s->context_initialized      = 0;
1180
763
    s->last_picture_ptr         =
1181
763
    s->next_picture_ptr         =
1182
763
    s->current_picture_ptr      = NULL;
1183
763
    s->linesize = s->uvlinesize = 0;
1184
}
1185
1186
1187
static void gray_frame(AVFrame *frame)
1188
{
1189
    int i, h_chroma_shift, v_chroma_shift;
1190
1191
    av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1192
1193
    for(i=0; i<frame->height; i++)
1194
        memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1195
    for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1196
        memset(frame->data[1] + frame->linesize[1]*i,
1197
               0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1198
        memset(frame->data[2] + frame->linesize[2]*i,
1199
               0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1200
    }
1201
}
1202
1203
/**
1204
 * generic function called after decoding
1205
 * the header and before a frame is decoded.
1206
 */
1207
10826
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1208
{
1209
    int i, ret;
1210
    Picture *pic;
1211
10826
    s->mb_skipped = 0;
1212
1213
10826
    if (!ff_thread_can_start_frame(avctx)) {
1214
        av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1215
        return -1;
1216
    }
1217
1218
    /* mark & release old frames */
1219

10826
    if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1220
7861
        s->last_picture_ptr != s->next_picture_ptr &&
1221
7861
        s->last_picture_ptr->f->buf[0]) {
1222
7861
        ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1223
    }
1224
1225
    /* release forgotten pictures */
1226
    /* if (MPEG-124 / H.263) */
1227
400562
    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1228
389736
        if (&s->picture[i] != s->last_picture_ptr &&
1229
379406
            &s->picture[i] != s->next_picture_ptr &&
1230

368873
            s->picture[i].reference && !s->picture[i].needs_realloc) {
1231
            ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1232
        }
1233
    }
1234
1235
10826
    ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1236
10826
    ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1237
10826
    ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1238
1239
    /* release non reference frames */
1240
400562
    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1241
389736
        if (!s->picture[i].reference)
1242
376714
            ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1243
    }
1244
1245

10826
    if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1246
        // we already have an unused image
1247
        // (maybe it was set before reading the header)
1248
5977
        pic = s->current_picture_ptr;
1249
    } else {
1250
4849
        i   = ff_find_unused_picture(s->avctx, s->picture, 0);
1251
4849
        if (i < 0) {
1252
            av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1253
            return i;
1254
        }
1255
4849
        pic = &s->picture[i];
1256
    }
1257
1258
10826
    pic->reference = 0;
1259
10826
    if (!s->droppable) {
1260
10826
        if (s->pict_type != AV_PICTURE_TYPE_B)
1261
8357
            pic->reference = 3;
1262
    }
1263
1264
10826
    pic->f->coded_picture_number = s->coded_picture_number++;
1265
1266
10826
    if (alloc_picture(s, pic, 0) < 0)
1267
        return -1;
1268
1269
10826
    s->current_picture_ptr = pic;
1270
    // FIXME use only the vars from current_pic
1271
10826
    s->current_picture_ptr->f->top_field_first = s->top_field_first;
1272
10826
    if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1273
10346
        s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1274
3487
        if (s->picture_structure != PICT_FRAME)
1275
602
            s->current_picture_ptr->f->top_field_first =
1276
602
                (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1277
    }
1278
12728
    s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1279
1902
                                                 !s->progressive_sequence;
1280
10826
    s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1281
1282
10826
    s->current_picture_ptr->f->pict_type = s->pict_type;
1283
    // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1284
    //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1285
10826
    s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1286
1287
10826
    if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1288
                                   s->current_picture_ptr)) < 0)
1289
        return ret;
1290
1291
10826
    if (s->pict_type != AV_PICTURE_TYPE_B) {
1292
8357
        s->last_picture_ptr = s->next_picture_ptr;
1293
8357
        if (!s->droppable)
1294
8357
            s->next_picture_ptr = s->current_picture_ptr;
1295
    }
1296
    ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1297
            s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1298
            s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1299
            s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1300
            s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1301
            s->pict_type, s->droppable);
1302
1303

10826
    if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1304
293
        (s->pict_type != AV_PICTURE_TYPE_I)) {
1305
        int h_chroma_shift, v_chroma_shift;
1306
6
        av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1307
                                         &h_chroma_shift, &v_chroma_shift);
1308

6
        if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1309
            av_log(avctx, AV_LOG_DEBUG,
1310
                   "allocating dummy last picture for B frame\n");
1311
6
        else if (s->pict_type != AV_PICTURE_TYPE_I)
1312
6
            av_log(avctx, AV_LOG_ERROR,
1313
                   "warning: first frame is no keyframe\n");
1314
1315
        /* Allocate a dummy frame */
1316
6
        i = ff_find_unused_picture(s->avctx, s->picture, 0);
1317
6
        if (i < 0) {
1318
            av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1319
            return i;
1320
        }
1321
6
        s->last_picture_ptr = &s->picture[i];
1322
1323
6
        s->last_picture_ptr->reference   = 3;
1324
6
        s->last_picture_ptr->f->key_frame = 0;
1325
6
        s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1326
1327
6
        if (alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1328
            s->last_picture_ptr = NULL;
1329
            return -1;
1330
        }
1331
1332
6
        if (!avctx->hwaccel) {
1333
1734
            for(i=0; i<avctx->height; i++)
1334
1728
                memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1335
1728
                       0x80, avctx->width);
1336
6
            if (s->last_picture_ptr->f->data[2]) {
1337
870
                for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1338
864
                    memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1339
864
                        0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1340
864
                    memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1341
864
                        0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1342
                }
1343
            }
1344
1345

6
            if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1346
                for(i=0; i<avctx->height; i++)
1347
                memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1348
            }
1349
        }
1350
1351
6
        ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1352
6
        ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1353
    }
1354

10826
    if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1355
        s->pict_type == AV_PICTURE_TYPE_B) {
1356
        /* Allocate a dummy frame */
1357
        i = ff_find_unused_picture(s->avctx, s->picture, 0);
1358
        if (i < 0) {
1359
            av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1360
            return i;
1361
        }
1362
        s->next_picture_ptr = &s->picture[i];
1363
1364
        s->next_picture_ptr->reference   = 3;
1365
        s->next_picture_ptr->f->key_frame = 0;
1366
        s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1367
1368
        if (alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1369
            s->next_picture_ptr = NULL;
1370
            return -1;
1371
        }
1372
        ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1373
        ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1374
    }
1375
1376
#if 0 // BUFREF-FIXME
1377
    memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1378
    memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1379
#endif
1380
10826
    if (s->last_picture_ptr) {
1381

21078
        if (s->last_picture_ptr->f->buf[0] &&
1382
10539
            (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1383
                                       s->last_picture_ptr)) < 0)
1384
            return ret;
1385
    }
1386
10826
    if (s->next_picture_ptr) {
1387

21652
        if (s->next_picture_ptr->f->buf[0] &&
1388
10826
            (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1389
                                       s->next_picture_ptr)) < 0)
1390
            return ret;
1391
    }
1392
1393

10826
    av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1394
                                                 s->last_picture_ptr->f->buf[0]));
1395
1396
10826
    if (s->picture_structure!= PICT_FRAME) {
1397
        int i;
1398
3010
        for (i = 0; i < 4; i++) {
1399
2408
            if (s->picture_structure == PICT_BOTTOM_FIELD) {
1400
2404
                s->current_picture.f->data[i] +=
1401
2404
                    s->current_picture.f->linesize[i];
1402
            }
1403
2408
            s->current_picture.f->linesize[i] *= 2;
1404
2408
            s->last_picture.f->linesize[i]    *= 2;
1405
2408
            s->next_picture.f->linesize[i]    *= 2;
1406
        }
1407
    }
1408
1409
    /* set dequantizer, we can't do it during init as
1410
     * it might change for MPEG-4 and we can't do it in the header
1411
     * decode as init is not called for MPEG-4 there yet */
1412

10826
    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1413
3047
        s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1414
3047
        s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1415

7779
    } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1416
7299
        s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1417
7299
        s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1418
    } else {
1419
480
        s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1420
480
        s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1421
    }
1422
1423
10826
    if (s->avctx->debug & FF_DEBUG_NOMC) {
1424
        gray_frame(s->current_picture_ptr->f);
1425
    }
1426
1427
10826
    return 0;
1428
}
1429
1430
/* called after a frame has been decoded. */
1431
10826
void ff_mpv_frame_end(MpegEncContext *s)
1432
{
1433
10826
    emms_c();
1434
1435
10826
    if (s->current_picture.reference)
1436
8357
        ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1437
10826
}
1438
1439
10646
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
1440
{
1441
10646
    ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
1442
10646
                         p->qscale_table, p->motion_val, &s->low_delay,
1443
                         s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1444
10646
}
1445
1446
9878
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
1447
{
1448
9878
    AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
1449
9878
    int offset = 2*s->mb_stride + 1;
1450
9878
    if(!ref)
1451
        return AVERROR(ENOMEM);
1452
9878
    av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
1453
9878
    ref->size -= offset;
1454
9878
    ref->data += offset;
1455
9878
    return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
1456
}
1457
1458
126300
static inline int hpel_motion_lowres(MpegEncContext *s,
1459
                                     uint8_t *dest, uint8_t *src,
1460
                                     int field_based, int field_select,
1461
                                     int src_x, int src_y,
1462
                                     int width, int height, ptrdiff_t stride,
1463
                                     int h_edge_pos, int v_edge_pos,
1464
                                     int w, int h, h264_chroma_mc_func *pix_op,
1465
                                     int motion_x, int motion_y)
1466
{
1467
126300
    const int lowres   = s->avctx->lowres;
1468
126300
    const int op_index = FFMIN(lowres, 3);
1469
126300
    const int s_mask   = (2 << lowres) - 1;
1470
126300
    int emu = 0;
1471
    int sx, sy;
1472
1473
126300
    if (s->quarter_sample) {
1474
        motion_x /= 2;
1475
        motion_y /= 2;
1476
    }
1477
1478
126300
    sx = motion_x & s_mask;
1479
126300
    sy = motion_y & s_mask;
1480
126300
    src_x += motion_x >> lowres + 1;
1481
126300
    src_y += motion_y >> lowres + 1;
1482
1483
126300
    src   += src_y * stride + src_x;
1484
1485
126300
    if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
1486
126300
        (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1487
298
        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
1488
                                 s->linesize, s->linesize,
1489
298
                                 w + 1, (h + 1) << field_based,
1490
                                 src_x, src_y   << field_based,
1491
                                 h_edge_pos, v_edge_pos);
1492
298
        src = s->sc.edge_emu_buffer;
1493
298
        emu = 1;
1494
    }
1495
1496
126300
    sx = (sx << 2) >> lowres;
1497
126300
    sy = (sy << 2) >> lowres;
1498
126300
    if (field_select)
1499
        src += s->linesize;
1500
126300
    pix_op[op_index](dest, src, stride, h, sx, sy);
1501
126300
    return emu;
1502
}
1503
1504
/* apply one mpeg motion vector to the three components */
1505
24814
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1506
                                                uint8_t *dest_y,
1507
                                                uint8_t *dest_cb,
1508
                                                uint8_t *dest_cr,
1509
                                                int field_based,
1510
                                                int bottom_field,
1511
                                                int field_select,
1512
                                                uint8_t **ref_picture,
1513
                                                h264_chroma_mc_func *pix_op,
1514
                                                int motion_x, int motion_y,
1515
                                                int h, int mb_y)
1516
{
1517
    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1518
    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
1519
    ptrdiff_t uvlinesize, linesize;
1520
24814
    const int lowres     = s->avctx->lowres;
1521
24814
    const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 3);
1522
24814
    const int block_s    = 8>>lowres;
1523
24814
    const int s_mask     = (2 << lowres) - 1;
1524
24814
    const int h_edge_pos = s->h_edge_pos >> lowres;
1525
24814
    const int v_edge_pos = s->v_edge_pos >> lowres;
1526
24814
    linesize   = s->current_picture.f->linesize[0] << field_based;
1527
24814
    uvlinesize = s->current_picture.f->linesize[1] << field_based;
1528
1529
    // FIXME obviously not perfect but qpel will not work in lowres anyway
1530
24814
    if (s->quarter_sample) {
1531
        motion_x /= 2;
1532
        motion_y /= 2;
1533
    }
1534
1535
24814
    if(field_based){
1536
        motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1537
    }
1538
1539
24814
    sx = motion_x & s_mask;
1540
24814
    sy = motion_y & s_mask;
1541
24814
    src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1542
24814
    src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1543
1544
24814
    if (s->out_format == FMT_H263) {
1545
24814
        uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
1546
24814
        uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
1547
24814
        uvsrc_x = src_x >> 1;
1548
24814
        uvsrc_y = src_y >> 1;
1549
    } else if (s->out_format == FMT_H261) {
1550
        // even chroma mv's are full pel in H261
1551
        mx      = motion_x / 4;
1552
        my      = motion_y / 4;
1553
        uvsx    = (2 * mx) & s_mask;
1554
        uvsy    = (2 * my) & s_mask;
1555
        uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1556
        uvsrc_y =    mb_y * block_s + (my >> lowres);
1557
    } else {
1558
        if(s->chroma_y_shift){
1559
            mx      = motion_x / 2;
1560
            my      = motion_y / 2;
1561
            uvsx    = mx & s_mask;
1562
            uvsy    = my & s_mask;
1563
            uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
1564
            uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
1565
        } else {
1566
            if(s->chroma_x_shift){
1567
            //Chroma422
1568
                mx = motion_x / 2;
1569
                uvsx = mx & s_mask;
1570
                uvsy = motion_y & s_mask;
1571
                uvsrc_y = src_y;
1572
                uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1573
            } else {
1574
            //Chroma444
1575
                uvsx = motion_x & s_mask;
1576
                uvsy = motion_y & s_mask;
1577
                uvsrc_x = src_x;
1578
                uvsrc_y = src_y;
1579
            }
1580
        }
1581
    }
1582
1583
24814
    ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
1584
24814
    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1585
24814
    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1586
1587

24814
    if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||
1588
24712
        (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1589
197
        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
1590
                                 linesize >> field_based, linesize >> field_based,
1591
                                 17, 17 + field_based,
1592
                                src_x, src_y << field_based, h_edge_pos,
1593
                                v_edge_pos);
1594
197
        ptr_y = s->sc.edge_emu_buffer;
1595
        if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1596
197
            uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
1597
197
            uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
1598
197
            if (s->workaround_bugs & FF_BUG_IEDGE)
1599
                vbuf -= s->uvlinesize;
1600
197
            s->vdsp.emulated_edge_mc(ubuf,  ptr_cb,
1601
                                     uvlinesize >> field_based, uvlinesize >> field_based,
1602
                                     9, 9 + field_based,
1603
                                    uvsrc_x, uvsrc_y << field_based,
1604
                                    h_edge_pos >> 1, v_edge_pos >> 1);
1605
197
            s->vdsp.emulated_edge_mc(vbuf,  ptr_cr,
1606
                                     uvlinesize >> field_based,uvlinesize >> field_based,
1607
                                     9, 9 + field_based,
1608
                                    uvsrc_x, uvsrc_y << field_based,
1609
                                    h_edge_pos >> 1, v_edge_pos >> 1);
1610
197
            ptr_cb = ubuf;
1611
197
            ptr_cr = vbuf;
1612
        }
1613
    }
1614
1615
    // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
1616
24814
    if (bottom_field) {
1617
        dest_y  += s->linesize;
1618
        dest_cb += s->uvlinesize;
1619
        dest_cr += s->uvlinesize;
1620
    }
1621
1622
24814
    if (field_select) {
1623
        ptr_y   += s->linesize;
1624
        ptr_cb  += s->uvlinesize;
1625
        ptr_cr  += s->uvlinesize;
1626
    }
1627
1628
24814
    sx = (sx << 2) >> lowres;
1629
24814
    sy = (sy << 2) >> lowres;
1630
24814
    pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1631
1632
    if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1633
24814
        int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
1634
24814
        uvsx = (uvsx << 2) >> lowres;
1635
24814
        uvsy = (uvsy << 2) >> lowres;
1636
24814
        if (hc) {
1637
24814
            pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1638
24814
            pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1639
        }
1640
    }
1641
    // FIXME h261 lowres loop filter
1642
24814
}
1643
1644
31575
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1645
                                            uint8_t *dest_cb, uint8_t *dest_cr,
1646
                                            uint8_t **ref_picture,
1647
                                            h264_chroma_mc_func * pix_op,
1648
                                            int mx, int my)
1649
{
1650
31575
    const int lowres     = s->avctx->lowres;
1651
31575
    const int op_index   = FFMIN(lowres, 3);
1652
31575
    const int block_s    = 8 >> lowres;
1653
31575
    const int s_mask     = (2 << lowres) - 1;
1654
31575
    const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1655
31575
    const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1656
31575
    int emu = 0, src_x, src_y, sx, sy;
1657
    ptrdiff_t offset;
1658
    uint8_t *ptr;
1659
1660
31575
    if (s->quarter_sample) {
1661
        mx /= 2;
1662
        my /= 2;
1663
    }
1664
1665
    /* In case of 8X8, we construct a single chroma motion vector
1666
       with a special rounding */
1667
31575
    mx = ff_h263_round_chroma(mx);
1668
31575
    my = ff_h263_round_chroma(my);
1669
1670
31575
    sx = mx & s_mask;
1671
31575
    sy = my & s_mask;
1672
31575
    src_x = s->mb_x * block_s + (mx >> lowres + 1);
1673
31575
    src_y = s->mb_y * block_s + (my >> lowres + 1);
1674
1675
31575
    offset = src_y * s->uvlinesize + src_x;
1676
31575
    ptr = ref_picture[1] + offset;
1677
31575
    if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1678
31575
        (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1679
144
        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1680
                                 s->uvlinesize, s->uvlinesize,
1681
                                 9, 9,
1682
                                 src_x, src_y, h_edge_pos, v_edge_pos);
1683
144
        ptr = s->sc.edge_emu_buffer;
1684
144
        emu = 1;
1685
    }
1686
31575
    sx = (sx << 2) >> lowres;
1687
31575
    sy = (sy << 2) >> lowres;
1688
31575
    pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1689
1690
31575
    ptr = ref_picture[2] + offset;
1691
31575
    if (emu) {
1692
144
        s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1693
                                 s->uvlinesize, s->uvlinesize,
1694
                                 9, 9,
1695
                                 src_x, src_y, h_edge_pos, v_edge_pos);
1696
144
        ptr = s->sc.edge_emu_buffer;
1697
    }
1698
31575
    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1699
31575
}
1700
1701
/**
1702
 * motion compensation of a single macroblock
1703
 * @param s context
1704
 * @param dest_y luma destination pointer
1705
 * @param dest_cb chroma cb/u destination pointer
1706
 * @param dest_cr chroma cr/v destination pointer
1707
 * @param dir direction (0->forward, 1->backward)
1708
 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1709
 * @param pix_op halfpel motion compensation function (average or put normally)
1710
 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1711
 */
1712
56389
static inline void MPV_motion_lowres(MpegEncContext *s,
1713
                                     uint8_t *dest_y, uint8_t *dest_cb,
1714
                                     uint8_t *dest_cr,
1715
                                     int dir, uint8_t **ref_picture,
1716
                                     h264_chroma_mc_func *pix_op)
1717
{
1718
    int mx, my;
1719
    int mb_x, mb_y, i;
1720
56389
    const int lowres  = s->avctx->lowres;
1721
56389
    const int block_s = 8 >>lowres;
1722
1723
56389
    mb_x = s->mb_x;
1724
56389
    mb_y = s->mb_y;
1725
1726

56389
    switch (s->mv_type) {
1727
24814
    case MV_TYPE_16X16:
1728
24814
        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1729
                           0, 0, 0,
1730
                           ref_picture, pix_op,
1731
                           s->mv[dir][0][0], s->mv[dir][0][1],
1732
                           2 * block_s, mb_y);
1733
24814
        break;
1734
31575
    case MV_TYPE_8X8:
1735
31575
        mx = 0;
1736
31575
        my = 0;
1737
157875
        for (i = 0; i < 4; i++) {
1738
126300
            hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
1739
126300
                               s->linesize) * block_s,
1740
                               ref_picture[0], 0, 0,
1741
126300
                               (2 * mb_x + (i & 1)) * block_s,
1742
126300
                               (2 * mb_y + (i >> 1)) * block_s,
1743
                               s->width, s->height, s->linesize,
1744
126300
                               s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1745
                               block_s, block_s, pix_op,
1746
                               s->mv[dir][i][0], s->mv[dir][i][1]);
1747
1748
126300
            mx += s->mv[dir][i][0];
1749
126300
            my += s->mv[dir][i][1];
1750
        }
1751
1752
        if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
1753
31575
            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1754
                                     pix_op, mx, my);
1755
31575
        break;
1756
    case MV_TYPE_FIELD:
1757
        if (s->picture_structure == PICT_FRAME) {
1758
            /* top field */
1759
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1760
                               1, 0, s->field_select[dir][0],
1761
                               ref_picture, pix_op,
1762
                               s->mv[dir][0][0], s->mv[dir][0][1],
1763
                               block_s, mb_y);
1764
            /* bottom field */
1765
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1766
                               1, 1, s->field_select[dir][1],
1767
                               ref_picture, pix_op,
1768
                               s->mv[dir][1][0], s->mv[dir][1][1],
1769
                               block_s, mb_y);
1770
        } else {
1771
            if (s->picture_structure != s->field_select[dir][0] + 1 &&
1772
                s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
1773
                ref_picture = s->current_picture_ptr->f->data;
1774
1775
            }
1776
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1777
                               0, 0, s->field_select[dir][0],
1778
                               ref_picture, pix_op,
1779
                               s->mv[dir][0][0],
1780
                               s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1781
            }
1782
        break;
1783
    case MV_TYPE_16X8:
1784
        for (i = 0; i < 2; i++) {
1785
            uint8_t **ref2picture;
1786
1787
            if (s->picture_structure == s->field_select[dir][i] + 1 ||
1788
                s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
1789
                ref2picture = ref_picture;
1790
            } else {
1791
                ref2picture = s->current_picture_ptr->f->data;
1792
            }
1793
1794
            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1795
                               0, 0, s->field_select[dir][i],
1796
                               ref2picture, pix_op,
1797
                               s->mv[dir][i][0], s->mv[dir][i][1] +
1798
                               2 * block_s * i, block_s, mb_y >> 1);
1799
1800
            dest_y  +=  2 * block_s *  s->linesize;
1801
            dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1802
            dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1803
        }
1804
        break;
1805
    case MV_TYPE_DMV:
1806
        if (s->picture_structure == PICT_FRAME) {
1807
            for (i = 0; i < 2; i++) {
1808
                int j;
1809
                for (j = 0; j < 2; j++) {
1810
                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1811
                                       1, j, j ^ i,
1812
                                       ref_picture, pix_op,
1813
                                       s->mv[dir][2 * i + j][0],
1814
                                       s->mv[dir][2 * i + j][1],
1815
                                       block_s, mb_y);
1816
                }
1817
                pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1818
            }
1819
        } else {
1820
            for (i = 0; i < 2; i++) {
1821
                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1822
                                   0, 0, s->picture_structure != i + 1,
1823
                                   ref_picture, pix_op,
1824
                                   s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
1825
                                   2 * block_s, mb_y >> 1);
1826
1827
                // after put we make avg of the same block
1828
                pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1829
1830
                // opposite parity is always in the same
1831
                // frame if this is second field
1832
                if (!s->first_field) {
1833
                    ref_picture = s->current_picture_ptr->f->data;
1834
                }
1835
            }
1836
        }
1837
        break;
1838
56389
    default:
1839
        av_assert2(0);
1840
    }
1841
56389
}
1842
1843
/**
1844
 * find the lowest MB row referenced in the MVs
1845
 */
1846
static int lowest_referenced_row(MpegEncContext *s, int dir)
1847
{
1848
    int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1849
    int my, off, i, mvs;
1850
1851
    if (s->picture_structure != PICT_FRAME || s->mcsel)
1852
        goto unhandled;
1853
1854
    switch (s->mv_type) {
1855
        case MV_TYPE_16X16:
1856
            mvs = 1;
1857
            break;
1858
        case MV_TYPE_16X8:
1859
            mvs = 2;
1860
            break;
1861
        case MV_TYPE_8X8:
1862
            mvs = 4;
1863
            break;
1864
        default:
1865
            goto unhandled;
1866
    }
1867
1868
    for (i = 0; i < mvs; i++) {
1869
        my = s->mv[dir][i][1];
1870
        my_max = FFMAX(my_max, my);
1871
        my_min = FFMIN(my_min, my);
1872
    }
1873
1874
    off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1875
1876
    return av_clip(s->mb_y + off, 0, s->mb_height - 1);
1877
unhandled:
1878
    return s->mb_height-1;
1879
}
1880
1881
/* put block[] to dest[] */
1882
4698878
static inline void put_dct(MpegEncContext *s,
1883
                           int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1884
{
1885
4698878
    s->dct_unquantize_intra(s, block, i, qscale);
1886
4698878
    s->idsp.idct_put(dest, line_size, block);
1887
4698878
}
1888
1889
/* add block[] to dest[] */
1890
19366082
static inline void add_dct(MpegEncContext *s,
1891
                           int16_t *block, int i, uint8_t *dest, int line_size)
1892
{
1893
19366082
    if (s->block_last_index[i] >= 0) {
1894
7046442
        s->idsp.idct_add(dest, line_size, block);
1895
    }
1896
19366082
}
1897
1898
21854390
static inline void add_dequant_dct(MpegEncContext *s,
1899
                           int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1900
{
1901
21854390
    if (s->block_last_index[i] >= 0) {
1902
9051961
        s->dct_unquantize_inter(s, block, i, qscale);
1903
1904
9051961
        s->idsp.idct_add(dest, line_size, block);
1905
    }
1906
21854390
}
1907
1908
/**
1909
 * Clean dc, ac, coded_block for the current non-intra MB.
1910
 */
1911
383901
void ff_clean_intra_table_entries(MpegEncContext *s)
1912
{
1913
383901
    int wrap = s->b8_stride;
1914
383901
    int xy = s->block_index[0];
1915
1916
383901
    s->dc_val[0][xy           ] =
1917
383901
    s->dc_val[0][xy + 1       ] =
1918
383901
    s->dc_val[0][xy     + wrap] =
1919
383901
    s->dc_val[0][xy + 1 + wrap] = 1024;
1920
    /* ac pred */
1921
383901
    memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1922
383901
    memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1923
383901
    if (s->msmpeg4_version>=3) {
1924
45701
        s->coded_block[xy           ] =
1925
45701
        s->coded_block[xy + 1       ] =
1926
45701
        s->coded_block[xy     + wrap] =
1927
45701
        s->coded_block[xy + 1 + wrap] = 0;
1928
    }
1929
    /* chroma */
1930
383901
    wrap = s->mb_stride;
1931
383901
    xy = s->mb_x + s->mb_y * wrap;
1932
383901
    s->dc_val[1][xy] =
1933
383901
    s->dc_val[2][xy] = 1024;
1934
    /* ac pred */
1935
383901
    memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1936
383901
    memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1937
1938
383901
    s->mbintra_table[xy]= 0;
1939
383901
}
1940
1941
/* generic function called after a macroblock has been parsed by the
1942
   decoder or after it has been encoded by the encoder.
1943
1944
   Important variables used:
1945
   s->mb_intra : true if intra macroblock
1946
   s->mv_dir   : motion vector direction
1947
   s->mv_type  : motion vector type
1948
   s->mv       : motion vector
1949
   s->interlaced_dct : true if interlaced dct used (mpeg2)
1950
 */
1951
static av_always_inline
1952
8873167
void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64],
1953
                            int lowres_flag, int is_mpeg12)
1954
{
1955
8873167
    const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1956
1957
    if (CONFIG_XVMC &&
1958
        s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
1959
        s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
1960
        return;
1961
    }
1962
1963
8873167
    if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1964
       /* print DCT coefficients */
1965
       int i,j;
1966
       av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1967
       for(i=0; i<6; i++){
1968
           for(j=0; j<64; j++){
1969
               av_log(s->avctx, AV_LOG_DEBUG, "%5d",
1970
                      block[i][s->idsp.idct_permutation[j]]);
1971
           }
1972
           av_log(s->avctx, AV_LOG_DEBUG, "\n");
1973
       }
1974
    }
1975
1976
8873167
    s->current_picture.qscale_table[mb_xy] = s->qscale;
1977
1978
    /* update DC predictors for P macroblocks */
1979
8873167
    if (!s->mb_intra) {
1980

7138622
        if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1981
3329974
            if(s->mbintra_table[mb_xy])
1982
306277
                ff_clean_intra_table_entries(s);
1983
        } else {
1984
3808648
            s->last_dc[0] =
1985
3808648
            s->last_dc[1] =
1986
3808648
            s->last_dc[2] = 128 << s->intra_dc_precision;
1987
        }
1988
    }
1989

1734545
    else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1990
452318
        s->mbintra_table[mb_xy]=1;
1991
1992

8873167
    if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
1993

8873167
        !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
1994
1926989
          s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
1995
        uint8_t *dest_y, *dest_cb, *dest_cr;
1996
        int dct_linesize, dct_offset;
1997
        op_pixels_func (*op_pix)[4];
1998
        qpel_mc_func (*op_qpix)[16];
1999
7965973
        const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2000
7965973
        const int uvlinesize = s->current_picture.f->linesize[1];
2001


7965973
        const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2002
7965973
        const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2003
2004
        /* avoid copy if macroblock skipped in last frame too */
2005
        /* skip only during decoding as we might trash the buffers during encoding a bit */
2006
7965973
        if(!s->encoding){
2007
4545066
            uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2008
2009
4545066
            if (s->mb_skipped) {
2010
322949
                s->mb_skipped= 0;
2011
                av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2012
322949
                *mbskip_ptr = 1;
2013
4222117
            } else if(!s->current_picture.reference) {
2014
886263
                *mbskip_ptr = 1;
2015
            } else{
2016
3335854
                *mbskip_ptr = 0; /* not skipped */
2017
            }
2018
        }
2019
2020
7965973
        dct_linesize = linesize << s->interlaced_dct;
2021
7965973
        dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2022
2023
7965973
        if(readable){
2024
6995046
            dest_y=  s->dest[0];
2025
6995046
            dest_cb= s->dest[1];
2026
6995046
            dest_cr= s->dest[2];
2027
        }else{
2028
970927
            dest_y = s->sc.b_scratchpad;
2029
970927
            dest_cb= s->sc.b_scratchpad+16*linesize;
2030
970927
            dest_cr= s->sc.b_scratchpad+32*linesize;
2031
        }
2032
2033
7965973
        if (!s->mb_intra) {
2034
            /* motion handling */
2035
            /* decoding or more than one mb_type (MC was already done otherwise) */
2036
6921926
            if(!s->encoding){
2037
2038
3968960
                if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2039
                    if (s->mv_dir & MV_DIR_FORWARD) {
2040
                        ff_thread_await_progress(&s->last_picture_ptr->tf,
2041
                                                 lowest_referenced_row(s, 0),
2042
                                                 0);
2043
                    }
2044
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2045
                        ff_thread_await_progress(&s->next_picture_ptr->tf,
2046
                                                 lowest_referenced_row(s, 1),
2047
                                                 0);
2048
                    }
2049
                }
2050
2051
3968960
                if(lowres_flag){
2052
41123
                    h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2053
2054
41123
                    if (s->mv_dir & MV_DIR_FORWARD) {
2055
37429
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2056
37429
                        op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2057
                    }
2058
41123
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2059
18960
                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2060
                    }
2061
                }else{
2062
3927837
                    op_qpix = s->me.qpel_put;
2063

3927837
                    if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2064
3168898
                        op_pix = s->hdsp.put_pixels_tab;
2065
                    }else{
2066
758939
                        op_pix = s->hdsp.put_no_rnd_pixels_tab;
2067
                    }
2068
3927837
                    if (s->mv_dir & MV_DIR_FORWARD) {
2069
3697244
                        ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2070
3697244
                        op_pix = s->hdsp.avg_pixels_tab;
2071
3697244
                        op_qpix= s->me.qpel_avg;
2072
                    }
2073
3927837
                    if (s->mv_dir & MV_DIR_BACKWARD) {
2074
754504
                        ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2075
                    }
2076
                }
2077
            }
2078
2079
            /* skip dequant / idct if we are really late ;) */
2080
6921926
            if(s->avctx->skip_idct){
2081
                if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2082
                   ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2083
                   || s->avctx->skip_idct >= AVDISCARD_ALL)
2084
                    goto skip_idct;
2085
            }
2086
2087
            /* add dct residue */
2088


6921926
            if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2089

1814842
                                || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2090
3526530
                add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2091
3526530
                add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2092
3526530
                add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2093
3526530
                add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2094
2095
3526530
                if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2096
3526530
                    if (s->chroma_y_shift){
2097
3178925
                        add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2098
3178925
                        add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2099
                    }else{
2100
347605
                        dct_linesize >>= 1;
2101
347605
                        dct_offset >>=1;
2102
347605
                        add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2103
347605
                        add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2104
347605
                        add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2105
347605
                        add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2106
                    }
2107
                }
2108

3395396
            } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2109
3205247
                add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2110
3205247
                add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2111
3205247
                add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2112
3205247
                add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2113
2114
3205247
                if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2115
3205247
                    if(s->chroma_y_shift){//Chroma420
2116
3137947
                        add_dct(s, block[4], 4, dest_cb, uvlinesize);
2117
3137947
                        add_dct(s, block[5], 5, dest_cr, uvlinesize);
2118
                    }else{
2119
                        //chroma422
2120
67300
                        dct_linesize = uvlinesize << s->interlaced_dct;
2121
67300
                        dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2122
2123
67300
                        add_dct(s, block[4], 4, dest_cb, dct_linesize);
2124
67300
                        add_dct(s, block[5], 5, dest_cr, dct_linesize);
2125
67300
                        add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2126
67300
                        add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2127
67300
                        if(!s->chroma_x_shift){//Chroma444
2128
                            add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2129
                            add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2130
                            add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2131
                            add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2132
                        }
2133
                    }
2134
                }//fi gray
2135
            }
2136
            else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2137
190149
                ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2138
            }
2139
        } else {
2140
            /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
2141
               TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
2142
1044047
            if (s->avctx->bits_per_raw_sample > 8){
2143
                const int act_block_size = block_size * 2;
2144
2145
                if(s->dpcm_direction == 0) {
2146
                    s->idsp.idct_put(dest_y,                           dct_linesize, (int16_t*)(*s->block32)[0]);
2147
                    s->idsp.idct_put(dest_y              + act_block_size, dct_linesize, (int16_t*)(*s->block32)[1]);
2148
                    s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, (int16_t*)(*s->block32)[2]);
2149
                    s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)(*s->block32)[3]);
2150
2151
                    dct_linesize = uvlinesize << s->interlaced_dct;
2152
                    dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2153
2154
                    s->idsp.idct_put(dest_cb,              dct_linesize, (int16_t*)(*s->block32)[4]);
2155
                    s->idsp.idct_put(dest_cr,              dct_linesize, (int16_t*)(*s->block32)[5]);
2156
                    s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)(*s->block32)[6]);
2157
                    s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)(*s->block32)[7]);
2158
                    if(!s->chroma_x_shift){//Chroma444
2159
                        s->idsp.idct_put(dest_cb + act_block_size,              dct_linesize, (int16_t*)(*s->block32)[8]);
2160
                        s->idsp.idct_put(dest_cr + act_block_size,              dct_linesize, (int16_t*)(*s->block32)[9]);
2161
                        s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[10]);
2162
                        s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[11]);
2163
                    }
2164
                } else if(s->dpcm_direction == 1) {
2165
                    int i, w, h;
2166
                    uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2167
                    int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2168
                    for(i = 0; i < 3; i++) {
2169
                        int idx = 0;
2170
                        int vsub = i ? s->chroma_y_shift : 0;
2171
                        int hsub = i ? s->chroma_x_shift : 0;
2172
                        for(h = 0; h < (16 >> vsub); h++){
2173
                            for(w = 0; w < (16 >> hsub); w++)
2174
                                dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2175
                            dest_pcm[i] += linesize[i] / 2;
2176
                        }
2177
                    }
2178
                } else if(s->dpcm_direction == -1) {
2179
                    int i, w, h;
2180
                    uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2181
                    int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2182
                    for(i = 0; i < 3; i++) {
2183
                        int idx = 0;
2184
                        int vsub = i ? s->chroma_y_shift : 0;
2185
                        int hsub = i ? s->chroma_x_shift : 0;
2186
                        dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub) - 1);
2187
                        for(h = (16 >> vsub)-1; h >= 1; h--){
2188
                            for(w = (16 >> hsub)-1; w >= 1; w--)
2189
                                dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2190
                            dest_pcm[i] -= linesize[i] / 2;
2191
                        }
2192
                    }
2193
                }
2194
            }
2195
            /* dct only in intra block */
2196

1044047
            else if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2197
770143
                put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2198
770143
                put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2199
770143
                put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2200
770143
                put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2201
2202
770143
                if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2203
770143
                    if(s->chroma_y_shift){
2204
731133
                        put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2205
731133
                        put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2206
                    }else{
2207
39010
                        dct_offset >>=1;
2208
39010
                        dct_linesize >>=1;
2209
39010
                        put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2210
39010
                        put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2211
39010
                        put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2212
39010
                        put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2213
                    }
2214
                }
2215
            }else{
2216
273904
                s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
2217
273904
                s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2218
273904
                s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
2219
273904
                s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2220
2221
                if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2222
273904
                    if(s->chroma_y_shift){
2223
220094
                        s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2224
220094
                        s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2225
                    }else{
2226
2227
53810
                        dct_linesize = uvlinesize << s->interlaced_dct;
2228
53810
                        dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2229
2230
53810
                        s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
2231
53810
                        s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
2232
53810
                        s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2233
53810
                        s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2234
53810
                        if(!s->chroma_x_shift){//Chroma444
2235
                            s->idsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2236
                            s->idsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2237
                            s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2238
                            s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2239
                        }
2240
                    }
2241
                }//gray
2242
            }
2243
        }
2244
53810
skip_idct:
2245
7965973
        if(!readable){
2246
970927
            s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2247
            if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2248
970927
                s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2249
970927
                s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2250
            }
2251
        }
2252
    }
2253
}
2254
2255
8873167
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
2256
{
2257
#if !CONFIG_SMALL
2258
8873167
    if(s->out_format == FMT_MPEG1) {
2259
3627291
        if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
2260
3627291
        else                 mpv_reconstruct_mb_internal(s, block, 0, 1);
2261
    } else
2262
#endif
2263
5245876
    if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
2264
5202376
    else                  mpv_reconstruct_mb_internal(s, block, 0, 0);
2265
8873167
}
2266
2267
166760
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2268
{
2269
166760
    ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
2270
166760
                       s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
2271
                       s->first_field, s->low_delay);
2272
166760
}
2273
2274
836832
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2275
836832
    const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2276
836832
    const int uvlinesize = s->current_picture.f->linesize[1];
2277
836832
    const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
2278
836832
    const int height_of_mb = 4 - s->avctx->lowres;
2279
2280
836832
    s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2281
836832
    s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2282
836832
    s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2283
836832
    s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2284
836832
    s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2285
836832
    s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2286
    //block_index is not used by mpeg2, so it is not affected by chroma_format
2287
2288
836832
    s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) <<  width_of_mb);
2289
836832
    s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2290
836832
    s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2291
2292

836832
    if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2293
    {
2294
836832
        if(s->picture_structure==PICT_FRAME){
2295
806052
        s->dest[0] += s->mb_y *   linesize << height_of_mb;
2296
806052
        s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2297
806052
        s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2298
        }else{
2299
30780
            s->dest[0] += (s->mb_y>>1) *   linesize << height_of_mb;
2300
30780
            s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2301
30780
            s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2302
            av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2303
        }
2304
    }
2305
836832
}
2306
2307
79
void ff_mpeg_flush(AVCodecContext *avctx){
2308
    int i;
2309
79
    MpegEncContext *s = avctx->priv_data;
2310
2311

79
    if (!s || !s->picture)
2312
        return;
2313
2314
2923
    for (i = 0; i < MAX_PICTURE_COUNT; i++)
2315
2844
        ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2316
79
    s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2317
2318
79
    ff_mpeg_unref_picture(s->avctx, &s->current_picture);
2319
79
    ff_mpeg_unref_picture(s->avctx, &s->last_picture);
2320
79
    ff_mpeg_unref_picture(s->avctx, &s->next_picture);
2321
2322
79
    s->mb_x= s->mb_y= 0;
2323
79
    s->closed_gop= 0;
2324
2325
79
    s->parse_context.state= -1;
2326
79
    s->parse_context.frame_start_found= 0;
2327
79
    s->parse_context.overread= 0;
2328
79
    s->parse_context.overread_index= 0;
2329
79
    s->parse_context.index= 0;
2330
79
    s->parse_context.last_index= 0;
2331
79
    s->bitstream_buffer_size=0;
2332
79
    s->pp_time=0;
2333
}
2334
2335
/**
2336
 * set qscale and update qscale dependent variables.
2337
 */
2338
1444180
void ff_set_qscale(MpegEncContext * s, int qscale)
2339
{
2340
1444180
    if (qscale < 1)
2341
        qscale = 1;
2342
1444180
    else if (qscale > 31)
2343
        qscale = 31;
2344
2345
1444180
    s->qscale = qscale;
2346
1444180
    s->chroma_qscale= s->chroma_qscale_table[qscale];
2347
2348
1444180
    s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2349
1444180
    s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2350
1444180
}
2351
2352
156992
void ff_mpv_report_decode_progress(MpegEncContext *s)
2353
{
2354

156992
    if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2355
116532
        ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2356
156992
}