mpeg12enc.c 47 KB
Newer Older
1
/*
2
 * MPEG-1/2 encoder
3
 * Copyright (c) 2000,2001 Fabrice Bellard
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
24
 * @file
25
 * MPEG-1/2 encoder
26 27
 */

28 29
#include <stdint.h>

30
#include "libavutil/attributes.h"
31
#include "libavutil/avassert.h"
32 33
#include "libavutil/log.h"
#include "libavutil/opt.h"
34
#include "libavutil/timecode.h"
35 36
#include "libavutil/stereo3d.h"

37
#include "avcodec.h"
38
#include "bytestream.h"
39
#include "mathops.h"
40 41
#include "mpeg12.h"
#include "mpeg12data.h"
42
#include "mpegutils.h"
43
#include "mpegvideo.h"
44

45 46 47
static const uint8_t svcd_scan_offset_placeholder[] = {
    0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80,
    0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
48 49
};

50
static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
51
static uint8_t fcode_tab[MAX_MV * 2 + 1];
52

53 54
static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
55

56 57
/* simple include everything table for dc, first byte is bits
 * number next 3 are code */
58 59 60 61
static uint32_t mpeg1_lum_dc_uni[512];
static uint32_t mpeg1_chr_dc_uni[512];

static uint8_t mpeg1_index_run[2][64];
62
static int8_t  mpeg1_max_level[2][64];
63

64 65
#define A53_MAX_CC_COUNT 0x1f

66 67
static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
{
68 69
    int i;

70 71
    for (i = 0; i < 128; i++) {
        int level = i - 64;
72
        int run;
73 74
        if (!level)
            continue;
75
        for (run = 0; run < 64; run++) {
76
            int len, code;
77
            int alevel = FFABS(level);
78 79

            if (alevel > rl->max_level[0][run])
80
                code = 111;                         /* rl->n */
81
            else
82
                code = rl->index_run[0][run] + alevel - 1;
83

84 85 86
            if (code < 111) {                       /* rl->n */
                /* length of VLC and sign */
                len = rl->table_vlc[code][1] + 1;
87
            } else {
88
                len = rl->table_vlc[111 /* rl->n */][1] + 6;
89

90
                if (alevel < 128)
91
                    len += 8;
92
                else
93
                    len += 16;
94 95
            }

96
            uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
97 98 99 100
        }
    }
}

101 102
static int find_frame_rate_index(MpegEncContext *s)
{
103
    int i;
104
    AVRational bestq = (AVRational) {0, 0};
105 106
    AVRational ext;
    AVRational target = av_inv_q(s->avctx->time_base);
107

108 109 110 111
    for (i = 1; i < 14; i++) {
        if (s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&
            i >= 9)
            break;
112

113 114
        for (ext.num=1; ext.num <= 4; ext.num++) {
            for (ext.den=1; ext.den <= 32; ext.den++) {
115
                AVRational q = av_mul_q(ext, ff_mpeg12_frame_rate_tab[i]);
116

117
                if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
118
                    continue;
119
                if (av_gcd(ext.den, ext.num) != 1)
120 121
                    continue;

122
                if (    bestq.num==0
123
                    || av_nearer_q(target, bestq, q) < 0
124 125 126
                    || ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) {
                    bestq               = q;
                    s->frame_rate_index = i;
127 128 129 130
                    s->mpeg2_frame_rate_ext.num = ext.num;
                    s->mpeg2_frame_rate_ext.den = ext.den;
                }
            }
131 132
        }
    }
133

134
    if (av_cmp_q(target, bestq))
135 136 137 138 139
        return -1;
    else
        return 0;
}

140
static av_cold int encode_init(AVCodecContext *avctx)
141 142 143
{
    MpegEncContext *s = avctx->priv_data;

144
    if (ff_mpv_encode_init(avctx) < 0)
145 146
        return -1;

147 148
    if (find_frame_rate_index(s) < 0) {
        if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
149
            av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n",
150
                   avctx->time_base.den, avctx->time_base.num);
151
            return -1;
152 153
        } else {
            av_log(avctx, AV_LOG_INFO,
154
                   "MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n",
155
                   avctx->time_base.den, avctx->time_base.num);
156 157 158
        }
    }

159 160
    if (avctx->profile == FF_PROFILE_UNKNOWN) {
        if (avctx->level != FF_LEVEL_UNKNOWN) {
161 162 163
            av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
            return -1;
        }
164 165
        /* Main or 4:2:2 */
        avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0;
166 167
    }

168 169 170 171 172 173 174 175 176 177
    if (avctx->level == FF_LEVEL_UNKNOWN) {
        if (avctx->profile == 0) {                  /* 4:2:2 */
            if (avctx->width <= 720 && avctx->height <= 608)
                avctx->level = 5;                   /* Main */
            else
                avctx->level = 2;                   /* High */
        } else {
            if (avctx->profile != 1 && s->chroma_format != CHROMA_420) {
                av_log(avctx, AV_LOG_ERROR,
                       "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
178 179
                return -1;
            }
180 181 182 183 184 185
            if (avctx->width <= 720 && avctx->height <= 576)
                avctx->level = 8;                   /* Main */
            else if (avctx->width <= 1440)
                avctx->level = 6;                   /* High 1440 */
            else
                avctx->level = 4;                   /* High */
186 187 188
        }
    }

189 190 191 192 193 194 195
    if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) {
        av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n");
        return AVERROR(EINVAL);
    }

    if (s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
        if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) {
196
            av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
197 198 199 200 201
                                        "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
            return AVERROR(EINVAL);
        }
    }

202
    s->drop_frame_timecode = s->drop_frame_timecode || !!(avctx->flags2 & AV_CODEC_FLAG2_DROP_FRAME_TIMECODE);
203 204
    if (s->drop_frame_timecode)
        s->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME;
