mpeg12enc.c 44.8 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
static const int8_t inv_non_linear_qscale[] = {
46
    0, 2, 4, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16,
47 48
   -1,17,-1,18,-1,19, -1, 20, -1, 21, -1, 22, -1,
   23,-1,24,-1,-1,-1
49 50
};

51 52 53
static const uint8_t svcd_scan_offset_placeholder[] = {
    0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80,
    0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
54 55
};

56 57
static uint8_t mv_penalty[MAX_FCODE + 1][MAX_MV * 2 + 1];
static uint8_t fcode_tab[MAX_MV * 2 + 1];
58

59 60
static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2];
static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2];
61

62 63
/* simple include everything table for dc, first byte is bits
 * number next 3 are code */
64 65 66 67
static uint32_t mpeg1_lum_dc_uni[512];
static uint32_t mpeg1_chr_dc_uni[512];

static uint8_t mpeg1_index_run[2][64];
68
static int8_t  mpeg1_max_level[2][64];
69

70 71
static av_cold void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len)
{
72 73
    int i;

74 75
    for (i = 0; i < 128; i++) {
        int level = i - 64;
76
        int run;
77 78
        if (!level)
            continue;
79
        for (run = 0; run < 64; run++) {
80
            int len, code;
81
            int alevel = FFABS(level);
82 83

            if (alevel > rl->max_level[0][run])
84
                code = 111;                         /* rl->n */
85
            else
86
                code = rl->index_run[0][run] + alevel - 1;
87

88 89 90
            if (code < 111) {                       /* rl->n */
                /* length of VLC and sign */
                len = rl->table_vlc[code][1] + 1;
91
            } else {
92
                len = rl->table_vlc[111 /* rl->n */][1] + 6;
93

94
                if (alevel < 128)
95
                    len += 8;
96
                else
97
                    len += 16;
98 99
            }

100
            uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
101 102 103 104
        }
    }
}

105 106
static int find_frame_rate_index(MpegEncContext *s)
{
107
    int i;
108
    AVRational bestq = (AVRational) {0, 0};
109 110
    AVRational ext;
    AVRational target = av_inv_q(s->avctx->time_base);
111

112 113 114 115
    for (i = 1; i < 14; i++) {
        if (s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&
            i >= 9)
            break;
116

117 118
        for (ext.num=1; ext.num <= 4; ext.num++) {
            for (ext.den=1; ext.den <= 32; ext.den++) {
119
                AVRational q = av_mul_q(ext, ff_mpeg12_frame_rate_tab[i]);
120

121
                if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1))
122
                    continue;
123
                if (av_gcd(ext.den, ext.num) != 1)
124 125
                    continue;

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

138
    if (av_cmp_q(target, bestq))
139 140 141 142 143
        return -1;
    else
        return 0;
}

144
static av_cold int encode_init(AVCodecContext *avctx)
145 146 147
{
    MpegEncContext *s = avctx->priv_data;

148 149 150
    if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && avctx->height > 2800)
        avctx->thread_count = 1;

151
    if (ff_mpv_encode_init(avctx) < 0)
152 153
        return -1;

154 155 156 157
    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);
158
            return -1;
159 160 161 162
        } 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);
163 164 165
        }
    }

166 167
    if (avctx->profile == FF_PROFILE_UNKNOWN) {
        if (avctx->level != FF_LEVEL_UNKNOWN) {
168 169 170
            av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
            return -1;
        }
171 172
        /* Main or 4:2:2 */
        avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0;
173 174
    }

175 176 177 178 179 180 181 182 183 184
    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");
185 186
                return -1;
            }
187 188 189 190 191 192
            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 */
193 194 195
        }
    }

196 197 198 199 200 201 202
    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) {
203
            av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n"
204 205 206 207 208
                                        "add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL);
            return AVERROR(EINVAL);
        }
    }

209
    s->drop_frame_timecode = s->drop_frame_timecode || !!(avctx->flags2 & AV_CODEC_FLAG2_DROP_FRAME_TIMECODE);
210 211
    if (s->drop_frame_timecode)
        s->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME;
