mpeg12enc.c 44.7 KB
Newer Older
1 2
/*
 * MPEG1/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 26 27
 * MPEG1/2 encoder
 */

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
static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
{
66 67
    int i;

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

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

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

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

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

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

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

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

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

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

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

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

142
    if (ff_mpv_encode_init(avctx) < 0)
143 144
        return -1;

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

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

166 167 168 169 170 171 172 173 174 175
    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");
176 177
                return -1;
            }
178 179 180 181 182 183
            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 */
184 185 186
        }
    }

187 188 189 190 191 192 193
    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) {
194
            av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
195 196 197 198 199
                                        "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
            return AVERROR(EINVAL);
        }
    }

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

209 210 211 212 213 214 215
#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

216
    if (s->tc_opt_str) {
217
        AVRational rate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
218 219 220 221
        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);
222
        s->timecode_frame_start = s->tc.start;
223
    } else {
224
        s->timecode_frame_start = 0; // default is -1
225
    }
226

227 228 229 230 231
    return 0;
}

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

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

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

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

252 253
        /* mpeg1 header repeated every gop */
        put_header(s, SEQ_START_CODE);
254

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

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

265
            error = FFABS(error);
266

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

273 274
        put_bits(&s->pb, 4, s->aspect_ratio_info);
        put_bits(&s->pb, 4, s->frame_rate_index);
275

276 277 278 279 280 281 282
        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;
        }
283

284 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
        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) {
314 315 316 317 318
            AVFrameSideData *side_data;
            int width = s->width;
            int height = s->height;
            int use_seq_disp_ext;

319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
            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);
335 336
            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
337

338 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 ||
                                s->avctx->colorspace != AVCOL_SPC_UNSPECIFIED);

353
            if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
354 355 356 357 358 359 360
                put_header(s, EXT_START_CODE);
                put_bits(&s->pb, 4, 2);                         // sequence display extension
                put_bits(&s->pb, 3, 0);                         // video_format: 0 is components
                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
361
                put_bits(&s->pb, 14, width);                    // display_horizontal_size
362
                put_bits(&s->pb, 1, 1);                         // marker_bit
363
                put_bits(&s->pb, 14, height);                   // display_vertical_size
364 365
                put_bits(&s->pb, 3, 0);                         // remaining 3 bits are zero padding
            }
366 367
        }

368 369 370 371 372
        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;
373
        time_code = s->current_picture_ptr->f->coded_picture_number +
374
                    s->timecode_frame_start;
375

376
        s->gop_picture_number = s->current_picture_ptr->f->coded_picture_number;
377 378 379 380 381

        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);

382 383 384 385 386
        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)));
387
        put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) || s->intra_only || !s->gop_picture_number);
388 389
        put_bits(&s->pb, 1, 0);                     // broken link
    }
390 391
}

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

static av_always_inline void put_qscale(MpegEncContext *s)
{
404
    put_bits(&s->pb, 5, s->qscale);
405 406
}

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

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

    /* mpeg1 picture header */
    put_header(s, PICTURE_START_CODE);
    /* temporal reference */

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

435 436
    s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8;
    put_bits(&s->pb, 16, 0xFFFF);               /* vbv_delay */
437

438 439 440 441 442 443
    // 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 */
444
        else
445
            put_bits(&s->pb, 3, 7);             /* forward_f_code */
446 447
    }

448
    // RAL: Backward f_code necessary for B-frames
449
    if (s->pict_type == AV_PICTURE_TYPE_B) {
450 451 452
        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 */
453
        else
454
            put_bits(&s->pb, 3, 7);             /* backward_f_code */
455 456
    }

457
    put_bits(&s->pb, 1, 0);                     /* extra bit picture */
458 459

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

478
        av_assert0(s->picture_structure == PICT_FRAME);
479
        put_bits(&s->pb, 2, s->picture_structure);
480 481 482
        if (s->progressive_sequence)
            put_bits(&s->pb, 1, 0);             /* no repeat */
        else
483
            put_bits(&s->pb, 1, s->current_picture_ptr->f->top_field_first);
484
        /* XXX: optimize the generation of this flag with entropy measures */
485 486 487 488 489 490 491 492 493
        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;