205
    if (s->drop_frame_timecode && s->frame_rate_index != 4) {
206 207
        av_log(avctx, AV_LOG_ERROR,
               "Drop frame time code only allowed with 1001/30000 fps\n");
208 209 210
        return -1;
    }

211 212 213 214 215 216 217
#if FF_API_PRIVATE_OPT
FF_DISABLE_DEPRECATION_WARNINGS
    if (avctx->timecode_frame_start)
        s->timecode_frame_start = avctx->timecode_frame_start;
FF_ENABLE_DEPRECATION_WARNINGS
#endif

218
    if (s->tc_opt_str) {
219
        AVRational rate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
220 221 222 223
        int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s);
        if (ret < 0)
            return ret;
        s->drop_frame_timecode = !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME);
224
        s->timecode_frame_start = s->tc.start;
225
    } else {
226
        s->timecode_frame_start = 0; // default is -1
227
    }
228

229 230 231 232 233
    return 0;
}

static void put_header(MpegEncContext *s, int header)
{
234
    avpriv_align_put_bits(&s->pb);
235
    put_bits(&s->pb, 16, header >> 16);
236
    put_sbits(&s->pb, 16, header);
237 238 239 240 241
}

/* put sequence header if needed */
static void mpeg1_encode_sequence_header(MpegEncContext *s)
{
242 243 244
    unsigned int vbv_buffer_size, fps, v;
    int i, constraint_parameter_flag;
    uint64_t time_code;
245 246
    int64_t best_aspect_error = INT64_MAX;
    AVRational aspect_ratio = s->avctx->sample_aspect_ratio;
247

248 249
    if (aspect_ratio.num == 0 || aspect_ratio.den == 0)
        aspect_ratio = (AVRational){1,1};             // pixel aspect 1.1 (VGA)
250

251
    if (s->current_picture.f->key_frame) {
252
        AVRational framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
253

254
        /* MPEG-1 header repeated every GOP */
255
        put_header(s, SEQ_START_CODE);
256

257 258
        put_sbits(&s->pb, 12, s->width  & 0xFFF);
        put_sbits(&s->pb, 12, s->height & 0xFFF);
259

260
        for (i = 1; i < 15; i++) {
261
            int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den;
262
            if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1)
263
                error -= (1LL<<32) / ff_mpeg1_aspect[i];
264
            else
265
                error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den;
266

267
            error = FFABS(error);
268

269
            if (error - 2 <= best_aspect_error) {
270 271
                best_aspect_error    = error;
                s->aspect_ratio_info = i;
272
            }
273
        }
274

275 276
        put_bits(&s->pb, 4, s->aspect_ratio_info);
        put_bits(&s->pb, 4, s->frame_rate_index);
277

278 279 280 281 282 283 284
        if (s->avctx->rc_max_rate) {
            v = (s->avctx->rc_max_rate + 399) / 400;
            if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
                v = 0x3ffff;
        } else {
            v = 0x3FFFF;
        }
285

286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
        if (s->avctx->rc_buffer_size)
            vbv_buffer_size = s->avctx->rc_buffer_size;
        else
            /* VBV calculation: Scaled so that a VCD has the proper
             * VBV size of 40 kilobytes */
            vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024;
        vbv_buffer_size = (vbv_buffer_size + 16383) / 16384;

        put_sbits(&s->pb, 18, v);
        put_bits(&s->pb, 1, 1);         // marker
        put_sbits(&s->pb, 10, vbv_buffer_size);

        constraint_parameter_flag =
            s->width  <= 768                                    &&
            s->height <= 576                                    &&
            s->mb_width * s->mb_height                 <= 396   &&
            s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den &&
            framerate.num <= framerate.den * 30                 &&
            s->avctx->me_range                                  &&
            s->avctx->me_range < 128                            &&
            vbv_buffer_size <= 20                               &&
            v <= 1856000 / 400                                  &&
            s->codec_id == AV_CODEC_ID_MPEG1VIDEO;

        put_bits(&s->pb, 1, constraint_parameter_flag);

        ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix);
        ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix);

        if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
316 317 318 319 320
            AVFrameSideData *side_data;
            int width = s->width;
            int height = s->height;
            int use_seq_disp_ext;

321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
            put_header(s, EXT_START_CODE);
            put_bits(&s->pb, 4, 1);                 // seq ext

            put_bits(&s->pb, 1, s->avctx->profile == 0); // escx 1 for 4:2:2 profile

            put_bits(&s->pb, 3, s->avctx->profile); // profile
            put_bits(&s->pb, 4, s->avctx->level);   // level

            put_bits(&s->pb, 1, s->progressive_sequence);
            put_bits(&s->pb, 2, s->chroma_format);
            put_bits(&s->pb, 2, s->width  >> 12);
            put_bits(&s->pb, 2, s->height >> 12);
            put_bits(&s->pb, 12, v >> 18);          // bitrate ext
            put_bits(&s->pb, 1, 1);                 // marker
            put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext
            put_bits(&s->pb, 1, s->low_delay);
337 338
            put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n
            put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d
339

340 341 342 343 344 345 346 347 348 349 350 351 352
            side_data = av_frame_get_side_data(s->current_picture_ptr->f, AV_FRAME_DATA_PANSCAN);
            if (side_data) {
                AVPanScan *pan_scan = (AVPanScan *)side_data->data;
                if (pan_scan->width && pan_scan->height) {
                    width = pan_scan->width >> 4;
                    height = pan_scan->height >> 4;
                }
            }

            use_seq_disp_ext = (width != s->width ||
                                height != s->height ||
                                s->avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
                                s->avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
353 354
                                s->avctx->colorspace != AVCOL_SPC_UNSPECIFIED ||
                                s->video_format != VIDEO_FORMAT_UNSPECIFIED);
355

356
            if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
357 358
                put_header(s, EXT_START_CODE);
                put_bits(&s->pb, 4, 2);                         // sequence display extension
