git.sesse.net Git - ffmpeg/blob - libavcodec/mjpegenc.c

   1 /*
   2  * MJPEG encoder
   3  * Copyright (c) 2000, 2001 Fabrice Bellard
   4  * Copyright (c) 2003 Alex Beregszaszi
   5  * Copyright (c) 2003-2004 Michael Niedermayer
   6  *
   7  * Support for external huffman table, various fixes (AVID workaround),
   8  * aspecting, new decode_frame mechanism and apple mjpeg-b support
   9  *                                  by Alex Beregszaszi
  10  *
  11  * This file is part of FFmpeg.
  12  *
  13  * FFmpeg is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Lesser General Public
  15  * License as published by the Free Software Foundation; either
  16  * version 2.1 of the License, or (at your option) any later version.
  17  *
  18  * FFmpeg is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public
  24  * License along with FFmpeg; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  */
  27
  28 /**
  29  * @file
  30  * MJPEG encoder.
  31  */
  32
  33 #include "libavutil/pixdesc.h"
  34
  35 #include "avcodec.h"
  36 #include "jpegtables.h"
  37 #include "mjpegenc_common.h"
  38 #include "mjpegenc_huffman.h"
  39 #include "mpegvideo.h"
  40 #include "mjpeg.h"
  41 #include "mjpegenc.h"
  42 #include "profiles.h"
  43
  44 static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],
  45                                     uint8_t *uni_ac_vlc_len)
  46 {
  47     for (int i = 0; i < 128; i++) {
  48         int level = i - 64;
  49         if (!level)
  50             continue;
  51         for (int run = 0; run < 64; run++) {
  52             int len, code, nbits;
  53             int alevel = FFABS(level);
  54
  55             len = (run >> 4) * huff_size_ac[0xf0];
  56
  57             nbits= av_log2_16bit(alevel) + 1;
  58             code = ((15&run) << 4) | nbits;
  59
  60             len += huff_size_ac[code] + nbits;
  61
  62             uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;
  63             // We ignore EOB as its just a constant which does not change generally
  64         }
  65     }
  66 }
  67
  68 /**
  69  * Encodes and outputs the entire frame in the JPEG format.
  70  *
  71  * @param s The MpegEncContext.
  72  */
  73 static void mjpeg_encode_picture_frame(MpegEncContext *s)
  74 {
  75     int nbits, code, table_id;
  76     MJpegContext *m = s->mjpeg_ctx;
  77     uint8_t  *huff_size[4] = { m->huff_size_dc_luminance,
  78                                m->huff_size_dc_chrominance,
  79                                m->huff_size_ac_luminance,
  80                                m->huff_size_ac_chrominance };
  81     uint16_t *huff_code[4] = { m->huff_code_dc_luminance,
  82                                m->huff_code_dc_chrominance,
  83                                m->huff_code_ac_luminance,
  84                                m->huff_code_ac_chrominance };
  85     size_t total_bits = 0;
  86     size_t bytes_needed;
  87
  88     s->header_bits = get_bits_diff(s);
  89     // Estimate the total size first
  90     for (int i = 0; i < m->huff_ncode; i++) {
  91         table_id = m->huff_buffer[i].table_id;
  92         code = m->huff_buffer[i].code;
  93         nbits = code & 0xf;
  94
  95         total_bits += huff_size[table_id][code] + nbits;
  96     }
  97
  98     bytes_needed = (total_bits + 7) / 8;
  99     ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
 100
 101     for (int i = 0; i < m->huff_ncode; i++) {
 102         table_id = m->huff_buffer[i].table_id;
 103         code = m->huff_buffer[i].code;
 104         nbits = code & 0xf;
 105
 106         put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
 107         if (nbits != 0) {
 108             put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
 109         }
 110     }
 111
 112     m->huff_ncode = 0;
 113     s->i_tex_bits = get_bits_diff(s);
 114 }
 115
 116 /**
 117  * Builds all 4 optimal Huffman tables.
 118  *
 119  * Uses the data stored in the JPEG buffer to compute the tables.
 120  * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.
 121  *
 122  * @param m MJpegContext containing the JPEG buffer.
 123  */
 124 static void mjpeg_build_optimal_huffman(MJpegContext *m)
 125 {
 126     MJpegEncHuffmanContext dc_luminance_ctx;
 127     MJpegEncHuffmanContext dc_chrominance_ctx;
 128     MJpegEncHuffmanContext ac_luminance_ctx;
 129     MJpegEncHuffmanContext ac_chrominance_ctx;
 130     MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx,
 131                                        &dc_chrominance_ctx,
 132                                        &ac_luminance_ctx,
 133                                        &ac_chrominance_ctx };
 134     for (int i = 0; i < 4; i++)
 135         ff_mjpeg_encode_huffman_init(ctx[i]);
 136
 137     for (int i = 0; i < m->huff_ncode; i++) {
 138         int table_id = m->huff_buffer[i].table_id;
 139         int code     = m->huff_buffer[i].code;
 140
 141         ff_mjpeg_encode_huffman_increment(ctx[table_id], code);
 142     }
 143
 144     ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,
 145                                   m->bits_dc_luminance,
 146                                   m->val_dc_luminance, 12);
 147     ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,
 148                                   m->bits_dc_chrominance,
 149                                   m->val_dc_chrominance, 12);
 150     ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,
 151                                   m->bits_ac_luminance,
 152                                   m->val_ac_luminance, 256);
 153     ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,
 154                                   m->bits_ac_chrominance,
 155                                   m->val_ac_chrominance, 256);
 156
 157     ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
 158                                  m->huff_code_dc_luminance,
 159                                  m->bits_dc_luminance,
 160                                  m->val_dc_luminance);
 161     ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
 162                                  m->huff_code_dc_chrominance,
 163                                  m->bits_dc_chrominance,
 164                                  m->val_dc_chrominance);
 165     ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
 166                                  m->huff_code_ac_luminance,
 167                                  m->bits_ac_luminance,
 168                                  m->val_ac_luminance);
 169     ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
 170                                  m->huff_code_ac_chrominance,
 171                                  m->bits_ac_chrominance,
 172                                  m->val_ac_chrominance);
 173 }
 174
 175 /**
 176  * Writes the complete JPEG frame when optimal huffman tables are enabled,
 177  * otherwise writes the stuffing.
 178  *
 179  * Header + values + stuffing.
 180  *
 181  * @param s The MpegEncContext.
 182  * @return int Error code, 0 if successful.
 183  */
 184 int ff_mjpeg_encode_stuffing(MpegEncContext *s)
 185 {
 186     PutBitContext *pbc = &s->pb;
 187     int mb_y = s->mb_y - !s->mb_x;
 188     int ret;
 189     MJpegContext *m;
 190
 191     m = s->mjpeg_ctx;
 192
 193     if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
 194         mjpeg_build_optimal_huffman(m);
 195
 196         // Replace the VLCs with the optimal ones.
 197         // The default ones may be used for trellis during quantization.
 198         init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
 199         init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
 200         s->intra_ac_vlc_length      =
 201         s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
 202         s->intra_chroma_ac_vlc_length      =
 203         s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
 204
 205         ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
 206                                        s->pred, s->intra_matrix, s->chroma_intra_matrix);
 207         mjpeg_encode_picture_frame(s);
 208     }
 209
 210     ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
 211                                             put_bits_count(&s->pb) / 4 + 1000);
 212     if (ret < 0) {
 213         av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
 214         goto fail;
 215     }
 216
 217     ff_mjpeg_escape_FF(pbc, s->esc_pos);
 218
 219     if ((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height - 1)
 220         put_marker(pbc, RST0 + (mb_y&7));
 221     s->esc_pos = put_bits_count(pbc) >> 3;
 222
 223 fail:
 224     for (int i = 0; i < 3; i++)
 225         s->last_dc[i] = 128 << s->intra_dc_precision;
 226
 227     return ret;
 228 }
 229
 230 static int alloc_huffman(MpegEncContext *s)
 231 {
 232     MJpegContext *m = s->mjpeg_ctx;
 233     size_t num_mbs, num_blocks, num_codes;
 234     int blocks_per_mb;
 235
 236     // We need to init this here as the mjpeg init is called before the common init,
 237     s->mb_width  = (s->width  + 15) / 16;
 238     s->mb_height = (s->height + 15) / 16;
 239
 240     switch (s->chroma_format) {
 241     case CHROMA_420: blocks_per_mb =  6; break;
 242     case CHROMA_422: blocks_per_mb =  8; break;
 243     case CHROMA_444: blocks_per_mb = 12; break;
 244     default: av_assert0(0);
 245     };
 246
 247     // Make sure we have enough space to hold this frame.
 248     num_mbs = s->mb_width * s->mb_height;
 249     num_blocks = num_mbs * blocks_per_mb;
 250     num_codes = num_blocks * 64;
 251
 252     m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
 253     if (!m->huff_buffer)
 254         return AVERROR(ENOMEM);
 255     return 0;
 256 }
 257
 258 av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
 259 {
 260     MJpegContext *m;
 261
 262     av_assert0(s->slice_context_count == 1);
 263
 264     if (s->width > 65500 || s->height > 65500) {
 265         av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
 266         return AVERROR(EINVAL);
 267     }
 268
 269     m = av_mallocz(sizeof(MJpegContext));
 270     if (!m)
 271         return AVERROR(ENOMEM);
 272
 273     s->min_qcoeff=-1023;
 274     s->max_qcoeff= 1023;
 275
 276     // Build default Huffman tables.
 277     // These may be overwritten later with more optimal Huffman tables, but
 278     // they are needed at least right now for some processes like trellis.
 279     ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
 280                                  m->huff_code_dc_luminance,
 281                                  avpriv_mjpeg_bits_dc_luminance,
 282                                  avpriv_mjpeg_val_dc);
 283     ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
 284                                  m->huff_code_dc_chrominance,
 285                                  avpriv_mjpeg_bits_dc_chrominance,
 286                                  avpriv_mjpeg_val_dc);
 287     ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
 288                                  m->huff_code_ac_luminance,
 289                                  avpriv_mjpeg_bits_ac_luminance,
 290                                  avpriv_mjpeg_val_ac_luminance);
 291     ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
 292                                  m->huff_code_ac_chrominance,
 293                                  avpriv_mjpeg_bits_ac_chrominance,
 294                                  avpriv_mjpeg_val_ac_chrominance);
 295
 296     init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
 297     init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
 298     s->intra_ac_vlc_length      =
 299     s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
 300     s->intra_chroma_ac_vlc_length      =
 301     s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
 302
 303     // Buffers start out empty.
 304     m->huff_ncode = 0;
 305     s->mjpeg_ctx = m;
 306
 307     if(s->huffman == HUFFMAN_TABLE_OPTIMAL)
 308         return alloc_huffman(s);
 309
 310     return 0;
 311 }
 312
 313 av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
 314 {
 315     av_freep(&s->mjpeg_ctx->huff_buffer);
 316     av_freep(&s->mjpeg_ctx);
 317 }
 318
 319 /**
 320  * Add code and table_id to the JPEG buffer.
 321  *
 322  * @param s The MJpegContext which contains the JPEG buffer.
 323  * @param table_id Which Huffman table the code belongs to.
 324  * @param code The encoded exponent of the coefficients and the run-bits.
 325  */
 326 static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
 327 {
 328     MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
 329     c->table_id = table_id;
 330     c->code = code;
 331 }
 332
 333 /**
 334  * Add the coefficient's data to the JPEG buffer.
 335  *
 336  * @param s The MJpegContext which contains the JPEG buffer.
 337  * @param table_id Which Huffman table the code belongs to.
 338  * @param val The coefficient.
 339  * @param run The run-bits.
 340  */
 341 static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
 342 {
 343     int mant, code;
 344
 345     if (val == 0) {
 346         av_assert0(run == 0);
 347         ff_mjpeg_encode_code(s, table_id, 0);
 348     } else {
 349         mant = val;
 350         if (val < 0) {
 351             val = -val;
 352             mant--;
 353         }
 354
 355         code = (run << 4) | (av_log2_16bit(val) + 1);
 356
 357         s->huff_buffer[s->huff_ncode].mant = mant;
 358         ff_mjpeg_encode_code(s, table_id, code);
 359     }
 360 }
 361
 362 /**
 363  * Add the block's data into the JPEG buffer.
 364  *
 365  * @param s The MJpegEncContext that contains the JPEG buffer.
 366  * @param block The block.
 367  * @param n The block's index or number.
 368  */
 369 static void record_block(MpegEncContext *s, int16_t *block, int n)
 370 {
 371     int i, j, table_id;
 372     int component, dc, last_index, val, run;
 373     MJpegContext *m = s->mjpeg_ctx;
 374
 375     /* DC coef */
 376     component = (n <= 3 ? 0 : (n&1) + 1);
 377     table_id = (n <= 3 ? 0 : 1);
 378     dc = block[0]; /* overflow is impossible */
 379     val = dc - s->last_dc[component];
 380
 381     ff_mjpeg_encode_coef(m, table_id, val, 0);
 382
 383     s->last_dc[component] = dc;
 384
 385     /* AC coefs */
 386
 387     run = 0;
 388     last_index = s->block_last_index[n];
 389     table_id |= 2;
 390
 391     for(i=1;i<=last_index;i++) {
 392         j = s->intra_scantable.permutated[i];
 393         val = block[j];
 394
 395         if (val == 0) {
 396             run++;
 397         } else {
 398             while (run >= 16) {
 399                 ff_mjpeg_encode_code(m, table_id, 0xf0);
 400                 run -= 16;
 401             }
 402             ff_mjpeg_encode_coef(m, table_id, val, run);
 403             run = 0;
 404         }
 405     }
 406
 407     /* output EOB only if not already 64 values */
 408     if (last_index < 63 || run != 0)
 409         ff_mjpeg_encode_code(m, table_id, 0);
 410 }
 411
 412 static void encode_block(MpegEncContext *s, int16_t *block, int n)
 413 {
 414     int mant, nbits, code, i, j;
 415     int component, dc, run, last_index, val;
 416     MJpegContext *m = s->mjpeg_ctx;
 417     uint8_t *huff_size_ac;
 418     uint16_t *huff_code_ac;
 419
 420     /* DC coef */
 421     component = (n <= 3 ? 0 : (n&1) + 1);
 422     dc = block[0]; /* overflow is impossible */
 423     val = dc - s->last_dc[component];
 424     if (n < 4) {
 425         ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 426         huff_size_ac = m->huff_size_ac_luminance;
 427         huff_code_ac = m->huff_code_ac_luminance;
 428     } else {
 429         ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 430         huff_size_ac = m->huff_size_ac_chrominance;
 431         huff_code_ac = m->huff_code_ac_chrominance;
 432     }
 433     s->last_dc[component] = dc;
 434
 435     /* AC coefs */
 436
 437     run = 0;
 438     last_index = s->block_last_index[n];
 439     for(i=1;i<=last_index;i++) {
 440         j = s->intra_scantable.permutated[i];
 441         val = block[j];
 442         if (val == 0) {
 443             run++;
 444         } else {
 445             while (run >= 16) {
 446                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 447                 run -= 16;
 448             }
 449             mant = val;
 450             if (val < 0) {
 451                 val = -val;
 452                 mant--;
 453             }
 454
 455             nbits= av_log2_16bit(val) + 1;
 456             code = (run << 4) | nbits;
 457
 458             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 459
 460             put_sbits(&s->pb, nbits, mant);
 461             run = 0;
 462         }
 463     }
 464
 465     /* output EOB only if not already 64 values */
 466     if (last_index < 63 || run != 0)
 467         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 468 }
 469
 470 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
 471 {
 472     int i;
 473     if (s->huffman == HUFFMAN_TABLE_OPTIMAL) {
 474         if (s->chroma_format == CHROMA_444) {
 475             record_block(s, block[0], 0);
 476             record_block(s, block[2], 2);
 477             record_block(s, block[4], 4);
 478             record_block(s, block[8], 8);
 479             record_block(s, block[5], 5);
 480             record_block(s, block[9], 9);
 481
 482             if (16*s->mb_x+8 < s->width) {
 483                 record_block(s, block[1], 1);
 484                 record_block(s, block[3], 3);
 485                 record_block(s, block[6], 6);
 486                 record_block(s, block[10], 10);
 487                 record_block(s, block[7], 7);
 488                 record_block(s, block[11], 11);
 489             }
 490         } else {
 491             for(i=0;i<5;i++) {
 492                 record_block(s, block[i], i);
 493             }
 494             if (s->chroma_format == CHROMA_420) {
 495                 record_block(s, block[5], 5);
 496             } else {
 497                 record_block(s, block[6], 6);
 498                 record_block(s, block[5], 5);
 499                 record_block(s, block[7], 7);
 500             }
 501         }
 502     } else {
 503         if (s->chroma_format == CHROMA_444) {
 504             encode_block(s, block[0], 0);
 505             encode_block(s, block[2], 2);
 506             encode_block(s, block[4], 4);
 507             encode_block(s, block[8], 8);
 508             encode_block(s, block[5], 5);
 509             encode_block(s, block[9], 9);
 510
 511             if (16*s->mb_x+8 < s->width) {
 512                 encode_block(s, block[1], 1);
 513                 encode_block(s, block[3], 3);
 514                 encode_block(s, block[6], 6);
 515                 encode_block(s, block[10], 10);
 516                 encode_block(s, block[7], 7);
 517                 encode_block(s, block[11], 11);
 518             }
 519         } else {
 520             for(i=0;i<5;i++) {
 521                 encode_block(s, block[i], i);
 522             }
 523             if (s->chroma_format == CHROMA_420) {
 524                 encode_block(s, block[5], 5);
 525             } else {
 526                 encode_block(s, block[6], 6);
 527                 encode_block(s, block[5], 5);
 528                 encode_block(s, block[7], 7);
 529             }
 530         }
 531
 532         s->i_tex_bits += get_bits_diff(s);
 533     }
 534 }
 535
 536 #if CONFIG_AMV_ENCODER
 537 // maximum over s->mjpeg_vsample[i]
 538 #define V_MAX 2
 539 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 540                               const AVFrame *pic_arg, int *got_packet)
 541 {
 542     MpegEncContext *s = avctx->priv_data;
 543     AVFrame *pic;
 544     int i, ret;
 545     int chroma_h_shift, chroma_v_shift;
 546
 547     av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
 548
 549     if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
 550         av_log(avctx, AV_LOG_ERROR,
 551                "Heights which are not a multiple of 16 might fail with some decoders, "
 552                "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
 553         av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
 554                "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
 555         return AVERROR_EXPERIMENTAL;
 556     }
 557
 558     pic = av_frame_clone(pic_arg);
 559     if (!pic)
 560         return AVERROR(ENOMEM);
 561     //picture should be flipped upside-down
 562     for(i=0; i < 3; i++) {
 563         int vsample = i ? 2 >> chroma_v_shift : 2;
 564         pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
 565         pic->linesize[i] *= -1;
 566     }
 567     ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
 568     av_frame_free(&pic);
 569     return ret;
 570 }
 571 #endif
 572
 573 #define OFFSET(x) offsetof(MpegEncContext, x)
 574 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 575 static const AVOption options[] = {
 576 FF_MPV_COMMON_OPTS
 577 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
 578     { "left",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
 579     { "plane",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
 580     { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
 581 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
 582     { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
 583     { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
 584 { NULL},
 585 };
 586
 587 #if CONFIG_MJPEG_ENCODER
 588 static const AVClass mjpeg_class = {
 589     .class_name = "mjpeg encoder",
 590     .item_name  = av_default_item_name,
 591     .option     = options,
 592     .version    = LIBAVUTIL_VERSION_INT,
 593 };
 594
 595 AVCodec ff_mjpeg_encoder = {
 596     .name           = "mjpeg",
 597     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
 598     .type           = AVMEDIA_TYPE_VIDEO,
 599     .id             = AV_CODEC_ID_MJPEG,
 600     .priv_data_size = sizeof(MpegEncContext),
 601     .init           = ff_mpv_encode_init,
 602     .encode2        = ff_mpv_encode_picture,
 603     .close          = ff_mpv_encode_end,
 604     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
 605     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 606     .pix_fmts       = (const enum AVPixelFormat[]) {
 607         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
 608     },
 609     .priv_class     = &mjpeg_class,
 610     .profiles       = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
 611 };
 612 #endif
 613
 614 #if CONFIG_AMV_ENCODER
 615 static const AVClass amv_class = {
 616     .class_name = "amv encoder",
 617     .item_name  = av_default_item_name,
 618     .option     = options,
 619     .version    = LIBAVUTIL_VERSION_INT,
 620 };
 621
 622 AVCodec ff_amv_encoder = {
 623     .name           = "amv",
 624     .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
 625     .type           = AVMEDIA_TYPE_VIDEO,
 626     .id             = AV_CODEC_ID_AMV,
 627     .priv_data_size = sizeof(MpegEncContext),
 628     .init           = ff_mpv_encode_init,
 629     .encode2        = amv_encode_picture,
 630     .close          = ff_mpv_encode_end,
 631     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
 632     .pix_fmts       = (const enum AVPixelFormat[]) {
 633         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
 634     },
 635     .priv_class     = &amv_class,
 636 };
 637 #endif