mjpegenc.c 14.5 KB
Newer Older
1 2
/*
 * MJPEG encoder
3
 * Copyright (c) 2000, 2001 Fabrice Bellard
4 5 6
 * Copyright (c) 2003 Alex Beregszaszi
 * Copyright (c) 2003-2004 Michael Niedermayer
 *
7 8 9 10
 * Support for external huffman table, various fixes (AVID workaround),
 * aspecting, new decode_frame mechanism and apple mjpeg-b support
 *                                  by Alex Beregszaszi
 *
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * 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
 */

/**
29
 * @file
30 31 32
 * MJPEG encoder.
 */

33 34
#include "libavutil/pixdesc.h"

35
#include "avcodec.h"
36
#include "jpegtables.h"
37
#include "mjpegenc_common.h"
38 39
#include "mpegvideo.h"
#include "mjpeg.h"
40
#include "mjpegenc.h"
41
#include "profiles.h"
42

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
static int alloc_huffman(MpegEncContext *s)
{
    MJpegContext *m = s->mjpeg_ctx;
    size_t num_mbs, num_blocks, num_codes;
    int blocks_per_mb;

    // We need to init this here as the mjpeg init is called before the common init,
    s->mb_width  = (s->width  + 15) / 16;
    s->mb_height = (s->height + 15) / 16;

    switch (s->chroma_format) {
    case CHROMA_420: blocks_per_mb =  6; break;
    case CHROMA_422: blocks_per_mb =  8; break;
    case CHROMA_444: blocks_per_mb = 12; break;
    default: av_assert0(0);
    };

    // Make sure we have enough space to hold this frame.
    num_mbs = s->mb_width * s->mb_height;
    num_blocks = num_mbs * blocks_per_mb;
    num_codes = num_blocks * 64;

    m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
    if (!m->huff_buffer)
        return AVERROR(ENOMEM);
    return 0;
}

71
av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
72 73 74
{
    MJpegContext *m;

75 76
    av_assert0(s->slice_context_count == 1);

77 78
    if (s->width > 65500 || s->height > 65500) {
        av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
79
        return AVERROR(EINVAL);
80 81
    }

82
    m = av_mallocz(sizeof(MJpegContext));
83
    if (!m)
84
        return AVERROR(ENOMEM);
85 86 87 88

    s->min_qcoeff=-1023;
    s->max_qcoeff= 1023;

89 90 91
    // Build default Huffman tables.
    // These may be overwritten later with more optimal Huffman tables, but
    // they are needed at least right now for some processes like trellis.
92 93
    ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
                                 m->huff_code_dc_luminance,
94 95
                                 avpriv_mjpeg_bits_dc_luminance,
                                 avpriv_mjpeg_val_dc);
96 97
    ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
                                 m->huff_code_dc_chrominance,
98 99
                                 avpriv_mjpeg_bits_dc_chrominance,
                                 avpriv_mjpeg_val_dc);
100 101
    ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
                                 m->huff_code_ac_luminance,
102 103
                                 avpriv_mjpeg_bits_ac_luminance,
                                 avpriv_mjpeg_val_ac_luminance);
104 105
    ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
                                 m->huff_code_ac_chrominance,
106 107
                                 avpriv_mjpeg_bits_ac_chrominance,
                                 avpriv_mjpeg_val_ac_chrominance);
108

109 110
    ff_init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
    ff_init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
111
    s->intra_ac_vlc_length      =
112
    s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
113
    s->intra_chroma_ac_vlc_length      =
114 115 116 117
    s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;

    // Buffers start out empty.
    m->huff_ncode = 0;
118
    s->mjpeg_ctx = m;
119

120 121 122 123
    if(s->huffman == HUFFMAN_TABLE_OPTIMAL)
        return alloc_huffman(s);

    return 0;
124 125
}

126
av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
127
{
128
    av_freep(&s->mjpeg_ctx->huff_buffer);
129
    av_freep(&s->mjpeg_ctx);
130 131
}

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
/**
 * Add code and table_id to the JPEG buffer.
 *
 * @param s The MJpegContext which contains the JPEG buffer.
 * @param table_id Which Huffman table the code belongs to.
 * @param code The encoded exponent of the coefficients and the run-bits.
 */
static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
{
    MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
    c->table_id = table_id;
    c->code = code;
}

/**
 * Add the coefficient's data to the JPEG buffer.
 *
 * @param s The MJpegContext which contains the JPEG buffer.
 * @param table_id Which Huffman table the code belongs to.
 * @param val The coefficient.
 * @param run The run-bits.
 */
