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

   1 /*
   2  * MJPEG encoder and decoder
   3  * Copyright (c) 2000, 2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library 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 GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  * Support for external huffman table, various fixes (AVID workaround),
  20  * aspecting and new decode_frame mechanism
  21  *                                  by Alex Beregszaszi <alex@naxine.org>
  22  */
  23 //#define DEBUG
  24 #include "avcodec.h"
  25 #include "dsputil.h"
  26 #include "mpegvideo.h"
  27
  28 /* use two quantizer tables (one for luminance and one for chrominance) */
  29 /* not yet working */
  30 #undef TWOMATRIXES
  31
  32 typedef struct MJpegContext {
  33     UINT8 huff_size_dc_luminance[12];
  34     UINT16 huff_code_dc_luminance[12];
  35     UINT8 huff_size_dc_chrominance[12];
  36     UINT16 huff_code_dc_chrominance[12];
  37
  38     UINT8 huff_size_ac_luminance[256];
  39     UINT16 huff_code_ac_luminance[256];
  40     UINT8 huff_size_ac_chrominance[256];
  41     UINT16 huff_code_ac_chrominance[256];
  42 } MJpegContext;
  43
  44 /* JPEG marker codes */
  45 typedef enum {
  46     /* start of frame */
  47     SOF0  = 0xc0,       /* baseline */
  48     SOF1  = 0xc1,       /* extended sequential, huffman */
  49     SOF2  = 0xc2,       /* progressive, huffman */
  50     SOF3  = 0xc3,       /* lossless, huffman */
  51
  52     SOF5  = 0xc5,       /* differential sequential, huffman */
  53     SOF6  = 0xc6,       /* differential progressive, huffman */
  54     SOF7  = 0xc7,       /* differential lossless, huffman */
  55     JPG   = 0xc8,       /* reserved for JPEG extension */
  56     SOF9  = 0xc9,       /* extended sequential, arithmetic */
  57     SOF10 = 0xca,       /* progressive, arithmetic */
  58     SOF11 = 0xcb,       /* lossless, arithmetic */
  59
  60     SOF13 = 0xcd,       /* differential sequential, arithmetic */
  61     SOF14 = 0xce,       /* differential progressive, arithmetic */
  62     SOF15 = 0xcf,       /* differential lossless, arithmetic */
  63
  64     DHT   = 0xc4,       /* define huffman tables */
  65
  66     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
  67
  68     /* restart with modulo 8 count "m" */
  69     RST0  = 0xd0,
  70     RST1  = 0xd1,
  71     RST2  = 0xd2,
  72     RST3  = 0xd3,
  73     RST4  = 0xd4,
  74     RST5  = 0xd5,
  75     RST6  = 0xd6,
  76     RST7  = 0xd7,
  77
  78     SOI   = 0xd8,       /* start of image */
  79     EOI   = 0xd9,       /* end of image */
  80     SOS   = 0xda,       /* start of scan */
  81     DQT   = 0xdb,       /* define quantization tables */
  82     DNL   = 0xdc,       /* define number of lines */
  83     DRI   = 0xdd,       /* define restart interval */
  84     DHP   = 0xde,       /* define hierarchical progression */
  85     EXP   = 0xdf,       /* expand reference components */
  86
  87     APP0  = 0xe0,
  88     APP1  = 0xe1,
  89     APP2  = 0xe2,
  90     APP3  = 0xe3,
  91     APP4  = 0xe4,
  92     APP5  = 0xe5,
  93     APP6  = 0xe6,
  94     APP7  = 0xe7,
  95     APP8  = 0xe8,
  96     APP9  = 0xe9,
  97     APP10 = 0xea,
  98     APP11 = 0xeb,
  99     APP12 = 0xec,
 100     APP13 = 0xed,
 101     APP14 = 0xee,
 102     APP15 = 0xef,
 103
 104     JPG0  = 0xf0,
 105     JPG1  = 0xf1,
 106     JPG2  = 0xf2,
 107     JPG3  = 0xf3,
 108     JPG4  = 0xf4,
 109     JPG5  = 0xf5,
 110     JPG6  = 0xf6,
 111     JPG7  = 0xf7,
 112     JPG8  = 0xf8,
 113     JPG9  = 0xf9,
 114     JPG10 = 0xfa,
 115     JPG11 = 0xfb,
 116     JPG12 = 0xfc,
 117     JPG13 = 0xfd,
 118
 119     COM   = 0xfe,       /* comment */
 120
 121     TEM   = 0x01,       /* temporary private use for arithmetic coding */
 122
 123     /* 0x02 -> 0xbf reserved */
 124 } JPEG_MARKER;
 125
 126 #if 0
 127 /* These are the sample quantization tables given in JPEG spec section K.1.
 128  * The spec says that the values given produce "good" quality, and
 129  * when divided by 2, "very good" quality.
 130  */
 131 static const unsigned char std_luminance_quant_tbl[64] = {
 132     16,  11,  10,  16,  24,  40,  51,  61,
 133     12,  12,  14,  19,  26,  58,  60,  55,
 134     14,  13,  16,  24,  40,  57,  69,  56,
 135     14,  17,  22,  29,  51,  87,  80,  62,
 136     18,  22,  37,  56,  68, 109, 103,  77,
 137     24,  35,  55,  64,  81, 104, 113,  92,
 138     49,  64,  78,  87, 103, 121, 120, 101,
 139     72,  92,  95,  98, 112, 100, 103,  99
 140 };
 141 static const unsigned char std_chrominance_quant_tbl[64] = {
 142     17,  18,  24,  47,  99,  99,  99,  99,
 143     18,  21,  26,  66,  99,  99,  99,  99,
 144     24,  26,  56,  99,  99,  99,  99,  99,
 145     47,  66,  99,  99,  99,  99,  99,  99,
 146     99,  99,  99,  99,  99,  99,  99,  99,
 147     99,  99,  99,  99,  99,  99,  99,  99,
 148     99,  99,  99,  99,  99,  99,  99,  99,
 149     99,  99,  99,  99,  99,  99,  99,  99
 150 };
 151 #endif
 152
 153 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 154 /* IMPORTANT: these are only valid for 8-bit data precision! */
 155 static const UINT8 bits_dc_luminance[17] =
 156 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
 157 static const UINT8 val_dc_luminance[] =
 158 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 159
 160 static const UINT8 bits_dc_chrominance[17] =
 161 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 162 static const UINT8 val_dc_chrominance[] =
 163 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 164
 165 static const UINT8 bits_ac_luminance[17] =
 166 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 167 static const UINT8 val_ac_luminance[] =
 168 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 169   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 170   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 171   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 172   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 173   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 174   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 175   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 176   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 177   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 178   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 179   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 180   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 181   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 182   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 183   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 184   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 185   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 186   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 187   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 188   0xf9, 0xfa
 189 };
 190
 191 static const UINT8 bits_ac_chrominance[17] =
 192 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 193
 194 static const UINT8 val_ac_chrominance[] =
 195 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 196   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 197   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 198   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 199   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 200   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 201   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 202   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 203   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 204   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 205   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 206   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 207   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 208   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 209   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 210   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 211   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 212   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 213   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 214   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 215   0xf9, 0xfa
 216 };
 217
 218 /* isn't this function nicer than the one in the libjpeg ? */
 219 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
 220                                 const UINT8 *bits_table, const UINT8 *val_table)
 221 {
 222     int i, j, k,nb, code, sym;
 223
 224     code = 0;
 225     k = 0;
 226     for(i=1;i<=16;i++) {
 227         nb = bits_table[i];
 228         for(j=0;j<nb;j++) {
 229             sym = val_table[k++];
 230             huff_size[sym] = i;
 231             huff_code[sym] = code;
 232             code++;
 233         }
 234         code <<= 1;
 235     }
 236 }
 237
 238 int mjpeg_init(MpegEncContext *s)
 239 {
 240     MJpegContext *m;
 241
 242     m = av_malloc(sizeof(MJpegContext));
 243     if (!m)
 244         return -1;
 245
 246     s->min_qcoeff=-1023;
 247     s->max_qcoeff= 1023;
 248     s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
 249
 250     /* build all the huffman tables */
 251     build_huffman_codes(m->huff_size_dc_luminance,
 252                         m->huff_code_dc_luminance,
 253                         bits_dc_luminance,
 254                         val_dc_luminance);
 255     build_huffman_codes(m->huff_size_dc_chrominance,
 256                         m->huff_code_dc_chrominance,
 257                         bits_dc_chrominance,
 258                         val_dc_chrominance);
 259     build_huffman_codes(m->huff_size_ac_luminance,
 260                         m->huff_code_ac_luminance,
 261                         bits_ac_luminance,
 262                         val_ac_luminance);
 263     build_huffman_codes(m->huff_size_ac_chrominance,
 264                         m->huff_code_ac_chrominance,
 265                         bits_ac_chrominance,
 266                         val_ac_chrominance);
 267
 268     s->mjpeg_ctx = m;
 269     return 0;
 270 }
 271
 272 void mjpeg_close(MpegEncContext *s)
 273 {
 274     av_free(s->mjpeg_ctx);
 275 }
 276
 277 static inline void put_marker(PutBitContext *p, int code)
 278 {
 279     put_bits(p, 8, 0xff);
 280     put_bits(p, 8, code);
 281 }
 282
 283 /* table_class: 0 = DC coef, 1 = AC coefs */
 284 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 285                              const UINT8 *bits_table, const UINT8 *value_table)
 286 {
 287     PutBitContext *p = &s->pb;
 288     int n, i;
 289
 290     put_bits(p, 4, table_class);
 291     put_bits(p, 4, table_id);
 292
 293     n = 0;
 294     for(i=1;i<=16;i++) {
 295         n += bits_table[i];
 296         put_bits(p, 8, bits_table[i]);
 297     }
 298
 299     for(i=0;i<n;i++)
 300         put_bits(p, 8, value_table[i]);
 301
 302     return n + 17;
 303 }
 304
 305 static void jpeg_table_header(MpegEncContext *s)
 306 {
 307     PutBitContext *p = &s->pb;
 308     int i, j, size;
 309     UINT8 *ptr;
 310
 311     /* quant matrixes */
 312     put_marker(p, DQT);
 313 #ifdef TWOMATRIXES
 314     put_bits(p, 16, 2 + 2 * (1 + 64));
 315 #else
 316     put_bits(p, 16, 2 + 1 * (1 + 64));
 317 #endif
 318     put_bits(p, 4, 0); /* 8 bit precision */
 319     put_bits(p, 4, 0); /* table 0 */
 320     for(i=0;i<64;i++) {
 321         j = s->intra_scantable.permutated[i];
 322         put_bits(p, 8, s->intra_matrix[j]);
 323     }
 324 #ifdef TWOMATRIXES
 325     put_bits(p, 4, 0); /* 8 bit precision */
 326     put_bits(p, 4, 1); /* table 1 */
 327     for(i=0;i<64;i++) {
 328         j = s->intra_scantable.permutated[i];
 329         put_bits(p, 8, s->chroma_intra_matrix[j]);
 330     }
 331 #endif
 332
 333     /* huffman table */
 334     put_marker(p, DHT);
 335     flush_put_bits(p);
 336     ptr = pbBufPtr(p);
 337     put_bits(p, 16, 0); /* patched later */
 338     size = 2;
 339     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 340     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 341
 342     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 343     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 344     ptr[0] = size >> 8;
 345     ptr[1] = size;
 346 }
 347
 348 static void jpeg_put_comments(MpegEncContext *s)
 349 {
 350     PutBitContext *p = &s->pb;
 351     int size;
 352     UINT8 *ptr;
 353
 354     if (s->aspect_ratio_info)
 355     {
 356     /* JFIF header */
 357     put_marker(p, APP0);
 358     put_bits(p, 16, 16);
 359     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
 360     put_bits(p, 16, 0x0201); /* v 1.02 */
 361     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
 362     switch(s->aspect_ratio_info)
 363     {
 364         case FF_ASPECT_4_3_625:
 365         case FF_ASPECT_4_3_525:
 366             put_bits(p, 16, 4);
 367             put_bits(p, 16, 3);
 368             break;
 369         case FF_ASPECT_16_9_625:
 370         case FF_ASPECT_16_9_525:
 371             put_bits(p, 16, 16);
 372             put_bits(p, 16, 9);
 373             break;
 374         case FF_ASPECT_EXTENDED:
 375             put_bits(p, 16, s->aspected_width);
 376             put_bits(p, 16, s->aspected_height);
 377             break;
 378         case FF_ASPECT_SQUARE:
 379         default:
 380             put_bits(p, 16, 1); /* aspect: 1:1 */
 381             put_bits(p, 16, 1);
 382             break;
 383     }
 384     put_bits(p, 8, 0); /* thumbnail width */
 385     put_bits(p, 8, 0); /* thumbnail height */
 386     }
 387
 388     /* comment */
 389     if(!ff_bit_exact){
 390         put_marker(p, COM);
 391         flush_put_bits(p);
 392         ptr = pbBufPtr(p);
 393         put_bits(p, 16, 0); /* patched later */
 394 #define MJPEG_VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR
 395         put_string(p, MJPEG_VERSION);
 396         size = strlen(MJPEG_VERSION)+3;
 397 #undef MJPEG_VERSION
 398         ptr[0] = size >> 8;
 399         ptr[1] = size;
 400     }
 401 }
 402
 403 void mjpeg_picture_header(MpegEncContext *s)
 404 {
 405     put_marker(&s->pb, SOI);
 406
 407     if (!s->mjpeg_data_only_frames)
 408     {
 409     jpeg_put_comments(s);
 410
 411     if (s->mjpeg_write_tables) jpeg_table_header(s);
 412
 413     put_marker(&s->pb, SOF0);
 414
 415     put_bits(&s->pb, 16, 17);
 416     put_bits(&s->pb, 8, 8); /* 8 bits/component */
 417     put_bits(&s->pb, 16, s->height);
 418     put_bits(&s->pb, 16, s->width);
 419     put_bits(&s->pb, 8, 3); /* 3 components */
 420
 421     /* Y component */
 422     put_bits(&s->pb, 8, 1); /* component number */
 423     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
 424     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
 425     put_bits(&s->pb, 8, 0); /* select matrix */
 426
 427     /* Cb component */
 428     put_bits(&s->pb, 8, 2); /* component number */
 429     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
 430     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 431 #ifdef TWOMATRIXES
 432     put_bits(&s->pb, 8, 1); /* select matrix */
 433 #else
 434     put_bits(&s->pb, 8, 0); /* select matrix */
 435 #endif
 436
 437     /* Cr component */
 438     put_bits(&s->pb, 8, 3); /* component number */
 439     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
 440     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 441 #ifdef TWOMATRIXES
 442     put_bits(&s->pb, 8, 1); /* select matrix */
 443 #else
 444     put_bits(&s->pb, 8, 0); /* select matrix */
 445 #endif
 446     }
 447
 448     /* scan header */
 449     put_marker(&s->pb, SOS);
 450     put_bits(&s->pb, 16, 12); /* length */
 451     put_bits(&s->pb, 8, 3); /* 3 components */
 452
 453     /* Y component */
 454     put_bits(&s->pb, 8, 1); /* index */
 455     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 456     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 457
 458     /* Cb component */
 459     put_bits(&s->pb, 8, 2); /* index */
 460     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 461     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 462
 463     /* Cr component */
 464     put_bits(&s->pb, 8, 3); /* index */
 465     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 466     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 467
 468     put_bits(&s->pb, 8, 0); /* Ss (not used) */
 469     put_bits(&s->pb, 8, 63); /* Se (not used) */
 470     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 471 }
 472
 473 void mjpeg_picture_trailer(MpegEncContext *s)
 474 {
 475     jflush_put_bits(&s->pb);
 476     put_marker(&s->pb, EOI);
 477 }
 478
 479 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 480                                    UINT8 *huff_size, UINT16 *huff_code)
 481 {
 482     int mant, nbits;
 483
 484     if (val == 0) {
 485         jput_bits(&s->pb, huff_size[0], huff_code[0]);
 486     } else {
 487         mant = val;
 488         if (val < 0) {
 489             val = -val;
 490             mant--;
 491         }
 492
 493         /* compute the log (XXX: optimize) */
 494         nbits = 0;
 495         while (val != 0) {
 496             val = val >> 1;
 497             nbits++;
 498         }
 499
 500         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 501
 502         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 503     }
 504 }
 505
 506 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 507 {
 508     int mant, nbits, code, i, j;
 509     int component, dc, run, last_index, val;
 510     MJpegContext *m = s->mjpeg_ctx;
 511     UINT8 *huff_size_ac;
 512     UINT16 *huff_code_ac;
 513
 514     /* DC coef */
 515     component = (n <= 3 ? 0 : n - 4 + 1);
 516     dc = block[0]; /* overflow is impossible */
 517     val = dc - s->last_dc[component];
 518     if (n < 4) {
 519         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 520         huff_size_ac = m->huff_size_ac_luminance;
 521         huff_code_ac = m->huff_code_ac_luminance;
 522     } else {
 523         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 524         huff_size_ac = m->huff_size_ac_chrominance;
 525         huff_code_ac = m->huff_code_ac_chrominance;
 526     }
 527     s->last_dc[component] = dc;
 528
 529     /* AC coefs */
 530
 531     run = 0;
 532     last_index = s->block_last_index[n];
 533     for(i=1;i<=last_index;i++) {
 534         j = s->intra_scantable.permutated[i];
 535         val = block[j];
 536         if (val == 0) {
 537             run++;
 538         } else {
 539             while (run >= 16) {
 540                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 541                 run -= 16;
 542             }
 543             mant = val;
 544             if (val < 0) {
 545                 val = -val;
 546                 mant--;
 547             }
 548
 549             /* compute the log (XXX: optimize) */
 550             nbits = 0;
 551             while (val != 0) {
 552                 val = val >> 1;
 553                 nbits++;
 554             }
 555             code = (run << 4) | nbits;
 556
 557             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 558
 559             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 560             run = 0;
 561         }
 562     }
 563
 564     /* output EOB only if not already 64 values */
 565     if (last_index < 63 || run != 0)
 566         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 567 }
 568
 569 void mjpeg_encode_mb(MpegEncContext *s,
 570                      DCTELEM block[6][64])
 571 {
 572     int i;
 573     for(i=0;i<6;i++) {
 574         encode_block(s, block[i], i);
 575     }
 576 }
 577
 578 /******************************************/
 579 /* decoding */
 580
 581 #define MAX_COMPONENTS 4
 582
 583 typedef struct MJpegDecodeContext {
 584     AVCodecContext *avctx;
 585     GetBitContext gb;
 586     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 587
 588     int start_code; /* current start code */
 589     int buffer_size;
 590     UINT8 *buffer;
 591
 592     INT16 quant_matrixes[4][64];
 593     VLC vlcs[2][4];
 594
 595     int org_width, org_height;  /* size given at codec init */
 596     int first_picture;    /* true if decoding first picture */
 597     int interlaced;     /* true if interlaced */
 598     int bottom_field;   /* true if bottom field */
 599
 600     int width, height;
 601     int nb_components;
 602     int component_id[MAX_COMPONENTS];
 603     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 604     int v_count[MAX_COMPONENTS];
 605     int h_max, v_max; /* maximum h and v counts */
 606     int quant_index[4];   /* quant table index for each component */
 607     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 608     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
 609     int linesize[MAX_COMPONENTS];
 610     DCTELEM block[64] __align8;
 611     ScanTable scantable;
 612     void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 613
 614     int restart_interval;
 615     int restart_count;
 616
 617     int buggy_avid;
 618     int interlace_polarity;
 619 } MJpegDecodeContext;
 620
 621 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 622
 623 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
 624                       int nb_codes)
 625 {
 626     UINT8 huff_size[256];
 627     UINT16 huff_code[256];
 628
 629     memset(huff_size, 0, sizeof(huff_size));
 630     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 631
 632     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 633 }
 634
 635 static int mjpeg_decode_init(AVCodecContext *avctx)
 636 {
 637     MJpegDecodeContext *s = avctx->priv_data;
 638     MpegEncContext s2;
 639
 640     s->avctx = avctx;
 641
 642     /* ugly way to get the idct & scantable */
 643     memset(&s2, 0, sizeof(MpegEncContext));
 644     s2.flags= avctx->flags;
 645     s2.avctx= avctx;
 646 //    s2->out_format = FMT_MJPEG;
 647     s2.width = 8;
 648     s2.height = 8;
 649     if (MPV_common_init(&s2) < 0)
 650        return -1;
 651     s->scantable= s2.intra_scantable;
 652     s->idct_put= s2.idct_put;
 653     MPV_common_end(&s2);
 654
 655     s->mpeg_enc_ctx_allocated = 0;
 656     s->buffer_size = 102400; /* smaller buffer should be enough,
 657                                 but photojpg files could ahive bigger sizes */
 658     s->buffer = av_malloc(s->buffer_size);
 659     s->start_code = -1;
 660     s->first_picture = 1;
 661     s->org_width = avctx->width;
 662     s->org_height = avctx->height;
 663
 664     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 665     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 666     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 667     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 668
 669     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 670     {
 671         printf("mjpeg: using external huffman table\n");
 672         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
 673         mjpeg_decode_dht(s);
 674         /* should check for error - but dunno */
 675     }
 676
 677     return 0;
 678 }
 679
 680 /* quantize tables */
 681 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 682 {
 683     int len, index, i, j;
 684
 685     len = get_bits(&s->gb, 16) - 2;
 686
 687     while (len >= 65) {
 688         /* only 8 bit precision handled */
 689         if (get_bits(&s->gb, 4) != 0)
 690         {
 691             dprintf("dqt: 16bit precision\n");
 692             return -1;
 693         }
 694         index = get_bits(&s->gb, 4);
 695         if (index >= 4)
 696             return -1;
 697         dprintf("index=%d\n", index);
 698         /* read quant table */
 699         for(i=0;i<64;i++) {
 700             j = s->scantable.permutated[i];
 701             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 702         }
 703         len -= 65;
 704     }
 705
 706     return 0;
 707 }
 708
 709 /* decode huffman tables and build VLC decoders */
 710 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 711 {
 712     int len, index, i, class, n, v, code_max;
 713     UINT8 bits_table[17];
 714     UINT8 val_table[256];
 715
 716     len = get_bits(&s->gb, 16) - 2;
 717
 718     while (len > 0) {
 719         if (len < 17)
 720             return -1;
 721         class = get_bits(&s->gb, 4);
 722         if (class >= 2)
 723             return -1;
 724         index = get_bits(&s->gb, 4);
 725         if (index >= 4)
 726             return -1;
 727         n = 0;
 728         for(i=1;i<=16;i++) {
 729             bits_table[i] = get_bits(&s->gb, 8);
 730             n += bits_table[i];
 731         }
 732         len -= 17;
 733         if (len < n || n > 256)
 734             return -1;
 735
 736         code_max = 0;
 737         for(i=0;i<n;i++) {
 738             v = get_bits(&s->gb, 8);
 739             if (v > code_max)
 740                 code_max = v;
 741             val_table[i] = v;
 742         }
 743         len -= n;
 744
 745         /* build VLC and flush previous vlc if present */
 746         free_vlc(&s->vlcs[class][index]);
 747         dprintf("class=%d index=%d nb_codes=%d\n",
 748                class, index, code_max + 1);
 749         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 750     }
 751     return 0;
 752 }
 753
 754 static int mjpeg_decode_sof0(MJpegDecodeContext *s)
 755 {
 756     int len, nb_components, i, width, height;
 757
 758     /* XXX: verify len field validity */
 759     len = get_bits(&s->gb, 16);
 760     /* only 8 bits/component accepted */
 761     if (get_bits(&s->gb, 8) != 8)
 762         return -1;
 763     height = get_bits(&s->gb, 16);
 764     width = get_bits(&s->gb, 16);
 765     dprintf("sof0: picture: %dx%d\n", width, height);
 766
 767     nb_components = get_bits(&s->gb, 8);
 768     if (nb_components <= 0 ||
 769         nb_components > MAX_COMPONENTS)
 770         return -1;
 771     s->nb_components = nb_components;
 772     s->h_max = 1;
 773     s->v_max = 1;
 774     for(i=0;i<nb_components;i++) {
 775         /* component id */
 776         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 777         s->h_count[i] = get_bits(&s->gb, 4);
 778         s->v_count[i] = get_bits(&s->gb, 4);
 779         /* compute hmax and vmax (only used in interleaved case) */
 780         if (s->h_count[i] > s->h_max)
 781             s->h_max = s->h_count[i];
 782         if (s->v_count[i] > s->v_max)
 783             s->v_max = s->v_count[i];
 784         s->quant_index[i] = get_bits(&s->gb, 8);
 785         if (s->quant_index[i] >= 4)
 786             return -1;
 787         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
 788             s->v_count[i], s->component_id[i], s->quant_index[i]);
 789     }
 790
 791     /* if different size, realloc/alloc picture */
 792     /* XXX: also check h_count and v_count */
 793     if (width != s->width || height != s->height) {
 794         for(i=0;i<MAX_COMPONENTS;i++)
 795             av_freep(&s->current_picture[i]);
 796         s->width = width;
 797         s->height = height;
 798         /* test interlaced mode */
 799         if (s->first_picture &&
 800             s->org_height != 0 &&
 801             s->height < ((s->org_height * 3) / 4)) {
 802             s->interlaced = 1;
 803 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
 804             s->bottom_field = 0;
 805         }
 806
 807         for(i=0;i<nb_components;i++) {
 808             int w, h;
 809             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
 810             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
 811             w = w * 8 * s->h_count[i];
 812             h = h * 8 * s->v_count[i];
 813             if (s->interlaced)
 814                 w *= 2;
 815             s->linesize[i] = w;
 816             /* memory test is done in mjpeg_decode_sos() */
 817             s->current_picture[i] = av_mallocz(w * h);
 818         }
 819         s->first_picture = 0;
 820     }
 821
 822     if (len != (8+(3*nb_components)))
 823     {
 824         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
 825     }
 826
 827     return 0;
 828 }
 829
 830 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
 831 {
 832     int code, diff;
 833 #if 1
 834     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
 835 #else
 836     code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
 837 #endif
 838     if (code < 0)
 839     {
 840         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
 841                 &s->vlcs[0][dc_index]);
 842         return 0xffff;
 843     }
 844     if (code == 0) {
 845         diff = 0;
 846     } else {
 847         diff = get_bits(&s->gb, code);
 848         if ((diff & (1 << (code - 1))) == 0)
 849             diff = (-1 << code) | (diff + 1);
 850     }
 851     return diff;
 852 }
 853
 854 /* decode block and dequantize */
 855 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 856                         int component, int dc_index, int ac_index, int quant_index)
 857 {
 858     int nbits, code, i, j, level;
 859     int run, val;
 860     VLC *ac_vlc;
 861     INT16 *quant_matrix;
 862
 863     /* DC coef */
 864     val = mjpeg_decode_dc(s, dc_index);
 865     if (val == 0xffff) {
 866         dprintf("error dc\n");
 867         return -1;
 868     }
 869     quant_matrix = s->quant_matrixes[quant_index];
 870     val = val * quant_matrix[0] + s->last_dc[component];
 871     s->last_dc[component] = val;
 872     block[0] = val;
 873     /* AC coefs */
 874     ac_vlc = &s->vlcs[1][ac_index];
 875     i = 1;
 876     for(;;) {
 877 #if 1
 878         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
 879 #else
 880         code = get_vlc(&s->gb, ac_vlc);
 881 #endif
 882         if (code < 0) {
 883             dprintf("error ac\n");
 884             return -1;
 885         }
 886         /* EOB */
 887         if (code == 0)
 888             break;
 889         if (code == 0xf0) {
 890             i += 16;
 891         } else {
 892             run = code >> 4;
 893             nbits = code & 0xf;
 894             level = get_bits(&s->gb, nbits);
 895             if ((level & (1 << (nbits - 1))) == 0)
 896                 level = (-1 << nbits) | (level + 1);
 897             i += run;
 898             if (i >= 64) {
 899                 dprintf("error count: %d\n", i);
 900                 return -1;
 901             }
 902             j = s->scantable.permutated[i];
 903             block[j] = level * quant_matrix[j];
 904             i++;
 905             if (i >= 64)
 906                 break;
 907         }
 908     }
 909     return 0;
 910 }
 911
 912 static int mjpeg_decode_sos(MJpegDecodeContext *s)
 913 {
 914     int len, nb_components, i, j, n, h, v, ret;
 915     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 916     int comp_index[4];
 917     int dc_index[4];
 918     int ac_index[4];
 919     int nb_blocks[4];
 920     int h_count[4];
 921     int v_count[4];
 922
 923     /* XXX: verify len field validity */
 924     len = get_bits(&s->gb, 16);
 925     nb_components = get_bits(&s->gb, 8);
 926     if (len != 6+2*nb_components)
 927     {
 928         dprintf("decode_sos: invalid len (%d)\n", len);
 929         return -1;
 930     }
 931     /* XXX: only interleaved scan accepted */
 932     if (nb_components != 3)
 933     {
 934         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
 935         return -1;
 936     }
 937     vmax = 0;
 938     hmax = 0;
 939     for(i=0;i<nb_components;i++) {
 940         id = get_bits(&s->gb, 8) - 1;
 941         dprintf("component: %d\n", id);
 942         /* find component index */
 943         for(index=0;index<s->nb_components;index++)
 944             if (id == s->component_id[index])
 945                 break;
 946         if (index == s->nb_components)
 947         {
 948             dprintf("decode_sos: index(%d) out of components\n", index);
 949             return -1;
 950         }
 951
 952         comp_index[i] = index;
 953         nb_blocks[i] = s->h_count[index] * s->v_count[index];
 954         h_count[i] = s->h_count[index];
 955         v_count[i] = s->v_count[index];
 956
 957         dc_index[i] = get_bits(&s->gb, 4);
 958         ac_index[i] = get_bits(&s->gb, 4);
 959
 960         if (dc_index[i] < 0 || ac_index[i] < 0 ||
 961             dc_index[i] >= 4 || ac_index[i] >= 4)
 962             goto out_of_range;
 963         switch(s->start_code)
 964         {
 965             case SOF0:
 966                 if (dc_index[i] > 1 || ac_index[i] > 1)
 967                     goto out_of_range;
 968                 break;
 969             case SOF1:
 970             case SOF2:
 971                 if (dc_index[i] > 3 || ac_index[i] > 3)
 972                     goto out_of_range;
 973                 break;
 974             case SOF3:
 975                 if (dc_index[i] > 3 || ac_index[i] != 0)
 976                     goto out_of_range;
 977                 break;
 978         }
 979     }
 980     skip_bits(&s->gb, 8); /* Ss */
 981     skip_bits(&s->gb, 8); /* Se */
 982     skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
 983
 984     for(i=0;i<nb_components;i++)
 985         s->last_dc[i] = 1024;
 986
 987     if (nb_components > 1) {
 988         /* interleaved stream */
 989         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
 990         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
 991     } else {
 992         h = s->h_max / s->h_count[comp_index[0]];
 993         v = s->v_max / s->v_count[comp_index[0]];
 994         mb_width = (s->width + h * 8 - 1) / (h * 8);
 995         mb_height = (s->height + v * 8 - 1) / (v * 8);
 996         nb_blocks[0] = 1;
 997         h_count[0] = 1;
 998         v_count[0] = 1;
 999     }
1000
1001     for(mb_y = 0; mb_y < mb_height; mb_y++) {
1002         for(mb_x = 0; mb_x < mb_width; mb_x++) {
1003             for(i=0;i<nb_components;i++) {
1004                 UINT8 *ptr;
1005                 int x, y, c;
1006                 n = nb_blocks[i];
1007                 c = comp_index[i];
1008                 h = h_count[i];
1009                 v = v_count[i];
1010                 x = 0;
1011                 y = 0;
1012                 if (s->restart_interval && !s->restart_count)
1013                     s->restart_count = s->restart_interval;
1014                 for(j=0;j<n;j++) {
1015                     memset(s->block, 0, sizeof(s->block));
1016                     if (decode_block(s, s->block, i,
1017                                      dc_index[i], ac_index[i],
1018                                      s->quant_index[c]) < 0) {
1019                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1020                         ret = -1;
1021                         goto the_end;
1022                     }
1023 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1024                     ptr = s->current_picture[c] +
1025                         (s->linesize[c] * (v * mb_y + y) * 8) +
1026                         (h * mb_x + x) * 8;
1027                     if (s->interlaced && s->bottom_field)
1028                         ptr += s->linesize[c] >> 1;
1029                     s->idct_put(ptr, s->linesize[c], s->block);
1030                     if (++x == h) {
1031                         x = 0;
1032                         y++;
1033                     }
1034                 }
1035             }
1036             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1037
1038             if ((s->restart_interval < 1350) && !--s->restart_count) {
1039                 align_get_bits(&s->gb);
1040                 skip_bits(&s->gb, 16); /* skip RSTn */
1041                 for (j=0; j<nb_components; j++) /* reset dc */
1042                     s->last_dc[j] = 1024;
1043             }
1044         }
1045     }
1046     ret = 0;
1047  the_end:
1048     emms_c();
1049     return ret;
1050  out_of_range:
1051     dprintf("decode_sos: ac/dc index out of range\n");
1052     return -1;
1053 }
1054
1055 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1056 {
1057     if (get_bits(&s->gb, 16) != 4)
1058         return -1;
1059     s->restart_interval = get_bits(&s->gb, 16);
1060     dprintf("restart interval: %d\n", s->restart_interval);
1061
1062     return 0;
1063 }
1064
1065 static int mjpeg_decode_app(MJpegDecodeContext *s)
1066 {
1067     int len, id;
1068
1069     /* XXX: verify len field validity */
1070     len = get_bits(&s->gb, 16);
1071     if (len < 5)
1072         return -1;
1073
1074     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1075     id = be2me_32(id);
1076     len -= 6;
1077
1078     /* buggy AVID, it puts EOI only at every 10th frame */
1079     /* also this fourcc is used by non-avid files too, it holds some
1080        informations, but it's always present in AVID creates files */
1081     if (id == ff_get_fourcc("AVI1"))
1082     {
1083         /* structure:
1084             4bytes      AVI1
1085             1bytes      polarity
1086             1bytes      always zero
1087             4bytes      field_size
1088             4bytes      field_size_less_padding
1089         */
1090         s->buggy_avid = 1;
1091 //      if (s->first_picture)
1092 //          printf("mjpeg: workarounding buggy AVID\n");
1093         s->interlace_polarity = get_bits(&s->gb, 8);
1094 #if 0
1095         skip_bits(&s->gb, 8);
1096         skip_bits(&s->gb, 32);
1097         skip_bits(&s->gb, 32);
1098         len -= 10;
1099 #endif
1100 //      if (s->interlace_polarity)
1101 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1102         goto out;
1103     }
1104
1105 //    len -= 2;
1106
1107     if (id == ff_get_fourcc("JFIF"))
1108     {
1109         int t_w, t_h;
1110         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1111         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1112             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1113         if (get_bits(&s->gb, 8) == 0)
1114         {
1115             s->avctx->aspect_ratio_info = FF_ASPECT_EXTENDED;
1116             s->avctx->aspected_width = get_bits(&s->gb, 16);
1117             s->avctx->aspected_height = get_bits(&s->gb, 16);
1118         }
1119         else
1120         {
1121             skip_bits(&s->gb, 16);
1122             skip_bits(&s->gb, 16);
1123         }
1124         t_w = get_bits(&s->gb, 8);
1125         t_h = get_bits(&s->gb, 8);
1126         if (t_w && t_h)
1127         {
1128             /* skip thumbnail */
1129             if (len-10-(t_w*t_h*3) > 0)
1130                 len -= t_w*t_h*3;
1131         }
1132         len -= 10;
1133         goto out;
1134     }
1135
1136     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1137     {
1138         printf("mjpeg: Adobe header found\n");
1139         skip_bits(&s->gb, 16); /* version */
1140         skip_bits(&s->gb, 16); /* flags0 */
1141         skip_bits(&s->gb, 16); /* flags1 */
1142         skip_bits(&s->gb, 8); /* transform */
1143         len -= 7;
1144         goto out;
1145     }
1146
1147     /* Apple MJPEG-A */
1148     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1149     {
1150         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1151         id = be2me_32(id);
1152         len -= 4;
1153         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1154         {
1155 #if 0
1156             skip_bits(&s->gb, 32); /* field size */
1157             skip_bits(&s->gb, 32); /* pad field size */
1158             skip_bits(&s->gb, 32); /* next off */
1159             skip_bits(&s->gb, 32); /* quant off */
1160             skip_bits(&s->gb, 32); /* huff off */
1161             skip_bits(&s->gb, 32); /* image off */
1162             skip_bits(&s->gb, 32); /* scan off */
1163             skip_bits(&s->gb, 32); /* data off */
1164 #endif
1165             if (s->first_picture)
1166                 printf("mjpeg: Apple MJPEG-A header found\n");
1167         }
1168     }
1169
1170 out:
1171     /* slow but needed for extreme adobe jpegs */
1172     if (len < 0)
1173         printf("mjpeg: error, decode_app parser read over the end\n");
1174     while(--len > 0)
1175         skip_bits(&s->gb, 8);
1176
1177     return 0;
1178 }
1179
1180 static int mjpeg_decode_com(MJpegDecodeContext *s)
1181 {
1182     int len, i;
1183     UINT8 *cbuf;
1184
1185     /* XXX: verify len field validity */
1186     len = get_bits(&s->gb, 16)-2;
1187     cbuf = av_malloc(len+1);
1188
1189     for (i = 0; i < len; i++)
1190         cbuf[i] = get_bits(&s->gb, 8);
1191     if (cbuf[i-1] == '\n')
1192         cbuf[i-1] = 0;
1193     else
1194         cbuf[i] = 0;
1195
1196     printf("mjpeg comment: '%s'\n", cbuf);
1197
1198     /* buggy avid, it puts EOI only at every 10th frame */
1199     if (!strcmp(cbuf, "AVID"))
1200     {
1201         s->buggy_avid = 1;
1202 //      if (s->first_picture)
1203 //          printf("mjpeg: workarounding buggy AVID\n");
1204     }
1205
1206     av_free(cbuf);
1207
1208     return 0;
1209 }
1210
1211 #if 0
1212 static int valid_marker_list[] =
1213 {
1214         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1215 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1216 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1217 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1218 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1219 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1220 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1221 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1222 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1223 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1224 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1225 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1226 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1227 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1228 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1229 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1230 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1231 }
1232 #endif
1233
1234 /* return the 8 bit start code value and update the search
1235    state. Return -1 if no start code found */
1236 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
1237 {
1238     UINT8 *buf_ptr;
1239     unsigned int v, v2;
1240     int val;
1241 #ifdef DEBUG
1242     int skipped=0;
1243 #endif
1244
1245     buf_ptr = *pbuf_ptr;
1246     while (buf_ptr < buf_end) {
1247         v = *buf_ptr++;
1248         v2 = *buf_ptr;
1249         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1250             val = *buf_ptr++;
1251             goto found;
1252         }
1253 #ifdef DEBUG
1254         skipped++;
1255 #endif
1256     }
1257     val = -1;
1258 found:
1259 #ifdef DEBUG
1260     dprintf("find_marker skipped %d bytes\n", skipped);
1261 #endif
1262     *pbuf_ptr = buf_ptr;
1263     return val;
1264 }
1265
1266 static int mjpeg_decode_frame(AVCodecContext *avctx,
1267                               void *data, int *data_size,
1268                               UINT8 *buf, int buf_size)
1269 {
1270     MJpegDecodeContext *s = avctx->priv_data;
1271     UINT8 *buf_end, *buf_ptr;
1272     int i, start_code;
1273     AVPicture *picture = data;
1274
1275     *data_size = 0;
1276
1277     /* no supplementary picture */
1278     if (buf_size == 0)
1279         return 0;
1280
1281     buf_ptr = buf;
1282     buf_end = buf + buf_size;
1283     while (buf_ptr < buf_end) {
1284         /* find start next marker */
1285         start_code = find_marker(&buf_ptr, buf_end);
1286         {
1287             /* EOF */
1288             if (start_code < 0) {
1289                 goto the_end;
1290             } else {
1291                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1292
1293                 if ((buf_end - buf_ptr) > s->buffer_size)
1294                 {
1295                     av_free(s->buffer);
1296                     s->buffer_size = buf_end-buf_ptr;
1297                     s->buffer = av_malloc(s->buffer_size);
1298                     dprintf("buffer too small, expanding to %d bytes\n",
1299                         s->buffer_size);
1300                 }
1301
1302                 /* unescape buffer of SOS */
1303                 if (start_code == SOS)
1304                 {
1305                     UINT8 *src = buf_ptr;
1306                     UINT8 *dst = s->buffer;
1307
1308                     while (src<buf_end)
1309                     {
1310                         UINT8 x = *(src++);
1311
1312 #if 0
1313                         if (x == 0xff && *src == 0xff)
1314                             break;
1315 #endif
1316                         *(dst++) = x;
1317                         if (x == 0xff)
1318                         {
1319                             x = *(src++);
1320                             if (x >= 0xd0 && x <= 0xd7)
1321                                 *(dst++) = x;
1322                             else if (x)
1323                                 break;
1324                         }
1325                     }
1326                     init_get_bits(&s->gb, s->buffer, dst - s->buffer);
1327
1328                     dprintf("escaping removed %d bytes\n",
1329                         (buf_end - buf_ptr) - (dst - s->buffer));
1330                 }
1331                 else
1332                     init_get_bits(&s->gb, buf_ptr, buf_end - buf_ptr);
1333
1334                 s->start_code = start_code;
1335
1336                 /* process markers */
1337                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1338                     dprintf("restart marker: %d\n", start_code&0x0f);
1339                 } else if (s->first_picture) {
1340                     /* APP fields */
1341                     if (start_code >= 0xe0 && start_code <= 0xef)
1342                         mjpeg_decode_app(s);
1343                     /* Comment */
1344                     else if (start_code == COM)
1345                         mjpeg_decode_com(s);
1346                 }
1347
1348                 switch(start_code) {
1349                 case SOI:
1350                     s->restart_interval = 0;
1351                     /* nothing to do on SOI */
1352                     break;
1353                 case DQT:
1354                     mjpeg_decode_dqt(s);
1355                     break;
1356                 case DHT:
1357                     mjpeg_decode_dht(s);
1358                     break;
1359                 case SOF0:
1360                     mjpeg_decode_sof0(s);
1361                     break;
1362                 case EOI:
1363 eoi_parser:
1364                     {
1365                         int l;
1366                         if (s->interlaced) {
1367                             s->bottom_field ^= 1;
1368                             /* if not bottom field, do not output image yet */
1369                             if (s->bottom_field)
1370                                 goto not_the_end;
1371                         }
1372                         for(i=0;i<3;i++) {
1373                             picture->data[i] = s->current_picture[i];
1374 #if 1
1375                             l = s->linesize[i];
1376                             if (s->interlaced)
1377                                 l >>= 1;
1378                             picture->linesize[i] = l;
1379 #else
1380                             picture->linesize[i] = (s->interlaced) ?
1381                                 s->linesize[i] >> 1 : s->linesize[i];
1382 #endif
1383                         }
1384                         *data_size = sizeof(AVPicture);
1385                         avctx->height = s->height;
1386                         if (s->interlaced)
1387                             avctx->height *= 2;
1388                         avctx->width = s->width;
1389                         /* XXX: not complete test ! */
1390                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1391                         case 0x11:
1392                             avctx->pix_fmt = PIX_FMT_YUV444P;
1393                             break;
1394                         case 0x21:
1395                             avctx->pix_fmt = PIX_FMT_YUV422P;
1396                             break;
1397                         default:
1398                         case 0x22:
1399                             avctx->pix_fmt = PIX_FMT_YUV420P;
1400                             break;
1401                         }
1402                         /* dummy quality */
1403                         /* XXX: infer it with matrix */
1404                         avctx->quality = 3;
1405                         goto the_end;
1406                     }
1407                     break;
1408                 case SOS:
1409                     mjpeg_decode_sos(s);
1410                     /* buggy avid puts EOI every 10-20th frame */
1411                     /* if restart period is over process EOI */
1412                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1413                         goto eoi_parser;
1414                     break;
1415                 case DRI:
1416                     mjpeg_decode_dri(s);
1417                     break;
1418                 case SOF1:
1419                 case SOF2:
1420                 case SOF3:
1421                 case SOF5:
1422                 case SOF6:
1423                 case SOF7:
1424                 case SOF9:
1425                 case SOF10:
1426                 case SOF11:
1427                 case SOF13:
1428                 case SOF14:
1429                 case SOF15:
1430                 case JPG:
1431                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1432                     break;
1433 //              default:
1434 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1435 //                  break;
1436                 }
1437
1438 not_the_end:
1439                 /* eof process start code */
1440                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1441                 dprintf("marker parser used %d bytes (%d bits)\n",
1442                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1443             }
1444         }
1445     }
1446 the_end:
1447
1448     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1449 //    return buf_end - buf_ptr;
1450     return buf_ptr - buf;
1451 }
1452
1453 static int mjpeg_decode_end(AVCodecContext *avctx)
1454 {
1455     MJpegDecodeContext *s = avctx->priv_data;
1456     int i, j;
1457
1458     av_free(s->buffer);
1459     for(i=0;i<MAX_COMPONENTS;i++)
1460         av_free(s->current_picture[i]);
1461     for(i=0;i<2;i++) {
1462         for(j=0;j<4;j++)
1463             free_vlc(&s->vlcs[i][j]);
1464     }
1465     return 0;
1466 }
1467
1468 AVCodec mjpeg_decoder = {
1469     "mjpeg",
1470     CODEC_TYPE_VIDEO,
1471     CODEC_ID_MJPEG,
1472     sizeof(MJpegDecodeContext),
1473     mjpeg_decode_init,
1474     NULL,
1475     mjpeg_decode_end,
1476     mjpeg_decode_frame,
1477     0,
1478     NULL
1479 };