359
                put_bits(&s->pb, 3, s->video_format);           // video_format
360 361 362 363
                put_bits(&s->pb, 1, 1);                         // colour_description
                put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries
                put_bits(&s->pb, 8, s->avctx->color_trc);       // transfer_characteristics
                put_bits(&s->pb, 8, s->avctx->colorspace);      // matrix_coefficients
364
                put_bits(&s->pb, 14, width);                    // display_horizontal_size
365
                put_bits(&s->pb, 1, 1);                         // marker_bit
366
                put_bits(&s->pb, 14, height);                   // display_vertical_size
367 368
                put_bits(&s->pb, 3, 0);                         // remaining 3 bits are zero padding
            }
369 370
        }

371 372 373 374 375
        put_header(s, GOP_START_CODE);
        put_bits(&s->pb, 1, s->drop_frame_timecode);    // drop frame flag
        /* time code: we must convert from the real frame rate to a
         * fake MPEG frame rate in case of low frame rate */
        fps       = (framerate.num + framerate.den / 2) / framerate.den;
376
        time_code = s->current_picture_ptr->f->coded_picture_number +
377
                    s->timecode_frame_start;
378

379
        s->gop_picture_number = s->current_picture_ptr->f->coded_picture_number;
380 381 382 383 384

        av_assert0(s->drop_frame_timecode == !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME));
        if (s->drop_frame_timecode)
            time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps);

385 386 387 388 389
        put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
        put_bits(&s->pb, 6, (uint32_t)((time_code / (fps *   60)) % 60));
        put_bits(&s->pb, 1, 1);
        put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60));
        put_bits(&s->pb, 6, (uint32_t)((time_code % fps)));
390
        put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) || s->intra_only || !s->gop_picture_number);
391 392
        put_bits(&s->pb, 1, 0);                     // broken link
    }
393 394
}

395 396
static inline void encode_mb_skip_run(MpegEncContext *s, int run)
{
397 398 399 400
    while (run >= 33) {
        put_bits(&s->pb, 11, 0x008);
        run -= 33;
    }
401 402
    put_bits(&s->pb, ff_mpeg12_mbAddrIncrTable[run][1],
             ff_mpeg12_mbAddrIncrTable[run][0]);
403 404 405 406
}

static av_always_inline void put_qscale(MpegEncContext *s)
{
407
    put_bits(&s->pb, 5, s->qscale);
408 409
}

410 411
void ff_mpeg1_encode_slice_header(MpegEncContext *s)
{
412
    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) {
413
        put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127));
414 415
        /* slice_vertical_position_extension */
        put_bits(&s->pb, 3, s->mb_y >> 7);
416
    } else {
417
        put_header(s, SLICE_MIN_START_CODE + s->mb_y);
418
    }
419
    put_qscale(s);
420 421
    /* slice extra information */
    put_bits(&s->pb, 1, 0);
422 423
}

424
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
425
{
426
    AVFrameSideData *side_data;
427 428
    mpeg1_encode_sequence_header(s);

429
    /* MPEG-1 picture header */
430 431 432 433
    put_header(s, PICTURE_START_CODE);
    /* temporal reference */

    // RAL: s->picture_number instead of s->fake_picture_number
434 435
    put_bits(&s->pb, 10,
             (s->picture_number - s->gop_picture_number) & 0x3ff);
436 437
    put_bits(&s->pb, 3, s->pict_type);

438 439
    s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8;
    put_bits(&s->pb, 16, 0xFFFF);               /* vbv_delay */
440

441 442 443 444 445 446
    // RAL: Forward f_code also needed for B-frames
    if (s->pict_type == AV_PICTURE_TYPE_P ||
        s->pict_type == AV_PICTURE_TYPE_B) {
        put_bits(&s->pb, 1, 0);                 /* half pel coordinates */
        if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
            put_bits(&s->pb, 3, s->f_code);     /* forward_f_code */
447
        else
448
            put_bits(&s->pb, 3, 7);             /* forward_f_code */
449 450
    }

451
    // RAL: Backward f_code necessary for B-frames
452
    if (s->pict_type == AV_PICTURE_TYPE_B) {
453 454 455
        put_bits(&s->pb, 1, 0);                 /* half pel coordinates */
        if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO)
            put_bits(&s->pb, 3, s->b_code);     /* backward_f_code */
456
        else
457
            put_bits(&s->pb, 3, 7);             /* backward_f_code */
458 459
    }

460
    put_bits(&s->pb, 1, 0);                     /* extra bit picture */
461 462

    s->frame_pred_frame_dct = 1;
463
    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
464
        put_header(s, EXT_START_CODE);
465 466 467
        put_bits(&s->pb, 4, 8);                 /* pic ext */
        if (s->pict_type == AV_PICTURE_TYPE_P ||
            s->pict_type == AV_PICTURE_TYPE_B) {
468 469
            put_bits(&s->pb, 4, s->f_code);
            put_bits(&s->pb, 4, s->f_code);
470
        } else {
471 472
            put_bits(&s->pb, 8, 255);
        }
473
        if (s->pict_type == AV_PICTURE_TYPE_B) {
474 475
            put_bits(&s->pb, 4, s->b_code);
            put_bits(&s->pb, 4, s->b_code);
476
        } else {
477 478 479 480
            put_bits(&s->pb, 8, 255);
        }
        put_bits(&s->pb, 2, s->intra_dc_precision);

481
        av_assert0(s->picture_structure == PICT_FRAME);
482
        put_bits(&s->pb, 2, s->picture_structure);
483 484 485
        if (s->progressive_sequence)
            put_bits(&s->pb, 1, 0);             /* no repeat */
        else
486
            put_bits(&s->pb, 1, s->current_picture_ptr->f->top_field_first);
487
        /* XXX: optimize the generation of this flag with entropy measures */