static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
{
    int mant, code;

    if (val == 0) {
        av_assert0(run == 0);
        ff_mjpeg_encode_code(s, table_id, 0);
    } else {
        mant = val;
        if (val < 0) {
            val = -val;
            mant--;
        }

        code = (run << 4) | (av_log2_16bit(val) + 1);

        s->huff_buffer[s->huff_ncode].mant = mant;
        ff_mjpeg_encode_code(s, table_id, code);
    }
}

/**
 * Add the block's data into the JPEG buffer.
 *
 * @param s The MJpegEncContext that contains the JPEG buffer.
 * @param block The block.
 * @param n The block's index or number.
 */
182
static void record_block(MpegEncContext *s, int16_t *block, int n)
183
{
184 185
    int i, j, table_id;
    int component, dc, last_index, val, run;
186
    MJpegContext *m = s->mjpeg_ctx;
187

188 189
    /* DC coef */
    component = (n <= 3 ? 0 : (n&1) + 1);
190
    table_id = (n <= 3 ? 0 : 1);
191 192
    dc = block[0]; /* overflow is impossible */
    val = dc - s->last_dc[component];
193 194 195

    ff_mjpeg_encode_coef(m, table_id, val, 0);

196 197 198 199 200 201
    s->last_dc[component] = dc;

    /* AC coefs */

    run = 0;
    last_index = s->block_last_index[n];
202 203
    table_id |= 2;

204 205 206
    for(i=1;i<=last_index;i++) {
        j = s->intra_scantable.permutated[i];
        val = block[j];
207

208 209 210 211
        if (val == 0) {
            run++;
        } else {
            while (run >= 16) {
212
                ff_mjpeg_encode_code(m, table_id, 0xf0);
213 214
                run -= 16;
            }
215
            ff_mjpeg_encode_coef(m, table_id, val, run);
216 217 218 219 220 221
            run = 0;
        }
    }

    /* output EOB only if not already 64 values */
    if (last_index < 63 || run != 0)
222
        ff_mjpeg_encode_code(m, table_id, 0);
223 224
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
static void encode_block(MpegEncContext *s, int16_t *block, int n)
{
    int mant, nbits, code, i, j;
    int component, dc, run, last_index, val;
    MJpegContext *m = s->mjpeg_ctx;
    uint8_t *huff_size_ac;
    uint16_t *huff_code_ac;

    /* DC coef */
    component = (n <= 3 ? 0 : (n&1) + 1);
    dc = block[0]; /* overflow is impossible */
    val = dc - s->last_dc[component];
    if (n < 4) {
        ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
        huff_size_ac = m->huff_size_ac_luminance;
        huff_code_ac = m->huff_code_ac_luminance;
    } else {
        ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
        huff_size_ac = m->huff_size_ac_chrominance;
        huff_code_ac = m->huff_code_ac_chrominance;
    }
    s->last_dc[component] = dc;

    /* AC coefs */

    run = 0;
    last_index = s->block_last_index[n];
    for(i=1;i<=last_index;i++) {
        j = s->intra_scantable.permutated[i];
        val = block[j];
        if (val == 0) {
            run++;
        } else {
            while (run >= 16) {
                put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
                run -= 16;
            }
            mant = val;
            if (val < 0) {
                val = -val;
                mant--;
            }

            nbits= av_log2_16bit(val) + 1;
            code = (run << 4) | nbits;

            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);

            put_sbits(&s->pb, nbits, mant);
            run = 0;
        }
    }

    /* output EOB only if not already 64 values */
    if (last_index < 63 || run != 0)
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
}

283
void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
284
{
285
    int i;
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->huffman == HUFFMAN_TABLE_OPTIMAL) {
        if (s->chroma_format == CHROMA_444) {
            record_block(s, block[0], 0);
            record_block(s, block[2], 2);
            record_block(s, block[4], 4);
            record_block(s, block[8], 8);
            record_block(s, block[5], 5);
            record_block(s, block[9], 9);

            if (16*s->mb_x+8 < s->width) {
                record_block(s, block[1], 1);
                record_block(s, block[3], 3);
                record_block(s, block[6], 6);
                record_block(s, block[10], 10);
                record_block(s, block[7], 7);
                record_block(s, block[11], 11);
            }
        } else {
            for(i=0;i<5;i++) {
                record_block(s, block[i], i);
            }
            if (s->chroma_format == CHROMA_420) {
                record_block(s, block[5], 5);
            } else {
                record_block(s, block[6], 6);
                record_block(s, block[5], 5);
                record_block(s, block[7], 7);
            }
314
        }
315
    } else {
316 317 318 319 320
        if (s->chroma_format == CHROMA_444) {
            encode_block(s, block[0], 0);
            encode_block(s, block[2], 2);
            encode_block(s, block[4], 4);
            encode_block(s, block[8], 8);
321
            encode_block(s, block[5], 5);
322 323 324 325 326 327 328 329 330 331
            encode_block(s, block[9], 9);

            if (16*s->mb_x+8 < s->width) {
                encode_block(s, block[1], 1);
                encode_block(s, block[3], 3);
                encode_block(s, block[6], 6);
                encode_block(s, block[10], 10);
                encode_block(s, block[7], 7);
                encode_block(s, block[11], 11);
            }
332
        } else {
333 334 335 336 337 338 339 340 341 342
            for(i=0;i<5;i++) {
                encode_block(s, block[i], i);
            }
            if (s->chroma_format == CHROMA_420) {
                encode_block(s, block[5], 5);
            } else {
                encode_block(s, block[6], 6);
                encode_block(s, block[5], 5);
                encode_block(s, block[7], 7);
            }
343
        }
344 345

        s->i_tex_bits += get_bits_diff(s);
346 347
    }
}
348