494 495 496
        /* chroma_420_type */
        put_bits(&s->pb, 1, s->chroma_format ==
                            CHROMA_420 ? s->progressive_frame : 0);
497
        put_bits(&s->pb, 1, s->progressive_frame);
498
        put_bits(&s->pb, 1, 0);                 /* composite_display_flag */
499
    }
500
    if (s->scan_offset) {
501 502 503
        int i;

        put_header(s, USER_START_CODE);
504
        for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
505 506
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
    }
507
    side_data = av_frame_get_side_data(s->current_picture_ptr->f,
508 509 510 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
                                       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]
        }
    }
545

546
    s->mb_y = 0;
547 548 549 550 551 552 553 554 555
    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)
556 557
            /* motion_type: frame/field */
            put_bits(&s->pb, 2, 2 - field_motion);
558 559 560 561
        put_bits(&s->pb, 1, s->interlaced_dct);
    }
}

562 563 564 565 566 567 568 569 570 571 572
// 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;
573
        int range    = 1 << bit_size;
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
        /* 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;
        }

590
        av_assert2(code > 0 && code <= 16);
591 592 593 594 595 596

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

        put_bits(&s->pb, 1, sign);
597
        if (bit_size > 0)
598 599 600 601 602 603
            put_bits(&s->pb, bit_size, bits);
    }
}

static inline void encode_dc(MpegEncContext *s, int diff, int component)
{
604 605
    unsigned int diff_u = diff + 255;
    if (diff_u >= 511) {
606 607
        int index;

608 609
        if (diff < 0) {
            index = av_log2_16bit(-2 * diff);
610
            diff--;
611 612
        } else {
            index = av_log2_16bit(2 * diff);
613
        }
614 615 616 617
        if (component == 0)
            put_bits(&s->pb,
                     ff_mpeg12_vlc_dc_lum_bits[index] + index,
                     (ff_mpeg12_vlc_dc_lum_code[index] << index) +
618
                     av_mod_uintp2(diff, index));
619 620 621 622
        else
            put_bits(&s->pb,
                     ff_mpeg12_vlc_dc_chroma_bits[index] + index,
                     (ff_mpeg12_vlc_dc_chroma_code[index] << index) +
623
                     av_mod_uintp2(diff, index));
624
    } else {
625 626 627 628 629 630 631 632
        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);
633 634 635
    }
}

636
static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n)
637 638 639 640 641 642 643 644 645
{
    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) {
646 647 648
        component = (n <= 3 ? 0 : (n & 1) + 1);
        dc        = block[0];                   /* overflow is impossible */
        diff      = dc - s->last_dc[component];
649 650 651 652 653 654
        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 {
655 656
        /* encode the first coefficient: needs to be done here because
         * it is handled slightly differently */
657 658
        level = block[0];
        if (abs(level) == 1) {
659 660 661
            code = ((uint32_t)level >> 31);     /* the sign bit */
            put_bits(&s->pb, 2, code | 0x02);
            i = 1;
662
        } else {
663
            i             = 0;
664 665 666 667 668 669 670 671
            last_non_zero = -1;
            goto next_coef;
        }
    }

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

672 673
    for (; i <= last_index; i++) {
        j     = s->intra_scantable.permutated[i];
674
        level = block[j];
675 676

next_coef:
677 678 679 680
        /* encode using VLC */
        if (level != 0) {
            run = i - last_non_zero - 1;

681
            alevel = level;
682
            MASK_ABS(sign, alevel);
683
            sign &= 1;
684

685 686 687 688 689
            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);
690 691 692 693 694
            } 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);
695
                if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
696 697 698
                    if (alevel < 128) {
                        put_sbits(&s->pb, 8, level);
                    } else {
699
                        if (level < 0)
700
                            put_bits(&s->pb, 16, 0x8001 + level + 255);
701
                        else
702 703
                            put_sbits(&s->pb, 16, level);
                    }
704
                } else {
705 706 707 708 709 710 711 712 713 714
                    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]);
}

715
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
716
                                                      int16_t block[8][64],
717 718
                                                      int motion_x, int motion_y,
                                                      int mb_block_count)