488 489 490 491 492 493 494 495 496
        s->frame_pred_frame_dct = s->progressive_sequence;

        put_bits(&s->pb, 1, s->frame_pred_frame_dct);
        put_bits(&s->pb, 1, s->concealment_motion_vectors);
        put_bits(&s->pb, 1, s->q_scale_type);
        put_bits(&s->pb, 1, s->intra_vlc_format);
        put_bits(&s->pb, 1, s->alternate_scan);
        put_bits(&s->pb, 1, s->repeat_first_field);
        s->progressive_frame = s->progressive_sequence;
497 498 499
        /* chroma_420_type */
        put_bits(&s->pb, 1, s->chroma_format ==
                            CHROMA_420 ? s->progressive_frame : 0);
500
        put_bits(&s->pb, 1, s->progressive_frame);
501
        put_bits(&s->pb, 1, 0);                 /* composite_display_flag */
502
    }
503
    if (s->scan_offset) {
504 505 506
        int i;

        put_header(s, USER_START_CODE);
507
        for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
508 509
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
    }
510
    side_data = av_frame_get_side_data(s->current_picture_ptr->f,
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
                                       AV_FRAME_DATA_STEREO3D);
    if (side_data) {
        AVStereo3D *stereo = (AVStereo3D *)side_data->data;
        uint8_t fpa_type;

        switch (stereo->type) {
        case AV_STEREO3D_SIDEBYSIDE:
            fpa_type = 0x03;
            break;
        case AV_STEREO3D_TOPBOTTOM:
            fpa_type = 0x04;
            break;
        case AV_STEREO3D_2D:
            fpa_type = 0x08;
            break;
        case AV_STEREO3D_SIDEBYSIDE_QUINCUNX:
            fpa_type = 0x23;
            break;
        default:
            fpa_type = 0;
            break;
        }

        if (fpa_type != 0) {
            put_header(s, USER_START_CODE);
            put_bits(&s->pb, 8, 'J');   // S3D_video_format_signaling_identifier
            put_bits(&s->pb, 8, 'P');
            put_bits(&s->pb, 8, '3');
            put_bits(&s->pb, 8, 'D');
            put_bits(&s->pb, 8, 0x03);  // S3D_video_format_length

            put_bits(&s->pb, 1, 1);     // reserved_bit
            put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type
            put_bits(&s->pb, 8, 0x04);  // reserved_data[0]
            put_bits(&s->pb, 8, 0xFF);  // reserved_data[1]
        }
    }
548

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) {
        side_data = av_frame_get_side_data(s->current_picture_ptr->f,
            AV_FRAME_DATA_A53_CC);
        if (side_data) {
            if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) {
                int i = 0;

                put_header (s, USER_START_CODE);

                put_bits(&s->pb, 8, 'G');                   // user_identifier
                put_bits(&s->pb, 8, 'A');
                put_bits(&s->pb, 8, '9');
                put_bits(&s->pb, 8, '4');
                put_bits(&s->pb, 8, 3);                     // user_data_type_code
                put_bits(&s->pb, 8,
                    (side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count
                put_bits(&s->pb, 8, 0xff);                  // em_data

                for (i = 0; i < side_data->size; i++)
                    put_bits(&s->pb, 8, side_data->data[i]);

                put_bits(&s->pb, 8, 0xff);                  // marker_bits
            } else {
                av_log(s->avctx, AV_LOG_WARNING,
                    "Warning Closed Caption size (%d) can not exceed 93 bytes "
                    "and must be a multiple of 3\n", side_data->size);
            }
        }
    }

579
    s->mb_y = 0;
580 581 582 583 584 585 586 587 588
    ff_mpeg1_encode_slice_header(s);
}

static inline void put_mb_modes(MpegEncContext *s, int n, int bits,
                                int has_mv, int field_motion)
{
    put_bits(&s->pb, n, bits);
    if (!s->frame_pred_frame_dct) {
        if (has_mv)
589 590
            /* motion_type: frame/field */
            put_bits(&s->pb, 2, 2 - field_motion);
591 592 593 594
        put_bits(&s->pb, 1, s->interlaced_dct);
    }
}

595 596 597 598 599 600 601 602 603 604 605
// RAL: Parameter added: f_or_b_code
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code)
{
    if (val == 0) {
        /* zero vector */
        put_bits(&s->pb,
                 ff_mpeg12_mbMotionVectorTable[0][1],
                 ff_mpeg12_mbMotionVectorTable[0][0]);
    } else {
        int code, sign, bits;
        int bit_size = f_or_b_code - 1;
606
        int range    = 1 << bit_size;
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
        /* modulo encoding */
        val = sign_extend(val, 5 + bit_size);

        if (val >= 0) {
            val--;
            code = (val >> bit_size) + 1;
            bits = val & (range - 1);
            sign = 0;
        } else {
            val = -val;
            val--;
            code = (val >> bit_size) + 1;
            bits = val & (range - 1);
            sign = 1;
        }

623
        av_assert2(code > 0 && code <= 16);
624 625 626 627 628 629

        put_bits(&s->pb,
                 ff_mpeg12_mbMotionVectorTable[code][1],
                 ff_mpeg12_mbMotionVectorTable[code][0]);

        put_bits(&s->pb, 1, sign);
630
        if (bit_size > 0)
631 632 633 634 635 636
            put_bits(&s->pb, bit_size, bits);
    }
}

