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