719 720
{
    int i, cbp;
721 722 723
    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;
724 725 726

    /* compute cbp */
    cbp = 0;
727
    for (i = 0; i < mb_block_count; i++)
728 729 730 731
        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 &&
732
        (mb_x != s->mb_width - 1 ||
733
         (mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) &&
734
        ((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) ||
735 736 737 738 739 740 741
         (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))) {
742 743 744 745 746
        s->mb_skip_run++;
        s->qscale -= s->dquant;
        s->skip_count++;
        s->misc_bits++;
        s->last_bits++;
747 748 749 750 751
        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;
752 753
        }
    } else {
754
        if (first_mb) {
755
            av_assert0(s->mb_skip_run == 0);
756
            encode_mb_skip_run(s, s->mb_x);
757
        } else {
758 759 760
            encode_mb_skip_run(s, s->mb_skip_run);
        }

761
        if (s->pict_type == AV_PICTURE_TYPE_I) {
762 763 764
            if (s->dquant && cbp) {
                /* macroblock_type: macroblock_quant = 1 */
                put_mb_modes(s, 2, 1, 0, 0);
765
                put_qscale(s);
766 767 768
            } else {
                /* macroblock_type: macroblock_quant = 0 */
                put_mb_modes(s, 1, 1, 0, 0);
769 770
                s->qscale -= s->dquant;
            }
771
            s->misc_bits += get_bits_diff(s);
772 773
            s->i_count++;
        } else if (s->mb_intra) {
774
            if (s->dquant && cbp) {
775 776
                put_mb_modes(s, 6, 0x01, 0, 0);
                put_qscale(s);
777
            } else {
778 779 780
                put_mb_modes(s, 5, 0x03, 0, 0);
                s->qscale -= s->dquant;
            }
781
            s->misc_bits += get_bits_diff(s);
782 783
            s->i_count++;
            memset(s->last_mv, 0, sizeof(s->last_mv));
784
        } else if (s->pict_type == AV_PICTURE_TYPE_P) {
785
            if (s->mv_type == MV_TYPE_16X16) {
786
                if (cbp != 0) {
787 788 789 790
                    if ((motion_x | motion_y) == 0) {
                        if (s->dquant) {
                            /* macroblock_pattern & quant */
                            put_mb_modes(s, 5, 1, 0, 0);
791
                            put_qscale(s);
792 793 794
                        } else {
                            /* macroblock_pattern only */
                            put_mb_modes(s, 2, 1, 0, 0);
795
                        }
796
                        s->misc_bits += get_bits_diff(s);
797
                    } else {
798 799
                        if (s->dquant) {
                            put_mb_modes(s, 5, 2, 1, 0);    /* motion + cbp */
800
                            put_qscale(s);
801 802
                        } else {
                            put_mb_modes(s, 1, 1, 1, 0);    /* motion + cbp */
803
                        }
804 805 806 807 808 809 810 811 812 813
                        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);
814 815
                    }
                } else {
816
                    put_bits(&s->pb, 3, 1);         /* motion only */
817
                    if (!s->frame_pred_frame_dct)
818 819 820 821 822 823 824 825 826 827 828 829
                        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);
830
                }
831 832 833
                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 {
834
                av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD);
835 836

                if (cbp) {
837 838
                    if (s->dquant) {
                        put_mb_modes(s, 5, 2, 1, 1);    /* motion + cbp */
839
                        put_qscale(s);
840 841
                    } else {
                        put_mb_modes(s, 1, 1, 1, 1);    /* motion + cbp */
842 843
                    }
                } else {
844 845
                    put_bits(&s->pb, 3, 1);             /* motion only */
                    put_bits(&s->pb, 2, 1);             /* motion_type: field */
846 847
                    s->qscale -= s->dquant;
                }
848 849
                s->misc_bits += get_bits_diff(s);
                for (i = 0; i < 2; i++) {
850
                    put_bits(&s->pb, 1, s->field_select[0][i]);
851 852 853 854 855 856 857 858
                    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];
859
                }
860
                s->mv_bits += get_bits_diff(s);
861
            }
862
            if (cbp) {
863
                if (s->chroma_y_shift) {
864 865 866
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp][1],
                             ff_mpeg12_mbPatTable[cbp][0]);
867
                } else {
868 869 870
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp >> 2][1],
                             ff_mpeg12_mbPatTable[cbp >> 2][0]);