static inline void encode_dc(MpegEncContext *s, int diff, int component)
{
637 638
    unsigned int diff_u = diff + 255;
    if (diff_u >= 511) {
639 640
        int index;

641 642
        if (diff < 0) {
            index = av_log2_16bit(-2 * diff);
643
            diff--;
644 645
        } else {
            index = av_log2_16bit(2 * diff);
646
        }
647 648 649 650
        if (component == 0)
            put_bits(&s->pb,
                     ff_mpeg12_vlc_dc_lum_bits[index] + index,
                     (ff_mpeg12_vlc_dc_lum_code[index] << index) +
651
                     av_mod_uintp2(diff, index));
652 653 654 655
        else
            put_bits(&s->pb,
                     ff_mpeg12_vlc_dc_chroma_bits[index] + index,
                     (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
656
                     av_mod_uintp2(diff, index));
657
    } else {
658 659 660 661 662 663 664 665
        if (component == 0)
            put_bits(&s->pb,
                     mpeg1_lum_dc_uni[diff + 255] & 0xFF,
                     mpeg1_lum_dc_uni[diff + 255] >> 8);
        else
            put_bits(&s->pb,
                     mpeg1_chr_dc_uni[diff + 255] & 0xFF,
                     mpeg1_chr_dc_uni[diff + 255] >> 8);
666 667 668
    }
}

669
static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
670 671 672 673 674 675 676 677 678
{
    int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;
    int code, component;
    const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc;

    last_index = s->block_last_index[n];

    /* DC coef */
    if (s->mb_intra) {
679 680 681
        component = (n <= 3 ? 0 : (n & 1) + 1);
        dc        = block[0];                   /* overflow is impossible */
        diff      = dc - s->last_dc[component];
682 683 684 685 686 687
        encode_dc(s, diff, component);
        s->last_dc[component] = dc;
        i = 1;
        if (s->intra_vlc_format)
            table_vlc = ff_rl_mpeg2.table_vlc;
    } else {
688 689
        /* encode the first coefficient: needs to be done here because
         * it is handled slightly differently */
690 691
        level = block[0];
        if (abs(level) == 1) {
692 693 694
            code = ((uint32_t)level >> 31);     /* the sign bit */
            put_bits(&s->pb, 2, code | 0x02);
            i = 1;
695
        } else {
696
            i             = 0;
697 698 699 700 701 702 703 704
            last_non_zero = -1;
            goto next_coef;
        }
    }

    /* now quantify & encode AC coefs */
    last_non_zero = i - 1;

705 706
    for (; i <= last_index; i++) {
        j     = s->intra_scantable.permutated[i];
707
        level = block[j];
708 709

next_coef:
710 711 712 713
        /* encode using VLC */
        if (level != 0) {
            run = i - last_non_zero - 1;

714
            alevel = level;
715
            MASK_ABS(sign, alevel);
716
            sign &= 1;
717

718 719 720 721 722
            if (alevel <= mpeg1_max_level[0][run]) {
                code = mpeg1_index_run[0][run] + alevel - 1;
                /* store the VLC & sign at once */
                put_bits(&s->pb, table_vlc[code][1] + 1,
                         (table_vlc[code][0] << 1) + sign);
723 724 725 726 727
            } else {
                /* escape seems to be pretty rare <5% so I do not optimize it */
                put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]);
                /* escape: only clip in this case */
                put_bits(&s->pb, 6, run);
728
                if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
729 730 731
                    if (alevel < 128) {
                        put_sbits(&s->pb, 8, level);
                    } else {
732
                        if (level < 0)
733
                            put_bits(&s->pb, 16, 0x8001 + level + 255);
734
                        else
735 736
                            put_sbits(&s->pb, 16, level);
                    }
737
                } else {
738 739 740 741 742 743 744 745 746 747
                    put_sbits(&s->pb, 12, level);
                }
            }
            last_non_zero = i;
        }
    }
    /* end of block */
    put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
}

748
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
749
                                                      int16_t block[8][64],
750 751
                                                      int motion_x, int motion_y,
                                                      int mb_block_count)