212
    if (s->drop_frame_timecode && s->frame_rate_index != 4) {
213 214
        av_log(avctx, AV_LOG_ERROR,
               "Drop frame time code only allowed with 1001/30000 fps\n");
215 216 217
        return -1;
    }

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->avctx->timecode_frame_start = s->tc.start;
225 226
    } else {
        s->avctx->timecode_frame_start = 0; // default is -1
227
    }
228 229 230 231 232
    return 0;
}

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

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

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

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

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

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

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

266
            error = FFABS(error);
267

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

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

277 278 279 280 281 282 283
        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;
        }
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 314
        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) {
315 316 317 318 319
            AVFrameSideData *side_data;
            int width = s->width;
            int height = s->height;
            int use_seq_disp_ext;

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

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
            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);

354
            if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) {
355 356 357 358 359 360 361
                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
362
                put_bits(&s->pb, 14, width);                    // display_horizontal_size
363
                put_bits(&s->pb, 1, 1);                         // marker_bit
364
                put_bits(&s->pb, 14, height);                   // display_vertical_size
365 366
                put_bits(&s->pb, 3, 0);                         // remaining 3 bits are zero padding
            }
367 368
        }

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

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

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

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

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

static av_always_inline void put_qscale(MpegEncContext *s)
{
405
    if (s->q_scale_type) {
406 407 408
        int qp = inv_non_linear_qscale[s->qscale];
        av_assert2(s->qscale >= 1 && qp > 0);
        put_bits(&s->pb, 5, qp);
409
    } else {
410 411 412 413
        put_bits(&s->pb, 5, s->qscale);
    }
}

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

428
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number)
429
{
430
    AVFrameSideData *side_data;
431 432 433 434 435 436 437
    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
438 439
    put_bits(&s->pb, 10,
             (s->picture_number - s->gop_picture_number) & 0x3ff);
440 441
    put_bits(&s->pb, 3, s->pict_type);

442 443
    s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8;
    put_bits(&s->pb, 16, 0xFFFF);               /* vbv_delay */
444

445 446 447 448 449 450
    // 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 */
451
        else
452
            put_bits(&s->pb, 3, 7);             /* forward_f_code */
453 454
    }

455
    // RAL: Backward f_code necessary for B-frames
456
    if (s->pict_type == AV_PICTURE_TYPE_B) {
457 458 459
        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 */
460
        else
461
            put_bits(&s->pb, 3, 7);             /* backward_f_code */
462 463
    }

464
    put_bits(&s->pb, 1, 0);                     /* extra bit picture */
465 466

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

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

        put_header(s, USER_START_CODE);
511
        for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++)
512 513
            put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]);
    }
514
    side_data = av_frame_get_side_data(s->current_picture_ptr->f,
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 548 549 550 551
                                       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]
        }
    }
552

553
    s->mb_y = 0;
554 555 556 557 558 559 560 561 562
    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)
563 564
            /* motion_type: frame/field */
            put_bits(&s->pb, 2, 2 - field_motion);
565 566 567 568
        put_bits(&s->pb, 1, s->interlaced_dct);
    }
}

569 570 571 572 573 574 575 576 577 578 579
// 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;
580
        int range    = 1 << bit_size;
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
        /* 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;
        }

597
        av_assert2(code > 0 && code <= 16);
598 599 600 601 602 603

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

        put_bits(&s->pb, 1, sign);
604
        if (bit_size > 0)
605 606 607 608 609 610
            put_bits(&s->pb, bit_size, bits);
    }
}

static inline void encode_dc(MpegEncContext *s, int diff, int component)
{
611 612
    unsigned int diff_u = diff + 255;
    if (diff_u >= 511) {
613 614
        int index;

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

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

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

679 680
    for (; i <= last_index; i++) {
        j     = s->intra_scantable.permutated[i];
681
        level = block[j];
682 683

next_coef:
684 685 686 687
        /* encode using VLC */
        if (level != 0) {
            run = i - last_non_zero - 1;

688
            alevel = level;
689
            MASK_ABS(sign, alevel);
690
            sign &= 1;
691

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

722
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s,
723
                                                      int16_t block[8][64],
724 725
                                                      int motion_x, int motion_y,
                                                      int mb_block_count)