349
#if CONFIG_AMV_ENCODER
Michael Niedermayer's avatar
Michael Niedermayer committed
350 351
// maximum over s->mjpeg_vsample[i]
#define V_MAX 2
352
static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
353
                              const AVFrame *pic_arg, int *got_packet)
354
{
Michael Niedermayer's avatar
Michael Niedermayer committed
355
    MpegEncContext *s = avctx->priv_data;
356 357
    AVFrame *pic;
    int i, ret;
358 359 360
    int chroma_h_shift, chroma_v_shift;

    av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
Michael Niedermayer's avatar
Michael Niedermayer committed
361

362
    if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
363
        av_log(avctx, AV_LOG_ERROR,
364 365 366 367 368
               "Heights which are not a multiple of 16 might fail with some decoders, "
               "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
        av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
               "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
        return AVERROR_EXPERIMENTAL;
369 370
    }

371
    pic = av_frame_clone(pic_arg);
372 373
    if (!pic)
        return AVERROR(ENOMEM);
Michael Niedermayer's avatar
Michael Niedermayer committed
374 375
    //picture should be flipped upside-down
    for(i=0; i < 3; i++) {
376
        int vsample = i ? 2 >> chroma_v_shift : 2;
377
        pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
378
        pic->linesize[i] *= -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
379
    }
380
    ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
381 382
    av_frame_free(&pic);
    return ret;
Michael Niedermayer's avatar
Michael Niedermayer committed
383
}
384
#endif
Michael Niedermayer's avatar
Michael Niedermayer committed
385

386 387 388
#define OFFSET(x) offsetof(MpegEncContext, x)
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
389
FF_MPV_COMMON_OPTS
390 391 392 393
{ "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
    { "left",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
    { "plane",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
    { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
394
{ "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
395 396
    { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
    { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
397
{ NULL},
398 399
};

400
#if CONFIG_MJPEG_ENCODER
401 402 403
static const AVClass mjpeg_class = {
    .class_name = "mjpeg encoder",
    .item_name  = av_default_item_name,
404
    .option     = options,
405 406
    .version    = LIBAVUTIL_VERSION_INT,
};
407

408
AVCodec ff_mjpeg_encoder = {
409
    .name           = "mjpeg",
410
    .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
411
    .type           = AVMEDIA_TYPE_VIDEO,
412
    .id             = AV_CODEC_ID_MJPEG,
413
    .priv_data_size = sizeof(MpegEncContext),
414 415 416
    .init           = ff_mpv_encode_init,
    .encode2        = ff_mpv_encode_picture,
    .close          = ff_mpv_encode_end,
417
    .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
418
    .pix_fmts       = (const enum AVPixelFormat[]) {
419
        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
420
    },
421
    .priv_class     = &mjpeg_class,
422
    .profiles       = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
423
};
424
#endif
425

426
#if CONFIG_AMV_ENCODER
427 428 429
static const AVClass amv_class = {
    .class_name = "amv encoder",
    .item_name  = av_default_item_name,
430
    .option     = options,
431 432
    .version    = LIBAVUTIL_VERSION_INT,
};
433

Michael Niedermayer's avatar
Michael Niedermayer committed
434
AVCodec ff_amv_encoder = {
435
    .name           = "amv",
436
    .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
437
    .type           = AVMEDIA_TYPE_VIDEO,
438
    .id             = AV_CODEC_ID_AMV,
439
    .priv_data_size = sizeof(MpegEncContext),
440
    .init           = ff_mpv_encode_init,
441
    .encode2        = amv_encode_picture,
442
    .close          = ff_mpv_encode_end,
443
    .pix_fmts       = (const enum AVPixelFormat[]) {
444
        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
445
    },
446
    .priv_class     = &amv_class,
Michael Niedermayer's avatar
Michael Niedermayer committed
447
};
448
#endif