871
                    put_sbits(&s->pb, 2, cbp);
872 873 874
                }
            }
            s->f_count++;
875 876 877
        } else {
            if (s->mv_type == MV_TYPE_16X16) {
                if (cbp) {                      // With coded bloc pattern
878
                    if (s->dquant) {
879
                        if (s->mv_dir == MV_DIR_FORWARD)
880 881
                            put_mb_modes(s, 6, 3, 1, 0);
                        else
882
                            put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0);
883 884
                        put_qscale(s);
                    } else {
885
                        put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0);
886
                    }
887 888
                } else {                        // No coded bloc pattern
                    put_bits(&s->pb, 5 - s->mv_dir, 2);
889 890 891 892 893
                    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);
894 895 896 897 898 899 900 901 902 903 904
                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];
905 906
                    s->f_count++;
                }
907 908 909 910 911 912 913 914 915 916 917
                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];
918 919
                    s->b_count++;
                }
920
            } else {
921 922
                av_assert2(s->mv_type == MV_TYPE_FIELD);
                av_assert2(!s->frame_pred_frame_dct);
923
                if (cbp) {                      // With coded bloc pattern
924
                    if (s->dquant) {
925
                        if (s->mv_dir == MV_DIR_FORWARD)
926 927
                            put_mb_modes(s, 6, 3, 1, 1);
                        else
928
                            put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1);
929 930
                        put_qscale(s);
                    } else {
931
                        put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1);
932
                    }
933 934 935
                } else {                        // No coded bloc pattern
                    put_bits(&s->pb, 5 - s->mv_dir, 2);
                    put_bits(&s->pb, 2, 1);     /* motion_type: field */
936 937 938
                    s->qscale -= s->dquant;
                }
                s->misc_bits += get_bits_diff(s);
939 940
                if (s->mv_dir & MV_DIR_FORWARD) {
                    for (i = 0; i < 2; i++) {
941
                        put_bits(&s->pb, 1, s->field_select[0][i]);
942 943 944 945 946 947 948 949
                        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;
950 951 952
                    }
                    s->f_count++;
                }
953 954
                if (s->mv_dir & MV_DIR_BACKWARD) {
                    for (i = 0; i < 2; i++) {
955
                        put_bits(&s->pb, 1, s->field_select[1][i]);
956 957 958 959 960 961 962 963
                        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;
964 965 966 967 968
                    }
                    s->b_count++;
                }
            }
            s->mv_bits += get_bits_diff(s);
969
            if (cbp) {
970
                if (s->chroma_y_shift) {
971 972 973
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp][1],
                             ff_mpeg12_mbPatTable[cbp][0]);
974
                } else {
975 976 977
                    put_bits(&s->pb,
                             ff_mpeg12_mbPatTable[cbp >> 2][1],
                             ff_mpeg12_mbPatTable[cbp >> 2][0]);
978
                    put_sbits(&s->pb, 2, cbp);
979 980 981
                }
            }
        }
982 983
        for (i = 0; i < mb_block_count; i++)
            if (cbp & (1 << (mb_block_count - 1 - i)))
984 985
                mpeg1_encode_block(s, block[i], i);
        s->mb_skip_run = 0;
986 987
        if (s->mb_intra)
            s->i_tex_bits += get_bits_diff(s);
988
        else
989
            s->p_tex_bits += get_bits_diff(s);
990 991 992
    }
}

993
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
994
                        int motion_x, int motion_y)
995
{
996 997 998 999
    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);
1000 1001
}

1002
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
1003
{
1004
    static int done = 0;
1005

1006
    ff_mpeg12_common_init(s);
1007

1008
    if (!done) {
1009 1010 1011 1012
        int f_code;
        int mv;
        int i;

1013
        done = 1;
1014 1015
        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]);
1016

1017 1018 1019
        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];
1020 1021
        }

1022
        init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len);
1023
        if (s->intra_vlc_format)
1024
            init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len);
1025 1026

        /* build unified dc encoding tables */
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
        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) +
1039
                    av_mod_uintp2(diff, index);
1040 1041 1042 1043
            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) +
1044
                    av_mod_uintp2(diff, index);
1045
            mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1046 1047
        }

