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

   1 /*
   2  * MJPEG encoder and decoder
   3  * Copyright (c) 2000, 2001 Gerard Lantau.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 #include "avcodec.h"
  20 #include "dsputil.h"
  21 #include "mpegvideo.h"
  22
  23 typedef struct MJpegContext {
  24     UINT8 huff_size_dc_luminance[12];
  25     UINT16 huff_code_dc_luminance[12];
  26     UINT8 huff_size_dc_chrominance[12];
  27     UINT16 huff_code_dc_chrominance[12];
  28
  29     UINT8 huff_size_ac_luminance[256];
  30     UINT16 huff_code_ac_luminance[256];
  31     UINT8 huff_size_ac_chrominance[256];
  32     UINT16 huff_code_ac_chrominance[256];
  33 } MJpegContext;
  34
  35 #define SOF0 0xc0
  36 #define SOI 0xd8
  37 #define EOI 0xd9
  38 #define DQT 0xdb
  39 #define DHT 0xc4
  40 #define SOS 0xda
  41
  42 #if 0
  43 /* These are the sample quantization tables given in JPEG spec section K.1.
  44  * The spec says that the values given produce "good" quality, and
  45  * when divided by 2, "very good" quality.
  46  */
  47 static const unsigned char std_luminance_quant_tbl[64] = {
  48     16,  11,  10,  16,  24,  40,  51,  61,
  49     12,  12,  14,  19,  26,  58,  60,  55,
  50     14,  13,  16,  24,  40,  57,  69,  56,
  51     14,  17,  22,  29,  51,  87,  80,  62,
  52     18,  22,  37,  56,  68, 109, 103,  77,
  53     24,  35,  55,  64,  81, 104, 113,  92,
  54     49,  64,  78,  87, 103, 121, 120, 101,
  55     72,  92,  95,  98, 112, 100, 103,  99
  56 };
  57 static const unsigned char std_chrominance_quant_tbl[64] = {
  58     17,  18,  24,  47,  99,  99,  99,  99,
  59     18,  21,  26,  66,  99,  99,  99,  99,
  60     24,  26,  56,  99,  99,  99,  99,  99,
  61     47,  66,  99,  99,  99,  99,  99,  99,
  62     99,  99,  99,  99,  99,  99,  99,  99,
  63     99,  99,  99,  99,  99,  99,  99,  99,
  64     99,  99,  99,  99,  99,  99,  99,  99,
  65     99,  99,  99,  99,  99,  99,  99,  99
  66 };
  67 #endif
  68
  69 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
  70 /* IMPORTANT: these are only valid for 8-bit data precision! */
  71 static const UINT8 bits_dc_luminance[17] =
  72 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
  73 static const UINT8 val_dc_luminance[] =
  74 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  75
  76 static const UINT8 bits_dc_chrominance[17] =
  77 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
  78 static const UINT8 val_dc_chrominance[] =
  79 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  80
  81 static const UINT8 bits_ac_luminance[17] =
  82 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
  83 static const UINT8 val_ac_luminance[] =
  84 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  85   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  86   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  87   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  88   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  89   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  90   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  91   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  92   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  93   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  94   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  95   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  96   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  97   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  98   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
  99   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 100   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 101   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 102   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 103   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 104   0xf9, 0xfa
 105 };
 106
 107 static const UINT8 bits_ac_chrominance[17] =
 108 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 109
 110 static const UINT8 val_ac_chrominance[] =
 111 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 112   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 113   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 114   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 115   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 116   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 117   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 118   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 119   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 120   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 121   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 122   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 123   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 124   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 125   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 126   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 127   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 128   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 129   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 130   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 131   0xf9, 0xfa
 132 };
 133
 134
 135 /* isn't this function nicer than the one in the libjpeg ? */
 136 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
 137                                 const UINT8 *bits_table, const UINT8 *val_table)
 138 {
 139     int i, j, k,nb, code, sym;
 140
 141     code = 0;
 142     k = 0;
 143     for(i=1;i<=16;i++) {
 144         nb = bits_table[i];
 145         for(j=0;j<nb;j++) {
 146             sym = val_table[k++];
 147             huff_size[sym] = i;
 148             huff_code[sym] = code;
 149             code++;
 150         }
 151         code <<= 1;
 152     }
 153 }
 154
 155 int mjpeg_init(MpegEncContext *s)
 156 {
 157     MJpegContext *m;
 158
 159     m = malloc(sizeof(MJpegContext));
 160     if (!m)
 161         return -1;
 162
 163     /* build all the huffman tables */
 164     build_huffman_codes(m->huff_size_dc_luminance,
 165                         m->huff_code_dc_luminance,
 166                         bits_dc_luminance,
 167                         val_dc_luminance);
 168     build_huffman_codes(m->huff_size_dc_chrominance,
 169                         m->huff_code_dc_chrominance,
 170                         bits_dc_chrominance,
 171                         val_dc_chrominance);
 172     build_huffman_codes(m->huff_size_ac_luminance,
 173                         m->huff_code_ac_luminance,
 174                         bits_ac_luminance,
 175                         val_ac_luminance);
 176     build_huffman_codes(m->huff_size_ac_chrominance,
 177                         m->huff_code_ac_chrominance,
 178                         bits_ac_chrominance,
 179                         val_ac_chrominance);
 180
 181     s->mjpeg_ctx = m;
 182     return 0;
 183 }
 184
 185 void mjpeg_close(MpegEncContext *s)
 186 {
 187     free(s->mjpeg_ctx);
 188 }
 189
 190 static inline void put_marker(PutBitContext *p, int code)
 191 {
 192     put_bits(p, 8, 0xff);
 193     put_bits(p, 8, code);
 194 }
 195
 196 /* table_class: 0 = DC coef, 1 = AC coefs */
 197 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 198                              const UINT8 *bits_table, const UINT8 *value_table)
 199 {
 200     PutBitContext *p = &s->pb;
 201     int n, i;
 202
 203     put_bits(p, 4, table_class);
 204     put_bits(p, 4, table_id);
 205
 206     n = 0;
 207     for(i=1;i<=16;i++) {
 208         n += bits_table[i];
 209         put_bits(p, 8, bits_table[i]);
 210     }
 211
 212     for(i=0;i<n;i++)
 213         put_bits(p, 8, value_table[i]);
 214
 215     return n + 17;
 216 }
 217
 218 static void jpeg_table_header(MpegEncContext *s)
 219 {
 220     PutBitContext *p = &s->pb;
 221     int i, j, size;
 222     UINT8 *ptr;
 223
 224     /* quant matrixes */
 225     put_marker(p, DQT);
 226     put_bits(p, 16, 2 + 1 * (1 + 64));
 227     put_bits(p, 4, 0); /* 8 bit precision */
 228     put_bits(p, 4, 0); /* table 0 */
 229     for(i=0;i<64;i++) {
 230         j = zigzag_direct[i];
 231         put_bits(p, 8, s->intra_matrix[j]);
 232     }
 233 #if 0
 234     put_bits(p, 4, 0); /* 8 bit precision */
 235     put_bits(p, 4, 1); /* table 1 */
 236     for(i=0;i<64;i++) {
 237         j = zigzag_direct[i];
 238         put_bits(p, 8, s->chroma_intra_matrix[j]);
 239     }
 240 #endif
 241
 242     /* huffman table */
 243     put_marker(p, DHT);
 244     flush_put_bits(p);
 245     ptr = p->buf_ptr;
 246     put_bits(p, 16, 0); /* patched later */
 247     size = 2;
 248     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 249     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 250
 251     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 252     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 253     ptr[0] = size >> 8;
 254     ptr[1] = size;
 255 }
 256
 257 void mjpeg_picture_header(MpegEncContext *s)
 258 {
 259     put_marker(&s->pb, SOI);
 260
 261     jpeg_table_header(s);
 262
 263     put_marker(&s->pb, SOF0);
 264
 265     put_bits(&s->pb, 16, 17);
 266     put_bits(&s->pb, 8, 8); /* 8 bits/component */
 267     put_bits(&s->pb, 16, s->height);
 268     put_bits(&s->pb, 16, s->width);
 269     put_bits(&s->pb, 8, 3); /* 3 components */
 270
 271     /* Y component */
 272     put_bits(&s->pb, 8, 1); /* component number */
 273     put_bits(&s->pb, 4, 2); /* H factor */
 274     put_bits(&s->pb, 4, 2); /* V factor */
 275     put_bits(&s->pb, 8, 0); /* select matrix */
 276
 277     /* Cb component */
 278     put_bits(&s->pb, 8, 2); /* component number */
 279     put_bits(&s->pb, 4, 1); /* H factor */
 280     put_bits(&s->pb, 4, 1); /* V factor */
 281     put_bits(&s->pb, 8, 0); /* select matrix */
 282
 283     /* Cr component */
 284     put_bits(&s->pb, 8, 3); /* component number */
 285     put_bits(&s->pb, 4, 1); /* H factor */
 286     put_bits(&s->pb, 4, 1); /* V factor */
 287     put_bits(&s->pb, 8, 0); /* select matrix */
 288
 289     /* scan header */
 290     put_marker(&s->pb, SOS);
 291     put_bits(&s->pb, 16, 12); /* length */
 292     put_bits(&s->pb, 8, 3); /* 3 components */
 293
 294     /* Y component */
 295     put_bits(&s->pb, 8, 1); /* index */
 296     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 297     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 298
 299     /* Cb component */
 300     put_bits(&s->pb, 8, 2); /* index */
 301     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 302     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 303
 304     /* Cr component */
 305     put_bits(&s->pb, 8, 3); /* index */
 306     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 307     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 308
 309     put_bits(&s->pb, 8, 0); /* Ss (not used) */
 310     put_bits(&s->pb, 8, 63); /* Se (not used) */
 311     put_bits(&s->pb, 8, 0); /* (not used) */
 312 }
 313
 314 void mjpeg_picture_trailer(MpegEncContext *s)
 315 {
 316     jflush_put_bits(&s->pb);
 317     put_marker(&s->pb, EOI);
 318 }
 319
 320 static inline void encode_dc(MpegEncContext *s, int val,
 321                              UINT8 *huff_size, UINT16 *huff_code)
 322 {
 323     int mant, nbits;
 324
 325     if (val == 0) {
 326         jput_bits(&s->pb, huff_size[0], huff_code[0]);
 327     } else {
 328         mant = val;
 329         if (val < 0) {
 330             val = -val;
 331             mant--;
 332         }
 333
 334         /* compute the log (XXX: optimize) */
 335         nbits = 0;
 336         while (val != 0) {
 337             val = val >> 1;
 338             nbits++;
 339         }
 340
 341         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 342
 343         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 344     }
 345 }
 346
 347 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 348 {
 349     int mant, nbits, code, i, j;
 350     int component, dc, run, last_index, val;
 351     MJpegContext *m = s->mjpeg_ctx;
 352     UINT8 *huff_size_ac;
 353     UINT16 *huff_code_ac;
 354
 355     /* DC coef */
 356     component = (n <= 3 ? 0 : n - 4 + 1);
 357     dc = block[0]; /* overflow is impossible */
 358     val = dc - s->last_dc[component];
 359     if (n < 4) {
 360         encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 361         huff_size_ac = m->huff_size_ac_luminance;
 362         huff_code_ac = m->huff_code_ac_luminance;
 363     } else {
 364         encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 365         huff_size_ac = m->huff_size_ac_chrominance;
 366         huff_code_ac = m->huff_code_ac_chrominance;
 367     }
 368     s->last_dc[component] = dc;
 369
 370     /* AC coefs */
 371
 372     run = 0;
 373     last_index = s->block_last_index[n];
 374     for(i=1;i<=last_index;i++) {
 375         j = zigzag_direct[i];
 376         val = block[j];
 377         if (val == 0) {
 378             run++;
 379         } else {
 380             while (run >= 16) {
 381                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 382                 run -= 16;
 383             }
 384             mant = val;
 385             if (val < 0) {
 386                 val = -val;
 387                 mant--;
 388             }
 389
 390             /* compute the log (XXX: optimize) */
 391             nbits = 0;
 392             while (val != 0) {
 393                 val = val >> 1;
 394                 nbits++;
 395             }
 396             code = (run << 4) | nbits;
 397
 398             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 399
 400             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 401             run = 0;
 402         }
 403     }
 404
 405     /* output EOB only if not already 64 values */
 406     if (last_index < 63 || run != 0)
 407         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 408 }
 409
 410 void mjpeg_encode_mb(MpegEncContext *s,
 411                      DCTELEM block[6][64])
 412 {
 413     int i;
 414     for(i=0;i<6;i++) {
 415         encode_block(s, block[i], i);
 416     }
 417 }
 418
 419 /******************************************/
 420 /* decoding */
 421
 422 //#define DEBUG
 423
 424 #ifndef CONFIG_WIN32
 425
 426 #ifdef DEBUG
 427 #define dprintf(fmt,args...) printf(fmt, ## args)
 428 #else
 429 #define dprintf(fmt,args...)
 430 #endif
 431
 432 #else
 433
 434 inline void dprintf(const char* fmt,...) {}
 435
 436 #endif
 437
 438 /* compressed picture size */
 439 #define PICTURE_BUFFER_SIZE 100000
 440
 441 #define MAX_COMPONENTS 4
 442
 443 typedef struct MJpegDecodeContext {
 444     GetBitContext gb;
 445     UINT32 header_state;
 446     int start_code; /* current start code */
 447     UINT8 *buf_ptr;
 448     int buffer_size;
 449     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 450     INT16 quant_matrixes[4][64];
 451     VLC vlcs[2][4];
 452
 453     int org_width, org_height;  /* size given at codec init */
 454     int first_picture;    /* true if decoding first picture */
 455     int interlaced;     /* true if interlaced */
 456     int bottom_field;   /* true if bottom field */
 457
 458     int width, height;
 459     int nb_components;
 460     int component_id[MAX_COMPONENTS];
 461     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 462     int v_count[MAX_COMPONENTS];
 463     int h_max, v_max; /* maximum h and v counts */
 464     int quant_index[4];   /* quant table index for each component */
 465     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 466     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
 467     int linesize[MAX_COMPONENTS];
 468     DCTELEM block[64] __align8;
 469     UINT8 buffer[PICTURE_BUFFER_SIZE];
 470 } MJpegDecodeContext;
 471
 472 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
 473                       int nb_codes)
 474 {
 475     UINT8 huff_size[256];
 476     UINT16 huff_code[256];
 477
 478     memset(huff_size, 0, sizeof(huff_size));
 479     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 480
 481     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 482 }
 483
 484 static int mjpeg_decode_init(AVCodecContext *avctx)
 485 {
 486     MJpegDecodeContext *s = avctx->priv_data;
 487
 488     s->header_state = 0;
 489     s->mpeg_enc_ctx_allocated = 0;
 490     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
 491                                                  account FF 00 case */
 492     s->start_code = -1;
 493     s->buf_ptr = s->buffer;
 494     s->first_picture = 1;
 495     s->org_width = avctx->width;
 496     s->org_height = avctx->height;
 497
 498     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 499     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 500     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 501     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 502     return 0;
 503 }
 504
 505 /* quantize tables */
 506 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
 507                             UINT8 *buf, int buf_size)
 508 {
 509     int len, index, i, j;
 510     init_get_bits(&s->gb, buf, buf_size);
 511
 512     len = get_bits(&s->gb, 16);
 513     len -= 2;
 514
 515     while (len >= 65) {
 516         /* only 8 bit precision handled */
 517         if (get_bits(&s->gb, 4) != 0)
 518             return -1;
 519         index = get_bits(&s->gb, 4);
 520         if (index >= 4)
 521             return -1;
 522         dprintf("index=%d\n", index);
 523         /* read quant table */
 524         for(i=0;i<64;i++) {
 525             j = zigzag_direct[i];
 526             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 527         }
 528         len -= 65;
 529     }
 530     return 0;
 531 }
 532
 533 /* decode huffman tables and build VLC decoders */
 534 static int mjpeg_decode_dht(MJpegDecodeContext *s,
 535                             UINT8 *buf, int buf_size)
 536 {
 537     int len, index, i, class, n, v, code_max;
 538     UINT8 bits_table[17];
 539     UINT8 val_table[256];
 540
 541     init_get_bits(&s->gb, buf, buf_size);
 542
 543     len = get_bits(&s->gb, 16);
 544     len -= 2;
 545
 546     while (len > 0) {
 547         if (len < 17)
 548             return -1;
 549         class = get_bits(&s->gb, 4);
 550         if (class >= 2)
 551             return -1;
 552         index = get_bits(&s->gb, 4);
 553         if (index >= 4)
 554             return -1;
 555         n = 0;
 556         for(i=1;i<=16;i++) {
 557             bits_table[i] = get_bits(&s->gb, 8);
 558             n += bits_table[i];
 559         }
 560         len -= 17;
 561         if (len < n || n > 256)
 562             return -1;
 563
 564         code_max = 0;
 565         for(i=0;i<n;i++) {
 566             v = get_bits(&s->gb, 8);
 567             if (v > code_max)
 568                 code_max = v;
 569             val_table[i] = v;
 570         }
 571         len -= n;
 572
 573         /* build VLC and flush previous vlc if present */
 574         free_vlc(&s->vlcs[class][index]);
 575         dprintf("class=%d index=%d nb_codes=%d\n",
 576                class, index, code_max + 1);
 577         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 578     }
 579     return 0;
 580 }
 581
 582 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
 583                              UINT8 *buf, int buf_size)
 584 {
 585     int len, nb_components, i, width, height;
 586
 587     init_get_bits(&s->gb, buf, buf_size);
 588
 589     /* XXX: verify len field validity */
 590     len = get_bits(&s->gb, 16);
 591     /* only 8 bits/component accepted */
 592     if (get_bits(&s->gb, 8) != 8)
 593         return -1;
 594     height = get_bits(&s->gb, 16);
 595     width = get_bits(&s->gb, 16);
 596
 597     nb_components = get_bits(&s->gb, 8);
 598     if (nb_components <= 0 ||
 599         nb_components > MAX_COMPONENTS)
 600         return -1;
 601     s->nb_components = nb_components;
 602     s->h_max = 1;
 603     s->v_max = 1;
 604     for(i=0;i<nb_components;i++) {
 605         /* component id */
 606         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 607         s->h_count[i] = get_bits(&s->gb, 4);
 608         s->v_count[i] = get_bits(&s->gb, 4);
 609         /* compute hmax and vmax (only used in interleaved case) */
 610         if (s->h_count[i] > s->h_max)
 611             s->h_max = s->h_count[i];
 612         if (s->v_count[i] > s->v_max)
 613             s->v_max = s->v_count[i];
 614         s->quant_index[i] = get_bits(&s->gb, 8);
 615         if (s->quant_index[i] >= 4)
 616             return -1;
 617         dprintf("component %d %d:%d\n", i, s->h_count[i], s->v_count[i]);
 618     }
 619
 620     /* if different size, realloc/alloc picture */
 621     /* XXX: also check h_count and v_count */
 622     if (width != s->width || height != s->height) {
 623         for(i=0;i<MAX_COMPONENTS;i++) {
 624             free(s->current_picture[i]);
 625             s->current_picture[i] = NULL;
 626         }
 627         s->width = width;
 628         s->height = height;
 629         /* test interlaced mode */
 630         if (s->first_picture &&
 631             s->org_height != 0 &&
 632             s->height < ((s->org_height * 3) / 4)) {
 633             s->interlaced = 1;
 634             s->bottom_field = 0;
 635         }
 636
 637         for(i=0;i<nb_components;i++) {
 638             int w, h, hh, vv;
 639             hh = s->h_max / s->h_count[i];
 640             vv = s->v_max / s->v_count[i];
 641             w = (s->width + 8 * hh - 1) / (8 * hh);
 642             h = (s->height + 8 * vv - 1) / (8 * vv);
 643             w = w * 8;
 644             h = h * 8;
 645             if (s->interlaced)
 646                 w *= 2;
 647             s->linesize[i] = w;
 648             /* memory test is done in mjpeg_decode_sos() */
 649             s->current_picture[i] = av_mallocz(w * h);
 650         }
 651         s->first_picture = 0;
 652     }
 653
 654     return 0;
 655 }
 656
 657 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
 658 {
 659     VLC *dc_vlc;
 660     int code, diff;
 661
 662     dc_vlc = &s->vlcs[0][dc_index];
 663     code = get_vlc(&s->gb, dc_vlc);
 664     if (code < 0)
 665         return 0xffff;
 666     if (code == 0) {
 667         diff = 0;
 668     } else {
 669         diff = get_bits(&s->gb, code);
 670         if ((diff & (1 << (code - 1))) == 0)
 671             diff = (-1 << code) | (diff + 1);
 672     }
 673     return diff;
 674 }
 675
 676 /* decode block and dequantize */
 677 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 678                         int component, int dc_index, int ac_index, int quant_index)
 679 {
 680     int nbits, code, i, j, level;
 681     int run, val;
 682     VLC *ac_vlc;
 683     INT16 *quant_matrix;
 684
 685     quant_matrix = s->quant_matrixes[quant_index];
 686     /* DC coef */
 687     val = decode_dc(s, dc_index);
 688     if (val == 0xffff) {
 689         dprintf("error dc\n");
 690         return -1;
 691     }
 692     val = val * quant_matrix[0] + s->last_dc[component];
 693     s->last_dc[component] = val;
 694     block[0] = val;
 695     /* AC coefs */
 696     ac_vlc = &s->vlcs[1][ac_index];
 697     i = 1;
 698     for(;;) {
 699         code = get_vlc(&s->gb, ac_vlc);
 700         if (code < 0) {
 701             dprintf("error ac\n");
 702             return -1;
 703         }
 704         /* EOB */
 705         if (code == 0)
 706             break;
 707         if (code == 0xf0) {
 708             i += 16;
 709         } else {
 710             run = code >> 4;
 711             nbits = code & 0xf;
 712             level = get_bits(&s->gb, nbits);
 713             if ((level & (1 << (nbits - 1))) == 0)
 714                 level = (-1 << nbits) | (level + 1);
 715             i += run;
 716             if (i >= 64) {
 717                 dprintf("error count: %d\n", i);
 718                 return -1;
 719             }
 720             j = zigzag_direct[i];
 721             block[j] = level * quant_matrix[j];
 722             i++;
 723             if (i >= 64)
 724                 break;
 725         }
 726     }
 727     return 0;
 728 }
 729
 730 static int mjpeg_decode_sos(MJpegDecodeContext *s,
 731                             UINT8 *buf, int buf_size)
 732 {
 733     int len, nb_components, i, j, n, h, v, ret;
 734     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 735     int comp_index[4];
 736     int dc_index[4];
 737     int ac_index[4];
 738     int nb_blocks[4];
 739     int h_count[4];
 740     int v_count[4];
 741
 742     init_get_bits(&s->gb, buf, buf_size);
 743     /* XXX: verify len field validity */
 744     len = get_bits(&s->gb, 16);
 745     nb_components = get_bits(&s->gb, 8);
 746     /* XXX: only interleaved scan accepted */
 747     if (nb_components != 3)
 748         return -1;
 749     vmax = 0;
 750     hmax = 0;
 751     for(i=0;i<nb_components;i++) {
 752         id = get_bits(&s->gb, 8) - 1;
 753         /* find component index */
 754         for(index=0;index<s->nb_components;index++)
 755             if (id == s->component_id[index])
 756                 break;
 757         if (index == s->nb_components)
 758             return -1;
 759
 760         comp_index[i] = index;
 761         nb_blocks[i] = s->h_count[index] * s->v_count[index];
 762         h_count[i] = s->h_count[index];
 763         v_count[i] = s->v_count[index];
 764
 765         dc_index[i] = get_bits(&s->gb, 4);
 766         if (dc_index[i] >= 4)
 767             return -1;
 768         ac_index[i] = get_bits(&s->gb, 4);
 769         if (ac_index[i] >= 4)
 770             return -1;
 771     }
 772     get_bits(&s->gb, 8); /* Ss */
 773     get_bits(&s->gb, 8); /* Se */
 774     get_bits(&s->gb, 8); /* not used */
 775
 776     for(i=0;i<nb_components;i++)
 777         s->last_dc[i] = 1024;
 778
 779     if (nb_components > 1) {
 780         /* interleaved stream */
 781         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
 782         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
 783     } else {
 784         h = s->h_max / s->h_count[comp_index[0]];
 785         v = s->v_max / s->v_count[comp_index[0]];
 786         mb_width = (s->width + h * 8 - 1) / (h * 8);
 787         mb_height = (s->height + v * 8 - 1) / (v * 8);
 788         nb_blocks[0] = 1;
 789         h_count[0] = 1;
 790         v_count[0] = 1;
 791     }
 792
 793     for(mb_y = 0; mb_y < mb_height; mb_y++) {
 794         for(mb_x = 0; mb_x < mb_width; mb_x++) {
 795             for(i=0;i<nb_components;i++) {
 796                 UINT8 *ptr;
 797                 int x, y, c;
 798                 n = nb_blocks[i];
 799                 c = comp_index[i];
 800                 h = h_count[i];
 801                 v = v_count[i];
 802                 x = 0;
 803                 y = 0;
 804                 for(j=0;j<n;j++) {
 805                     memset(s->block, 0, sizeof(s->block));
 806                     if (decode_block(s, s->block, i,
 807                                      dc_index[i], ac_index[i],
 808                                      s->quant_index[c]) < 0) {
 809                         dprintf("error %d %d\n", mb_y, mb_x);
 810                         ret = -1;
 811                         goto the_end;
 812                     }
 813                     ff_idct (s->block);
 814                     ptr = s->current_picture[c] +
 815                         (s->linesize[c] * (v * mb_y + y) * 8) +
 816                         (h * mb_x + x) * 8;
 817                     if (s->interlaced && s->bottom_field)
 818                         ptr += s->linesize[c] >> 1;
 819                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
 820                     if (++x == h) {
 821                         x = 0;
 822                         y++;
 823                     }
 824                 }
 825             }
 826         }
 827     }
 828     ret = 0;
 829  the_end:
 830     emms_c();
 831     return ret;
 832 }
 833
 834 /* return the 8 bit start code value and update the search
 835    state. Return -1 if no start code found */
 836 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end,
 837                        UINT32 *header_state)
 838 {
 839     UINT8 *buf_ptr;
 840     unsigned int state, v;
 841     int val;
 842
 843     state = *header_state;
 844     buf_ptr = *pbuf_ptr;
 845     if (state) {
 846         /* get marker */
 847     found:
 848         if (buf_ptr < buf_end) {
 849             val = *buf_ptr++;
 850             state = 0;
 851         } else {
 852             val = -1;
 853         }
 854     } else {
 855         while (buf_ptr < buf_end) {
 856             v = *buf_ptr++;
 857             if (v == 0xff) {
 858                 state = 1;
 859                 goto found;
 860             }
 861         }
 862         val = -1;
 863     }
 864     *pbuf_ptr = buf_ptr;
 865     *header_state = state;
 866     return val;
 867 }
 868
 869 static int mjpeg_decode_frame(AVCodecContext *avctx,
 870                               void *data, int *data_size,
 871                               UINT8 *buf, int buf_size)
 872 {
 873     MJpegDecodeContext *s = avctx->priv_data;
 874     UINT8 *buf_end, *buf_ptr, *buf_start;
 875     int len, code, start_code, input_size, i;
 876     AVPicture *picture = data;
 877
 878     *data_size = 0;
 879
 880     /* no supplementary picture */
 881     if (buf_size == 0)
 882         return 0;
 883
 884     buf_ptr = buf;
 885     buf_end = buf + buf_size;
 886     while (buf_ptr < buf_end) {
 887         buf_start = buf_ptr;
 888         /* find start next marker */
 889         code = find_marker(&buf_ptr, buf_end, &s->header_state);
 890         /* copy to buffer */
 891         len = buf_ptr - buf_start;
 892         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
 893             /* data too big : flush */
 894             s->buf_ptr = s->buffer;
 895             if (code > 0)
 896                 s->start_code = code;
 897         } else {
 898             memcpy(s->buf_ptr, buf_start, len);
 899             s->buf_ptr += len;
 900             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
 901             if (code == 0) {
 902                 s->buf_ptr--;
 903             } else if (code > 0) {
 904                 /* prepare data for next start code */
 905                 input_size = s->buf_ptr - s->buffer;
 906                 start_code = s->start_code;
 907                 s->buf_ptr = s->buffer;
 908                 s->start_code = code;
 909                 dprintf("marker=%x\n", start_code);
 910                 switch(start_code) {
 911                 case SOI:
 912                     /* nothing to do on SOI */
 913                     break;
 914                 case DQT:
 915                     mjpeg_decode_dqt(s, s->buffer, input_size);
 916                     break;
 917                 case DHT:
 918                     mjpeg_decode_dht(s, s->buffer, input_size);
 919                     break;
 920                 case SOF0:
 921                     mjpeg_decode_sof0(s, s->buffer, input_size);
 922                     break;
 923                 case SOS:
 924                     mjpeg_decode_sos(s, s->buffer, input_size);
 925                     if (s->start_code == EOI) {
 926                         int l;
 927                         if (s->interlaced) {
 928                             s->bottom_field ^= 1;
 929                             /* if not bottom field, do not output image yet */
 930                             if (s->bottom_field)
 931                                 goto the_end;
 932                         }
 933                         for(i=0;i<3;i++) {
 934                             picture->data[i] = s->current_picture[i];
 935                             l = s->linesize[i];
 936                             if (s->interlaced)
 937                                 l >>= 1;
 938                             picture->linesize[i] = l;
 939                         }
 940                         *data_size = sizeof(AVPicture);
 941                         avctx->height = s->height;
 942                         if (s->interlaced)
 943                             avctx->height *= 2;
 944                         avctx->width = s->width;
 945                         /* XXX: not complete test ! */
 946                         switch((s->h_count[0] << 4) | s->v_count[0]) {
 947                         case 0x11:
 948                             avctx->pix_fmt = PIX_FMT_YUV444P;
 949                             break;
 950                         case 0x21:
 951                             avctx->pix_fmt = PIX_FMT_YUV422P;
 952                             break;
 953                         default:
 954                         case 0x22:
 955                             avctx->pix_fmt = PIX_FMT_YUV420P;
 956                             break;
 957                         }
 958                         /* dummy quality */
 959                         /* XXX: infer it with matrix */
 960                         avctx->quality = 3;
 961                         goto the_end;
 962                     }
 963                     break;
 964                 }
 965             }
 966         }
 967     }
 968  the_end:
 969     return buf_ptr - buf;
 970 }
 971
 972 static int mjpeg_decode_end(AVCodecContext *avctx)
 973 {
 974     MJpegDecodeContext *s = avctx->priv_data;
 975     int i, j;
 976
 977     for(i=0;i<MAX_COMPONENTS;i++)
 978         free(s->current_picture[i]);
 979     for(i=0;i<2;i++) {
 980         for(j=0;j<4;j++)
 981             free_vlc(&s->vlcs[i][j]);
 982     }
 983     return 0;
 984 }
 985
 986 AVCodec mjpeg_decoder = {
 987     "mjpeg",
 988     CODEC_TYPE_VIDEO,
 989     CODEC_ID_MJPEG,
 990     sizeof(MJpegDecodeContext),
 991     mjpeg_decode_init,
 992     NULL,
 993     mjpeg_decode_end,
 994     mjpeg_decode_frame,
 995 };