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