752 753
{
    int i, cbp;
754 755 756
    const int mb_x     = s->mb_x;
    const int mb_y     = s->mb_y;
    const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y;
757 758 759

    /* compute cbp */
    cbp = 0;
760
    for (i = 0; i < mb_block_count; i++)
761 762 763 764
        if (s->block_last_index[i] >= 0)
            cbp |= 1 << (mb_block_count - 1 - i);

    if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 &&
765
        (mb_x != s->mb_width - 1 ||
766
         (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
767
        ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
768 769 770 771 772 773 774
         (s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir &&
          (((s->mv_dir & MV_DIR_FORWARD)
            ? ((s->mv[0][0][0] - s->last_mv[0][0][0]) |
               (s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) |
           ((s->mv_dir & MV_DIR_BACKWARD)
            ? ((s->mv[1][0][0] - s->last_mv[1][0][0]) |
               (s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) {
775 776 777 778 779
        s->mb_skip_run++;
        s->qscale -= s->dquant;
        s->skip_count++;
        s->misc_bits++;
        s->last_bits++;
780 781 782 783 784
        if (s->pict_type == AV_PICTURE_TYPE_P) {
            s->last_mv[0][0][0] =
            s->last_mv[0][0][1] =
            s->last_mv[0][1][0] =
            s->last_mv[0][1][1] = 0;
785 786
        }
    } else {
787
        if (first_mb) {
788
            av_assert0(s->mb_skip_run == 0);
789
            encode_mb_skip_run(s, s->mb_x);
790
        } else {
791 792 793
            encode_mb_skip_run(s, s->mb_skip_run);
        }

794
        if (s->pict_type == AV_PICTURE_TYPE_I) {
795 796 797
            if (s->dquant && cbp) {
                /* macroblock_type: macroblock_quant = 1 */
                put_mb_modes(s, 2, 1, 0, 0);
798
                put_qscale(s);
799 800 801
            } else {
                /* macroblock_type: macroblock_quant = 0 */
                put_mb_modes(s, 1, 1, 0, 0);
802 803
                s->qscale -= s->dquant;
            }
804
            s->misc_bits += get_bits_diff(s);
805 806
            s->i_count++;
        } else if (s->mb_intra) {
807
            if (s->dquant && cbp) {
808 809
                put_mb_modes(s, 6, 0x01, 0, 0);
                put_qscale(s);
810
            } else {
811 812 813
                put_mb_modes(s, 5, 0x03, 0, 0);
                s->qscale -= s->dquant;
            }
814
            s->misc_bits += get_bits_diff(s);
815 816
            s->i_count++;
            memset(s->last_mv, 0, sizeof(s->last_mv));
817
        } else if (s->pict_type == AV_PICTURE_TYPE_P) {
818
            if (s->mv_type == MV_TYPE_16X16) {
819
                if (cbp != 0) {
820 821 822 823
                    if ((motion_x | motion_y) == 0) {
                        if (s->dquant) {
                            /* macroblock_pattern & quant */
                            put_mb_modes(s, 5, 1, 0, 0);
824
                            put_qscale(s);
825 826 827
                        } else {
                            /* macroblock_pattern only */
                            put_mb_modes(s, 2, 1, 0, 0);
828
                        }
829
                        s->misc_bits += get_bits_diff(s);
830
                    } else {
831 832
                        if (s->dquant) {
                            put_mb_modes(s, 5, 2, 1, 0);    /* motion + cbp */
833
                            put_qscale(s);
834 835
                        } else {
                            put_mb_modes(s, 1, 1, 1, 0);    /* motion + cbp */
836
                        }
837 838 839 840 841 842 843 844 845 846
                        s->misc_bits += get_bits_diff(s);
                        // RAL: f_code parameter added
                        mpeg1_encode_motion(s,
                                            motion_x - s->last_mv[0][0][0],
                                            s->f_code);
                        // RAL: f_code parameter added
                        mpeg1_encode_motion(s,
                                            motion_y - s->last_mv[0][0][1],
                                            s->f_code);
                        s->mv_bits += get_bits_diff(s);
847 848
                    }
                } else {
849
                    put_bits(&s->pb, 3, 1);         /* motion only */
850
                    if (!s->frame_pred_frame_dct)
851 852 853 854 855 856 857 858 859 860 861 862
                        put_bits(&s->pb, 2, 2);     /* motion_type: frame */
                    s->misc_bits += get_bits_diff(s);
                    // RAL: f_code parameter added
                    mpeg1_encode_motion(s,
                                        motion_x - s->last_mv[0][0][0],
                                        s->f_code);
                    // RAL: f_code parameter added
                    mpeg1_encode_motion(s,
                                        motion_y - s->last_mv[0][0][1],
                                        s->f_code);
                    s->qscale  -= s->dquant;
                    s->mv_bits += get_bits_diff(s);
863
                }
864 865 866
                s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x;
                s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y;
            } else {
867
                av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
868 869

                if (cbp) {
870 871
                    if (s->dquant) {
                        put_mb_modes(s, 5, 2, 1, 1);    /* motion + cbp */
872
                        put_qscale(s);
873 874
                    } else {
                        put_mb_modes(s, 1, 1, 1, 1);    /* motion + cbp */
875 876
                    }
                } else {
877 878
                    put_bits(&s->pb, 3, 1);             /* motion only */
                    put_bits(&s->pb, 2, 1);             /* motion_type: field */
879 880
                    s->qscale -= s->dquant;
                }
881 882
                s->misc_bits += get_bits_diff(s);
                for (i = 0; i < 2; i++) {
883
                    put_bits(&s->pb, 1, s->field_select[0][i]);
884 885 886 887 888 889 890 891
                    mpeg1_encode_motion(s,
                                        s->mv[0][i][0] - s->last_mv[0][i][0],
                                        s->f_code);
                    mpeg1_encode_motion(s,
                                        s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
                                        s->f_code);
                    s->last_mv[0][i][0] = s->mv[0][i][0];
                    s->last_mv[0][i][1] = 2 * s->mv[0][i][1];
892
                }
893
                s->mv_bits += get_bits_diff(s);
894
            }
895
            if (cbp) {
896
                if (s->chroma_y_shift) {
897 898 899
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp][1],
                             ff_mpeg12_mbPatTable[cbp][0]);
900
                } else {
901 902 903
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp >> 2][1],
                             ff_mpeg12_mbPatTable[cbp >> 2][0]);
904
                    put_sbits(&s->pb, 2, cbp);
905 906 907
                }
            }
            s->f_count++;
908 909 910
        } else {
            if (s->mv_type == MV_TYPE_16X16) {
                if (cbp) {                      // With coded bloc pattern
911
                    if (s->dquant) {
912
                        if (s->mv_dir == MV_DIR_FORWARD)
913 914
                            put_mb_modes(s, 6, 3, 1, 0);
                        else
915
                            put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
916 917
                        put_qscale(s);
                    } else {
918
                        put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
919
                    }
920 921
                } else {                        // No coded bloc pattern
                    put_bits(&s->pb, 5 - s->mv_dir, 2);
922 923 924 925 926
                    if (!s->frame_pred_frame_dct)
                        put_bits(&s->pb, 2, 2); /* motion_type: frame */
                    s->qscale -= s->dquant;
                }
                s->misc_bits += get_bits_diff(s);
927 928 929 930 931 932 933 934 935 936 937
                if (s->mv_dir & MV_DIR_FORWARD) {
                    mpeg1_encode_motion(s,
                                        s->mv[0][0][0] - s->last_mv[0][0][0],
                                        s->f_code);
                    mpeg1_encode_motion(s,
                                        s->mv[0][0][1] - s->last_mv[0][0][1],
                                        s->f_code);
                    s->last_mv[0][0][0] =
                    s->last_mv[0][1][0] = s->mv[0][0][0];
                    s->last_mv[0][0][1] =
                    s->last_mv[0][1][1] = s->mv[0][0][1];
938 939
                    s->f_count++;
                }
940 941 942 943 944 945 946 947 948 949 950
                if (s->mv_dir & MV_DIR_BACKWARD) {
                    mpeg1_encode_motion(s,
                                        s->mv[1][0][0] - s->last_mv[1][0][0],
                                        s->b_code);
                    mpeg1_encode_motion(s,
                                        s->mv[1][0][1] - s->last_mv[1][0][1],
                                        s->b_code);
                    s->last_mv[1][0][0] =
                    s->last_mv[1][1][0] = s->mv[1][0][0];
                    s->last_mv[1][0][1] =
                    s->last_mv[1][1][1] = s->mv[1][0][1];
951 952
                    s->b_count++;
                }
953
            } else {
954 955
                av_assert2(s->mv_type == MV_TYPE_FIELD);
                av_assert2(!s->frame_pred_frame_dct);
956
                if (cbp) {                      // With coded bloc pattern
957
                    if (s->dquant) {
958
                        if (s->mv_dir == MV_DIR_FORWARD)
959 960
                            put_mb_modes(s, 6, 3, 1, 1);
                        else
961
                            put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
962 963
                        put_qscale(s);
                    } else {
964
                        put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
965
                    }
966 967 968
                } else {                        // No coded bloc pattern
                    put_bits(&s->pb, 5 - s->mv_dir, 2);
                    put_bits(&s->pb, 2, 1);     /* motion_type: field */
969 970 971
                    s->qscale -= s->dquant;
                }
                s->misc_bits += get_bits_diff(s);
972 973
                if (s->mv_dir & MV_DIR_FORWARD) {
                    for (i = 0; i < 2; i++) {
974
                        put_bits(&s->pb, 1, s->field_select[0][i]);
975 976 977 978 979 980 981 982
                        mpeg1_encode_motion(s,
                                            s->mv[0][i][0] - s->last_mv[0][i][0],
                                            s->f_code);
                        mpeg1_encode_motion(s,
                                            s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1),
                                            s->f_code);
                        s->last_mv[0][i][0] = s->mv[0][i][0];
                        s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
983 984 985
                    }
                    s->f_count++;
                }
986 987
                if (s->mv_dir & MV_DIR_BACKWARD) {
                    for (i = 0; i < 2; i++) {
988
                        put_bits(&s->pb, 1, s->field_select[1][i]);
989 990 991 992 993 994 995 996
                        mpeg1_encode_motion(s,
                                            s->mv[1][i][0] - s->last_mv[1][i][0],
                                            s->b_code);
                        mpeg1_encode_motion(s,
                                            s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1),
                                            s->b_code);
                        s->last_mv[1][i][0] = s->mv[1][i][0];
                        s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
997 998 999 1000 1001
                    }
                    s->b_count++;
                }
            }
            s->mv_bits += get_bits_diff(s);
1002
            if (cbp) {
1003
                if (s->chroma_y_shift) {
1004 1005 1006
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp][1],
                             ff_mpeg12_mbPatTable[cbp][0]);
1007
                } else {
1008 1009 1010
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp >> 2][1],
                             ff_mpeg12_mbPatTable[cbp >> 2][0]);
1011
                    put_sbits(&s->pb, 2, cbp);
1012 1013 1014
                }
            }
        }