1048
        for (f_code = 1; f_code <= MAX_FCODE; f_code++)
1049
            for (mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
1050 1051
                int len;

1052 1053 1054
                if (mv == 0) {
                    len = ff_mpeg12_mbMotionVectorTable[0][1];
                } else {
Mans Rullgard's avatar
Mans Rullgard committed
1055
                    int val, bit_size, code;
1056 1057 1058

                    bit_size = f_code - 1;

1059
                    val = mv;
1060 1061 1062 1063
                    if (val < 0)
                        val = -val;
                    val--;
                    code = (val >> bit_size) + 1;
1064 1065 1066 1067 1068 1069
                    if (code < 17)
                        len = ff_mpeg12_mbMotionVectorTable[code][1] +
                              1 + bit_size;
                    else
                        len = ff_mpeg12_mbMotionVectorTable[16][1] +
                              2 + bit_size;
1070 1071
                }

1072
                mv_penalty[f_code][mv + MAX_DMV] = len;
1073 1074 1075
            }


1076 1077 1078
        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;
1079
    }
1080 1081 1082 1083 1084 1085 1086 1087
    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;
1088 1089
    }
    if (s->intra_vlc_format) {
1090 1091
        s->intra_ac_vlc_length      =
        s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1092
    } else {
1093 1094
        s->intra_ac_vlc_length      =
        s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1095
    }
1096 1097
    s->inter_ac_vlc_length      =
    s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1098 1099
}

1100 1101
#define OFFSET(x) offsetof(MpegEncContext, x)
#define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1102
#define COMMON_OPTS                                                           \
1103
    { "gop_timecode",        "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.",   \
1104
      OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, VE },\
1105
    { "intra_vlc",           "Use MPEG-2 intra VLC table.",                   \
1106
      OFFSET(intra_vlc_format),    AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1107
    { "drop_frame_timecode", "Timecode is in drop frame format.",             \
1108
      OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1109
    { "scan_offset",         "Reserve space for SVCD scan offset user data.", \
1110
      OFFSET(scan_offset),         AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \
1111
    { "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \
1112
      OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \
1113 1114 1115

static const AVOption mpeg1_options[] = {
    COMMON_OPTS
1116
    FF_MPV_COMMON_OPTS
1117 1118 1119 1120 1121
    { NULL },
};

static const AVOption mpeg2_options[] = {
    COMMON_OPTS
1122 1123
    { "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 },
1124 1125 1126 1127
    { "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" },
1128
    FF_MPV_COMMON_OPTS
1129
    { NULL },
1130 1131
};

1132 1133 1134 1135 1136 1137
#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,                \
1138 1139 1140 1141 1142
};

mpeg12_class(1)
mpeg12_class(2)

1143
AVCodec ff_mpeg1video_encoder = {
1144
    .name                 = "mpeg1video",
1145
    .long_name            = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
1146
    .type                 = AVMEDIA_TYPE_VIDEO,
1147
    .id                   = AV_CODEC_ID_MPEG1VIDEO,
1148 1149
    .priv_data_size       = sizeof(MpegEncContext),
    .init                 = encode_init,
1150 1151
    .encode2              = ff_mpv_encode_picture,
    .close                = ff_mpv_encode_end,
1152
    .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
1153 1154
    .pix_fmts             = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                           AV_PIX_FMT_NONE },
1155
    .capabilities         = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
1156
    .priv_class           = &mpeg1_class,
1157 1158
};

1159
AVCodec ff_mpeg2video_encoder = {
1160
    .name                 = "mpeg2video",
1161
    .long_name            = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1162
    .type                 = AVMEDIA_TYPE_VIDEO,
1163
    .id                   = AV_CODEC_ID_MPEG2VIDEO,
1164 1165
    .priv_data_size       = sizeof(MpegEncContext),
    .init                 = encode_init,
1166 1167
    .encode2              = ff_mpv_encode_picture,
    .close                = ff_mpv_encode_end,
1168
    .supported_framerates = ff_mpeg2_frame_rate_tab,
1169 1170 1171
    .pix_fmts             = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                           AV_PIX_FMT_YUV422P,
                                                           AV_PIX_FMT_NONE },
1172
    .capabilities         = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
1173
    .priv_class           = &mpeg2_class,
1174
};