726 727
{
    int i, cbp;
728 729 730
    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;
731 732 733

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

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

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

1000
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64],
1001
                        int motion_x, int motion_y)
1002
{
1003 1004 1005 1006
    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);
1007 1008
}

1009
av_cold void ff_mpeg1_encode_init(MpegEncContext *s)
1010
{
1011
    static int done = 0;
1012

1013
    ff_mpeg12_common_init(s);
1014

1015
    if (!done) {
1016 1017 1018 1019
        int f_code;
        int mv;
        int i;

1020
        done = 1;
1021 1022
        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]);
1023

1024 1025 1026
        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];
1027 1028
        }

1029
        init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len);
1030
        if (s->intra_vlc_format)
1031
            init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len);
1032 1033

        /* build unified dc encoding tables */
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
        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) +
1046
                    av_mod_uintp2(diff, index);
1047 1048 1049 1050
            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) +
1051
                    av_mod_uintp2(diff, index);
1052
            mpeg1_chr_dc_uni[i + 255] = bits + (code << 8);
1053 1054
        }

1055 1056
        for (f_code = 1; f_code <= MAX_FCODE; f_code++)
            for (mv = -MAX_MV; mv <= MAX_MV; mv++) {
1057 1058
                int len;

1059 1060 1061
                if (mv == 0) {
                    len = ff_mpeg12_mbMotionVectorTable[0][1];
                } else {
Mans Rullgard's avatar
Mans Rullgard committed
1062
                    int val, bit_size, code;
1063 1064 1065

                    bit_size = f_code - 1;

1066
                    val = mv;
1067 1068 1069 1070
                    if (val < 0)
                        val = -val;
                    val--;
                    code = (val >> bit_size) + 1;
1071 1072 1073 1074 1075 1076
                    if (code < 17)
                        len = ff_mpeg12_mbMotionVectorTable[code][1] +
                              1 + bit_size;
                    else
                        len = ff_mpeg12_mbMotionVectorTable[16][1] +
                              2 + bit_size;
1077 1078
                }

1079
                mv_penalty[f_code][mv + MAX_MV] = len;
1080 1081 1082
            }


1083 1084 1085
        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;
1086
    }
1087 1088 1089 1090 1091 1092 1093 1094
    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;
1095 1096
    }
    if (s->intra_vlc_format) {
1097 1098
        s->intra_ac_vlc_length      =
        s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len;
1099
    } else {
1100 1101
        s->intra_ac_vlc_length      =
        s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1102
    }
1103 1104
    s->inter_ac_vlc_length      =
    s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len;
1105 1106
}

1107 1108
#define OFFSET(x) offsetof(MpegEncContext, x)
#define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
1109
#define COMMON_OPTS                                                           \
1110 1111
    { "gop_timecode",        "MPEG GOP Timecode in hh:mm:ss[:;.]ff format",   \
      OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, CHAR_MIN, CHAR_MAX, VE },\
1112 1113 1114 1115 1116 1117
    { "intra_vlc",           "Use MPEG-2 intra VLC table.",                   \
      OFFSET(intra_vlc_format),    AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE }, \
    { "drop_frame_timecode", "Timecode is in drop frame format.",             \
      OFFSET(drop_frame_timecode), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE }, \
    { "scan_offset",         "Reserve space for SVCD scan offset user data.", \
      OFFSET(scan_offset),         AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1118 1119 1120

static const AVOption mpeg1_options[] = {
    COMMON_OPTS
1121
    FF_MPV_COMMON_OPTS
1122 1123 1124 1125 1126
    { NULL },
};

static const AVOption mpeg2_options[] = {
    COMMON_OPTS
1127 1128
    { "non_linear_quant", "Use nonlinear quantizer.",    OFFSET(q_scale_type),   AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
    { "alternate_scan",   "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1129 1130 1131 1132
    { "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" },
1133
    FF_MPV_COMMON_OPTS
1134
    { NULL },
1135 1136
};

1137 1138 1139 1140 1141 1142
#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,                \
1143 1144 1145 1146 1147
};

mpeg12_class(1)
mpeg12_class(2)

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

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