1015 1016
        for (i = 0; i < mb_block_count; i++)
            if (cbp & (1 << (mb_block_count - 1 - i)))
1017 1018
                mpeg1_encode_block(s, block[i], i);
        s->mb_skip_run = 0;
1019 1020
        if (s->mb_intra)
            s->i_tex_bits += get_bits_diff(s);
1021
        else
1022
            s->p_tex_bits += get_bits_diff(s);
1023 1024 1025
    }
}

1026
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
1027
                        int motion_x, int motion_y)
1028
{
1029 1030 1031 1032
    if (s->chroma_format == CHROMA_420)
        mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6);
    else
        mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8);
1033 1034
}

1035
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
1036
{
1037
    static int done = 0;
1038

1039
    ff_mpeg12_common_init(s);
1040

1041
    if (!done) {
1042 1043 1044 1045
        int f_code;
        int mv;
        int i;

1046
        done = 1;
1047 1048
        ff_rl_init(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
        ff_rl_init(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
1049

1050 1051 1052
        for (i = 0; i < 64; i++) {
            mpeg1_max_level[0][i] = ff_rl_mpeg1.max_level[0][i];
            mpeg1_index_run[0][i] = ff_rl_mpeg1.index_run[0][i];
1053 1054
        }

1055
        init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len);
1056
        if (s->intra_vlc_format)
1057
            init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len);
1058 1059

        /* build unified dc encoding tables */
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
        for (i = -255; i < 256; i++) {
            int adiff, index;
            int bits, code;
            int diff = i;

            adiff = FFABS(diff);
            if (diff < 0)
                diff--;
            index = av_log2(2 * adiff);

            bits = ff_mpeg12_vlc_dc_lum_bits[index] + index;
            code = (ff_mpeg12_vlc_dc_lum_code[index] << index) +
1072
                    av_mod_uintp2(diff, index);
1073 1074 1075 1076
            mpeg1_lum_dc_uni[i + 255] = bits + (code << 8);

            bits = ff_mpeg12_vlc_dc_chroma_bits[index] + index;
            code = (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
1077
                    av_mod_uintp2(diff, index);
1078
            mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1079 1080
        }

1081
        for (f_code = 1; f_code <= MAX_FCODE; f_code++)
1082
            for (mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1083 1084
                int len;

1085 1086 1087
                if (mv == 0) {
                    len = ff_mpeg12_mbMotionVectorTable[0][1];
                } else {
Mans Rullgard's avatar
Mans Rullgard committed
1088
                    int val, bit_size, code;
1089 1090 1091

                    bit_size = f_code - 1;

1092
                    val = mv;
1093 1094 1095 1096
                    if (val < 0)
                        val = -val;
                    val--;
                    code = (val >> bit_size) + 1;
1097 1098 1099 1100 1101 1102
                    if (code < 17)
                        len = ff_mpeg12_mbMotionVectorTable[code][1] +
                              1 + bit_size;
                    else
                        len = ff_mpeg12_mbMotionVectorTable[16][1] +
                              2 + bit_size;
1103 1104
                }

1105
                mv_penalty[f_code][mv + MAX_DMV] = len;
1106 1107 1108
            }


1109 1110 1111
        for (f_code = MAX_FCODE; f_code > 0; f_code--)
            for (mv = -(8 << f_code); mv < (8 << f_code); mv++)
                fcode_tab[mv + MAX_MV] = f_code;
1112
    }
1113 1114 1115 1116 1117 1118 1119 1120
    s->me.mv_penalty = mv_penalty;
    s->fcode_tab     = fcode_tab;
    if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
        s->min_qcoeff = -255;
        s->max_qcoeff = 255;
    } else {
        s->min_qcoeff = -2047;
        s->max_qcoeff = 2047;
1121 1122
    }
    if (s->intra_vlc_format) {
1123 1124
        s->intra_ac_vlc_length      =
        s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1125
    } else {
1126 1127
        s->intra_ac_vlc_length      =
        s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1128
    }
1129 1130
    s->inter_ac_vlc_length      =
    s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1131 1132
}

1133 1134
#define OFFSET(x) offsetof(MpegEncContext, x)
#define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1135
#define COMMON_OPTS                                                           \
1136
    { "gop_timecode",        "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.",   \
1137
      OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, VE },\
1138
    { "intra_vlc",           "Use MPEG-2 intra VLC table.",                   \
1139
      OFFSET(intra_vlc_format),    AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1140
    { "drop_frame_timecode", "Timecode is in drop frame format.",             \
1141
      OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1142
    { "scan_offset",         "Reserve space for SVCD scan offset user data.", \
1143
      OFFSET(scan_offset),         AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1144
    { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1145
      OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1146 1147 1148

static const AVOption mpeg1_options[] = {
    COMMON_OPTS
1149
    FF_MPV_COMMON_OPTS
1150 1151 1152 1153 1154
    { NULL },
};

static const AVOption mpeg2_options[] = {
    COMMON_OPTS
1155 1156
    { "non_linear_quant", "Use nonlinear quantizer.",    OFFSET(q_scale_type),   AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
    { "alternate_scan",   "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1157 1158 1159 1160
    { "seq_disp_ext",     "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" },
    {     "auto",   NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = -1},  0, 0, VE, "seq_disp_ext" },
    {     "never",  NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = 0 },  0, 0, VE, "seq_disp_ext" },
    {     "always", NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = 1 },  0, 0, VE, "seq_disp_ext" },
1161 1162 1163 1164 1165 1166 1167
    { "video_format",     "Video_format in the sequence_display_extension indicating the source of the video.", OFFSET(video_format), AV_OPT_TYPE_INT, { .i64 = VIDEO_FORMAT_UNSPECIFIED }, 0, 7, VE, "video_format" },
    {     "component",    NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = VIDEO_FORMAT_COMPONENT  },  0, 0, VE, "video_format" },
    {     "pal",          NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = VIDEO_FORMAT_PAL        },  0, 0, VE, "video_format" },
    {     "ntsc",         NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = VIDEO_FORMAT_NTSC       },  0, 0, VE, "video_format" },
    {     "secam",        NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = VIDEO_FORMAT_SECAM      },  0, 0, VE, "video_format" },
    {     "mac",          NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = VIDEO_FORMAT_MAC        },  0, 0, VE, "video_format" },
    {     "unspecified",  NULL, 0, AV_OPT_TYPE_CONST,  {.i64 = VIDEO_FORMAT_UNSPECIFIED},  0, 0, VE, "video_format" },
1168
    FF_MPV_COMMON_OPTS
1169
    { NULL },
1170 1171
};

1172 1173 1174 1175 1176 1177
#define mpeg12_class(x)                                 \
static const AVClass mpeg ## x ## _class = {            \
    .class_name = "mpeg" # x "video encoder",           \
    .item_name  = av_default_item_name,                 \
    .option     = mpeg ## x ## _options,                \
    .version    = LIBAVUTIL_VERSION_INT,                \
1178 1179 1180 1181 1182
};

mpeg12_class(1)
mpeg12_class(2)

1183
AVCodec ff_mpeg1video_encoder = {
1184
    .name                 = "mpeg1video",
1185
    .long_name            = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1186
    .type                 = AVMEDIA_TYPE_VIDEO,
1187
    .id                   = AV_CODEC_ID_MPEG1VIDEO,
1188 1189
    .priv_data_size       = sizeof(MpegEncContext),
    .init                 = encode_init,
1190 1191
    .encode2              = ff_mpv_encode_picture,
    .close                = ff_mpv_encode_end,
1192
    .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1193 1194
    .pix_fmts             = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                           AV_PIX_FMT_NONE },
1195
    .capabilities         = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
1196
    .priv_class           = &mpeg1_class,
1197 1198
};

1199
AVCodec ff_mpeg2video_encoder = {
1200
    .name                 = "mpeg2video",
1201
    .long_name            = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1202
    .type                 = AVMEDIA_TYPE_VIDEO,
1203
    .id                   = AV_CODEC_ID_MPEG2VIDEO,
1204 1205
    .priv_data_size       = sizeof(MpegEncContext),
    .init                 = encode_init,
1206 1207
    .encode2              = ff_mpv_encode_picture,
    .close                = ff_mpv_encode_end,
1208
    .supported_framerates = ff_mpeg2_frame_rate_tab,
1209 1210 1211
    .pix_fmts             = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                           AV_PIX_FMT_YUV422P,
                                                           AV_PIX_FMT_NONE },
1212
    .capabilities         = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
1213
    .priv_class           = &mpeg2_class,
1214
};