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, new decode_frame mechanism and apple mjpeg-b 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 /* 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 static void escape_FF(MpegEncContext *s, int start)
 474 {
 475     int size= get_bit_count(&s->pb) - start*8;
 476     int i, ff_count;
 477     uint8_t *buf= s->pb.buf + start;
 478     int align= (-(int)(buf))&3;
 479
 480     assert((size&7) == 0);
 481     size >>= 3;
 482
 483     ff_count=0;
 484     for(i=0; i<size && i<align; i++){
 485         if(buf[i]==0xFF) ff_count++;
 486     }
 487     for(; i<size-15; i+=16){
 488         int acc, v;
 489
 490         v= *(uint32_t*)(&buf[i]);
 491         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 492         v= *(uint32_t*)(&buf[i+4]);
 493         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 494         v= *(uint32_t*)(&buf[i+8]);
 495         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 496         v= *(uint32_t*)(&buf[i+12]);
 497         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 498
 499         acc>>=4;
 500         acc+= (acc>>16);
 501         acc+= (acc>>8);
 502         ff_count+= acc&0xFF;
 503     }
 504     for(; i<size; i++){
 505         if(buf[i]==0xFF) ff_count++;
 506     }
 507
 508     if(ff_count==0) return;
 509
 510     /* skip put bits */
 511     for(i=0; i<ff_count-3; i+=4)
 512         put_bits(&s->pb, 32, 0);
 513     put_bits(&s->pb, (ff_count-i)*8, 0);
 514     flush_put_bits(&s->pb);
 515
 516     for(i=size-1; ff_count; i--){
 517         int v= buf[i];
 518
 519         if(v==0xFF){
 520 //printf("%d %d\n", i, ff_count);
 521             buf[i+ff_count]= 0;
 522             ff_count--;
 523         }
 524
 525         buf[i+ff_count]= v;
 526     }
 527 }
 528
 529 void mjpeg_picture_trailer(MpegEncContext *s)
 530 {
 531     int pad= (-get_bit_count(&s->pb))&7;
 532
 533     put_bits(&s->pb, pad,0xFF>>(8-pad));
 534     flush_put_bits(&s->pb);
 535
 536     assert((s->header_bits&7)==0);
 537
 538     escape_FF(s, s->header_bits>>3);
 539
 540     put_marker(&s->pb, EOI);
 541 }
 542
 543 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 544                                    UINT8 *huff_size, UINT16 *huff_code)
 545 {
 546     int mant, nbits;
 547
 548     if (val == 0) {
 549         put_bits(&s->pb, huff_size[0], huff_code[0]);
 550     } else {
 551         mant = val;
 552         if (val < 0) {
 553             val = -val;
 554             mant--;
 555         }
 556
 557         /* compute the log (XXX: optimize) */
 558         nbits = 0;
 559         while (val != 0) {
 560             val = val >> 1;
 561             nbits++;
 562         }
 563
 564         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 565
 566         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 567     }
 568 }
 569
 570 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 571 {
 572     int mant, nbits, code, i, j;
 573     int component, dc, run, last_index, val;
 574     MJpegContext *m = s->mjpeg_ctx;
 575     UINT8 *huff_size_ac;
 576     UINT16 *huff_code_ac;
 577
 578     /* DC coef */
 579     component = (n <= 3 ? 0 : n - 4 + 1);
 580     dc = block[0]; /* overflow is impossible */
 581     val = dc - s->last_dc[component];
 582     if (n < 4) {
 583         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 584         huff_size_ac = m->huff_size_ac_luminance;
 585         huff_code_ac = m->huff_code_ac_luminance;
 586     } else {
 587         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 588         huff_size_ac = m->huff_size_ac_chrominance;
 589         huff_code_ac = m->huff_code_ac_chrominance;
 590     }
 591     s->last_dc[component] = dc;
 592
 593     /* AC coefs */
 594
 595     run = 0;
 596     last_index = s->block_last_index[n];
 597     for(i=1;i<=last_index;i++) {
 598         j = s->intra_scantable.permutated[i];
 599         val = block[j];
 600         if (val == 0) {
 601             run++;
 602         } else {
 603             while (run >= 16) {
 604                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 605                 run -= 16;
 606             }
 607             mant = val;
 608             if (val < 0) {
 609                 val = -val;
 610                 mant--;
 611             }
 612
 613             /* compute the log (XXX: optimize) */
 614             nbits = 0;
 615             while (val != 0) {
 616                 val = val >> 1;
 617                 nbits++;
 618             }
 619             code = (run << 4) | nbits;
 620
 621             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 622
 623             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 624             run = 0;
 625         }
 626     }
 627
 628     /* output EOB only if not already 64 values */
 629     if (last_index < 63 || run != 0)
 630         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 631 }
 632
 633 void mjpeg_encode_mb(MpegEncContext *s,
 634                      DCTELEM block[6][64])
 635 {
 636     int i;
 637     for(i=0;i<6;i++) {
 638         encode_block(s, block[i], i);
 639     }
 640 }
 641
 642 /******************************************/
 643 /* decoding */
 644
 645 #define MAX_COMPONENTS 4
 646
 647 typedef struct MJpegDecodeContext {
 648     AVCodecContext *avctx;
 649     GetBitContext gb;
 650     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 651
 652     int start_code; /* current start code */
 653     int buffer_size;
 654     UINT8 *buffer;
 655
 656     INT16 quant_matrixes[4][64];
 657     VLC vlcs[2][4];
 658
 659     int org_width, org_height;  /* size given at codec init */
 660     int first_picture;    /* true if decoding first picture */
 661     int interlaced;     /* true if interlaced */
 662     int bottom_field;   /* true if bottom field */
 663
 664     int width, height;
 665     int nb_components;
 666     int component_id[MAX_COMPONENTS];
 667     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 668     int v_count[MAX_COMPONENTS];
 669     int h_max, v_max; /* maximum h and v counts */
 670     int quant_index[4];   /* quant table index for each component */
 671     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 672     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
 673     int linesize[MAX_COMPONENTS];
 674     DCTELEM block[64] __align8;
 675     ScanTable scantable;
 676     void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 677
 678     int restart_interval;
 679     int restart_count;
 680
 681     int buggy_avid;
 682     int interlace_polarity;
 683 } MJpegDecodeContext;
 684
 685 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 686
 687 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
 688                       int nb_codes)
 689 {
 690     UINT8 huff_size[256];
 691     UINT16 huff_code[256];
 692
 693     memset(huff_size, 0, sizeof(huff_size));
 694     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 695
 696     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 697 }
 698
 699 static int mjpeg_decode_init(AVCodecContext *avctx)
 700 {
 701     MJpegDecodeContext *s = avctx->priv_data;
 702     MpegEncContext s2;
 703
 704     s->avctx = avctx;
 705
 706     /* ugly way to get the idct & scantable */
 707     memset(&s2, 0, sizeof(MpegEncContext));
 708     s2.flags= avctx->flags;
 709     s2.avctx= avctx;
 710 //    s2->out_format = FMT_MJPEG;
 711     s2.width = 8;
 712     s2.height = 8;
 713     if (MPV_common_init(&s2) < 0)
 714        return -1;
 715     s->scantable= s2.intra_scantable;
 716     s->idct_put= s2.idct_put;
 717     MPV_common_end(&s2);
 718
 719     s->mpeg_enc_ctx_allocated = 0;
 720     s->buffer_size = 102400; /* smaller buffer should be enough,
 721                                 but photojpg files could ahive bigger sizes */
 722     s->buffer = av_malloc(s->buffer_size);
 723     if (!s->buffer)
 724         return -1;
 725     s->start_code = -1;
 726     s->first_picture = 1;
 727     s->org_width = avctx->width;
 728     s->org_height = avctx->height;
 729
 730     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 731     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 732     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 733     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 734
 735     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 736     {
 737         printf("mjpeg: using external huffman table\n");
 738         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 739         mjpeg_decode_dht(s);
 740         /* should check for error - but dunno */
 741     }
 742
 743     return 0;
 744 }
 745
 746 /* quantize tables */
 747 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 748 {
 749     int len, index, i, j;
 750
 751     len = get_bits(&s->gb, 16) - 2;
 752
 753     while (len >= 65) {
 754         /* only 8 bit precision handled */
 755         if (get_bits(&s->gb, 4) != 0)
 756         {
 757             dprintf("dqt: 16bit precision\n");
 758             return -1;
 759         }
 760         index = get_bits(&s->gb, 4);
 761         if (index >= 4)
 762             return -1;
 763         dprintf("index=%d\n", index);
 764         /* read quant table */
 765         for(i=0;i<64;i++) {
 766             j = s->scantable.permutated[i];
 767             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 768         }
 769         len -= 65;
 770     }
 771
 772     return 0;
 773 }
 774
 775 /* decode huffman tables and build VLC decoders */
 776 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 777 {
 778     int len, index, i, class, n, v, code_max;
 779     UINT8 bits_table[17];
 780     UINT8 val_table[256];
 781
 782     len = get_bits(&s->gb, 16) - 2;
 783
 784     while (len > 0) {
 785         if (len < 17)
 786             return -1;
 787         class = get_bits(&s->gb, 4);
 788         if (class >= 2)
 789             return -1;
 790         index = get_bits(&s->gb, 4);
 791         if (index >= 4)
 792             return -1;
 793         n = 0;
 794         for(i=1;i<=16;i++) {
 795             bits_table[i] = get_bits(&s->gb, 8);
 796             n += bits_table[i];
 797         }
 798         len -= 17;
 799         if (len < n || n > 256)
 800             return -1;
 801
 802         code_max = 0;
 803         for(i=0;i<n;i++) {
 804             v = get_bits(&s->gb, 8);
 805             if (v > code_max)
 806                 code_max = v;
 807             val_table[i] = v;
 808         }
 809         len -= n;
 810
 811         /* build VLC and flush previous vlc if present */
 812         free_vlc(&s->vlcs[class][index]);
 813         dprintf("class=%d index=%d nb_codes=%d\n",
 814                class, index, code_max + 1);
 815         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 816     }
 817     return 0;
 818 }
 819
 820 static int mjpeg_decode_sof0(MJpegDecodeContext *s)
 821 {
 822     int len, nb_components, i, width, height;
 823
 824     /* XXX: verify len field validity */
 825     len = get_bits(&s->gb, 16);
 826     /* only 8 bits/component accepted */
 827     if (get_bits(&s->gb, 8) != 8)
 828         return -1;
 829     height = get_bits(&s->gb, 16);
 830     width = get_bits(&s->gb, 16);
 831     dprintf("sof0: picture: %dx%d\n", width, height);
 832
 833     nb_components = get_bits(&s->gb, 8);
 834     if (nb_components <= 0 ||
 835         nb_components > MAX_COMPONENTS)
 836         return -1;
 837     s->nb_components = nb_components;
 838     s->h_max = 1;
 839     s->v_max = 1;
 840     for(i=0;i<nb_components;i++) {
 841         /* component id */
 842         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 843         s->h_count[i] = get_bits(&s->gb, 4);
 844         s->v_count[i] = get_bits(&s->gb, 4);
 845         /* compute hmax and vmax (only used in interleaved case) */
 846         if (s->h_count[i] > s->h_max)
 847             s->h_max = s->h_count[i];
 848         if (s->v_count[i] > s->v_max)
 849             s->v_max = s->v_count[i];
 850         s->quant_index[i] = get_bits(&s->gb, 8);
 851         if (s->quant_index[i] >= 4)
 852             return -1;
 853         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
 854             s->v_count[i], s->component_id[i], s->quant_index[i]);
 855     }
 856
 857     /* if different size, realloc/alloc picture */
 858     /* XXX: also check h_count and v_count */
 859     if (width != s->width || height != s->height) {
 860         for(i=0;i<MAX_COMPONENTS;i++)
 861             av_freep(&s->current_picture[i]);
 862         s->width = width;
 863         s->height = height;
 864         /* test interlaced mode */
 865         if (s->first_picture &&
 866             s->org_height != 0 &&
 867             s->height < ((s->org_height * 3) / 4)) {
 868             s->interlaced = 1;
 869 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
 870             s->bottom_field = 0;
 871         }
 872
 873         for(i=0;i<nb_components;i++) {
 874             int w, h;
 875             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
 876             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
 877             w = w * 8 * s->h_count[i];
 878             h = h * 8 * s->v_count[i];
 879             if (s->interlaced)
 880                 w *= 2;
 881             s->linesize[i] = w;
 882             s->current_picture[i] = av_mallocz(w * h);
 883             if (!s->current_picture[i])
 884             {
 885                 dprintf("error: no picture buffers allocated\n");
 886                 return -1;
 887             }
 888         }
 889         s->first_picture = 0;
 890     }
 891
 892     if (len != (8+(3*nb_components)))
 893     {
 894         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
 895     }
 896
 897     return 0;
 898 }
 899
 900 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
 901 {
 902     int code, diff;
 903 #if 1
 904     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
 905 #else
 906     code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
 907 #endif
 908     if (code < 0)
 909     {
 910         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
 911                 &s->vlcs[0][dc_index]);
 912         return 0xffff;
 913     }
 914     if (code == 0) {
 915         diff = 0;
 916     } else {
 917         diff = get_bits(&s->gb, code);
 918         if ((diff & (1 << (code - 1))) == 0)
 919             diff = (-1 << code) | (diff + 1);
 920     }
 921     return diff;
 922 }
 923
 924 /* decode block and dequantize */
 925 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 926                         int component, int dc_index, int ac_index, int quant_index)
 927 {
 928     int nbits, code, i, j, level;
 929     int run, val;
 930     VLC *ac_vlc;
 931     INT16 *quant_matrix;
 932
 933     /* DC coef */
 934     val = mjpeg_decode_dc(s, dc_index);
 935     if (val == 0xffff) {
 936         dprintf("error dc\n");
 937         return -1;
 938     }
 939     quant_matrix = s->quant_matrixes[quant_index];
 940     val = val * quant_matrix[0] + s->last_dc[component];
 941     s->last_dc[component] = val;
 942     block[0] = val;
 943     /* AC coefs */
 944     ac_vlc = &s->vlcs[1][ac_index];
 945     i = 1;
 946     for(;;) {
 947 #if 1
 948         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
 949 #else
 950         code = get_vlc(&s->gb, ac_vlc);
 951 #endif
 952         if (code < 0) {
 953             dprintf("error ac\n");
 954             return -1;
 955         }
 956         /* EOB */
 957         if (code == 0)
 958             break;
 959         if (code == 0xf0) {
 960             i += 16;
 961         } else {
 962             run = code >> 4;
 963             nbits = code & 0xf;
 964             level = get_bits(&s->gb, nbits);
 965             if ((level & (1 << (nbits - 1))) == 0)
 966                 level = (-1 << nbits) | (level + 1);
 967             i += run;
 968             if (i >= 64) {
 969                 dprintf("error count: %d\n", i);
 970                 return -1;
 971             }
 972             j = s->scantable.permutated[i];
 973             block[j] = level * quant_matrix[j];
 974             i++;
 975             if (i >= 64)
 976                 break;
 977         }
 978     }
 979     return 0;
 980 }
 981
 982 static int mjpeg_decode_sos(MJpegDecodeContext *s)
 983 {
 984     int len, nb_components, i, j, n, h, v, ret;
 985     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 986     int comp_index[4];
 987     int dc_index[4];
 988     int ac_index[4];
 989     int nb_blocks[4];
 990     int h_count[4];
 991     int v_count[4];
 992
 993     /* XXX: verify len field validity */
 994     len = get_bits(&s->gb, 16);
 995     nb_components = get_bits(&s->gb, 8);
 996     if (len != 6+2*nb_components)
 997     {
 998         dprintf("decode_sos: invalid len (%d)\n", len);
 999         return -1;
1000     }
1001     /* XXX: only interleaved scan accepted */
1002     if (nb_components != 3)
1003     {
1004         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1005         return -1;
1006     }
1007     vmax = 0;
1008     hmax = 0;
1009     for(i=0;i<nb_components;i++) {
1010         id = get_bits(&s->gb, 8) - 1;
1011         dprintf("component: %d\n", id);
1012         /* find component index */
1013         for(index=0;index<s->nb_components;index++)
1014             if (id == s->component_id[index])
1015                 break;
1016         if (index == s->nb_components)
1017         {
1018             dprintf("decode_sos: index(%d) out of components\n", index);
1019             return -1;
1020         }
1021
1022         comp_index[i] = index;
1023         nb_blocks[i] = s->h_count[index] * s->v_count[index];
1024         h_count[i] = s->h_count[index];
1025         v_count[i] = s->v_count[index];
1026
1027         dc_index[i] = get_bits(&s->gb, 4);
1028         ac_index[i] = get_bits(&s->gb, 4);
1029
1030         if (dc_index[i] < 0 || ac_index[i] < 0 ||
1031             dc_index[i] >= 4 || ac_index[i] >= 4)
1032             goto out_of_range;
1033         switch(s->start_code)
1034         {
1035             case SOF0:
1036                 if (dc_index[i] > 1 || ac_index[i] > 1)
1037                     goto out_of_range;
1038                 break;
1039             case SOF1:
1040             case SOF2:
1041                 if (dc_index[i] > 3 || ac_index[i] > 3)
1042                     goto out_of_range;
1043                 break;
1044             case SOF3:
1045                 if (dc_index[i] > 3 || ac_index[i] != 0)
1046                     goto out_of_range;
1047                 break;
1048         }
1049     }
1050     skip_bits(&s->gb, 8); /* Ss */
1051     skip_bits(&s->gb, 8); /* Se */
1052     skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
1053
1054     for(i=0;i<nb_components;i++)
1055         s->last_dc[i] = 1024;
1056
1057     if (nb_components > 1) {
1058         /* interleaved stream */
1059         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
1060         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
1061     } else {
1062         h = s->h_max / s->h_count[comp_index[0]];
1063         v = s->v_max / s->v_count[comp_index[0]];
1064         mb_width = (s->width + h * 8 - 1) / (h * 8);
1065         mb_height = (s->height + v * 8 - 1) / (v * 8);
1066         nb_blocks[0] = 1;
1067         h_count[0] = 1;
1068         v_count[0] = 1;
1069     }
1070
1071     for(mb_y = 0; mb_y < mb_height; mb_y++) {
1072         for(mb_x = 0; mb_x < mb_width; mb_x++) {
1073             for(i=0;i<nb_components;i++) {
1074                 UINT8 *ptr;
1075                 int x, y, c;
1076                 n = nb_blocks[i];
1077                 c = comp_index[i];
1078                 h = h_count[i];
1079                 v = v_count[i];
1080                 x = 0;
1081                 y = 0;
1082                 if (s->restart_interval && !s->restart_count)
1083                     s->restart_count = s->restart_interval;
1084                 for(j=0;j<n;j++) {
1085                     memset(s->block, 0, sizeof(s->block));
1086                     if (decode_block(s, s->block, i,
1087                                      dc_index[i], ac_index[i],
1088                                      s->quant_index[c]) < 0) {
1089                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1090                         ret = -1;
1091                         goto the_end;
1092                     }
1093 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1094                     ptr = s->current_picture[c] +
1095                         (s->linesize[c] * (v * mb_y + y) * 8) +
1096                         (h * mb_x + x) * 8;
1097                     if (s->interlaced && s->bottom_field)
1098                         ptr += s->linesize[c] >> 1;
1099                     s->idct_put(ptr, s->linesize[c], s->block);
1100                     if (++x == h) {
1101                         x = 0;
1102                         y++;
1103                     }
1104                 }
1105             }
1106             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1107             if (s->restart_interval && (s->restart_interval < 1350) &&
1108                 !--s->restart_count) {
1109                 align_get_bits(&s->gb);
1110                 skip_bits(&s->gb, 16); /* skip RSTn */
1111                 for (j=0; j<nb_components; j++) /* reset dc */
1112                     s->last_dc[j] = 1024;
1113             }
1114         }
1115     }
1116     ret = 0;
1117  the_end:
1118     emms_c();
1119     return ret;
1120  out_of_range:
1121     dprintf("decode_sos: ac/dc index out of range\n");
1122     return -1;
1123 }
1124
1125 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1126 {
1127     if (get_bits(&s->gb, 16) != 4)
1128         return -1;
1129     s->restart_interval = get_bits(&s->gb, 16);
1130     dprintf("restart interval: %d\n", s->restart_interval);
1131
1132     return 0;
1133 }
1134
1135 static int mjpeg_decode_app(MJpegDecodeContext *s)
1136 {
1137     int len, id;
1138
1139     /* XXX: verify len field validity */
1140     len = get_bits(&s->gb, 16);
1141     if (len < 5)
1142         return -1;
1143
1144     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1145     id = be2me_32(id);
1146     len -= 6;
1147
1148     /* buggy AVID, it puts EOI only at every 10th frame */
1149     /* also this fourcc is used by non-avid files too, it holds some
1150        informations, but it's always present in AVID creates files */
1151     if (id == ff_get_fourcc("AVI1"))
1152     {
1153         /* structure:
1154             4bytes      AVI1
1155             1bytes      polarity
1156             1bytes      always zero
1157             4bytes      field_size
1158             4bytes      field_size_less_padding
1159         */
1160         s->buggy_avid = 1;
1161 //      if (s->first_picture)
1162 //          printf("mjpeg: workarounding buggy AVID\n");
1163         s->interlace_polarity = get_bits(&s->gb, 8);
1164 #if 0
1165         skip_bits(&s->gb, 8);
1166         skip_bits(&s->gb, 32);
1167         skip_bits(&s->gb, 32);
1168         len -= 10;
1169 #endif
1170 //      if (s->interlace_polarity)
1171 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1172         goto out;
1173     }
1174
1175 //    len -= 2;
1176
1177     if (id == ff_get_fourcc("JFIF"))
1178     {
1179         int t_w, t_h;
1180         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1181         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1182             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1183         if (get_bits(&s->gb, 8) == 0)
1184         {
1185             int x_density, y_density;
1186             x_density = get_bits(&s->gb, 16);
1187             y_density = get_bits(&s->gb, 16);
1188
1189             dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1190                 (float)x_density, y_density, (float)y_density);
1191 #if 0
1192             //MN: needs to be checked
1193             if(x_density)
1194 //                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1195                 s->avctx->aspect_ratio = (float)x_density/y_density;
1196                 /* it's better, but every JFIF I have seen stores 1:1 */
1197             else
1198                 s->avctx->aspect_ratio= 0.0;
1199 #endif
1200         }
1201         else
1202         {
1203             skip_bits(&s->gb, 16);
1204             skip_bits(&s->gb, 16);
1205         }
1206
1207         t_w = get_bits(&s->gb, 8);
1208         t_h = get_bits(&s->gb, 8);
1209         if (t_w && t_h)
1210         {
1211             /* skip thumbnail */
1212             if (len-10-(t_w*t_h*3) > 0)
1213                 len -= t_w*t_h*3;
1214         }
1215         len -= 10;
1216         goto out;
1217     }
1218
1219     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1220     {
1221         printf("mjpeg: Adobe header found\n");
1222         skip_bits(&s->gb, 16); /* version */
1223         skip_bits(&s->gb, 16); /* flags0 */
1224         skip_bits(&s->gb, 16); /* flags1 */
1225         skip_bits(&s->gb, 8); /* transform */
1226         len -= 7;
1227         goto out;
1228     }
1229
1230     /* Apple MJPEG-A */
1231     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1232     {
1233         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1234         id = be2me_32(id);
1235         len -= 4;
1236         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1237         {
1238 #if 0
1239             skip_bits(&s->gb, 32); /* field size */
1240             skip_bits(&s->gb, 32); /* pad field size */
1241             skip_bits(&s->gb, 32); /* next off */
1242             skip_bits(&s->gb, 32); /* quant off */
1243             skip_bits(&s->gb, 32); /* huff off */
1244             skip_bits(&s->gb, 32); /* image off */
1245             skip_bits(&s->gb, 32); /* scan off */
1246             skip_bits(&s->gb, 32); /* data off */
1247 #endif
1248             if (s->first_picture)
1249                 printf("mjpeg: Apple MJPEG-A header found\n");
1250         }
1251     }
1252
1253 out:
1254     /* slow but needed for extreme adobe jpegs */
1255     if (len < 0)
1256         printf("mjpeg: error, decode_app parser read over the end\n");
1257     while(--len > 0)
1258         skip_bits(&s->gb, 8);
1259
1260     return 0;
1261 }
1262
1263 static int mjpeg_decode_com(MJpegDecodeContext *s)
1264 {
1265     /* XXX: verify len field validity */
1266     unsigned int len = get_bits(&s->gb, 16);
1267     if (len >= 2 && len < 32768) {
1268         /* XXX: any better upper bound */
1269         UINT8 *cbuf = av_malloc(len - 1);
1270         if (cbuf) {
1271             int i;
1272             for (i = 0; i < len - 2; i++)
1273                 cbuf[i] = get_bits(&s->gb, 8);
1274             if (i > 0 && cbuf[i-1] == '\n')
1275                 cbuf[i-1] = 0;
1276             else
1277                 cbuf[i] = 0;
1278
1279             printf("mjpeg comment: '%s'\n", cbuf);
1280
1281             /* buggy avid, it puts EOI only at every 10th frame */
1282             if (!strcmp(cbuf, "AVID"))
1283             {
1284                 s->buggy_avid = 1;
1285                 //      if (s->first_picture)
1286                 //          printf("mjpeg: workarounding buggy AVID\n");
1287             }
1288
1289             av_free(cbuf);
1290         }
1291     }
1292
1293     return 0;
1294 }
1295
1296 #if 0
1297 static int valid_marker_list[] =
1298 {
1299         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1300 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1301 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1302 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1303 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1304 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1305 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1306 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1307 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1308 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1309 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1310 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1311 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1312 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1313 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1314 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1315 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1316 }
1317 #endif
1318
1319 /* return the 8 bit start code value and update the search
1320    state. Return -1 if no start code found */
1321 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
1322 {
1323     UINT8 *buf_ptr;
1324     unsigned int v, v2;
1325     int val;
1326 #ifdef DEBUG
1327     int skipped=0;
1328 #endif
1329
1330     buf_ptr = *pbuf_ptr;
1331     while (buf_ptr < buf_end) {
1332         v = *buf_ptr++;
1333         v2 = *buf_ptr;
1334         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1335             val = *buf_ptr++;
1336             goto found;
1337         }
1338 #ifdef DEBUG
1339         skipped++;
1340 #endif
1341     }
1342     val = -1;
1343 found:
1344 #ifdef DEBUG
1345     dprintf("find_marker skipped %d bytes\n", skipped);
1346 #endif
1347     *pbuf_ptr = buf_ptr;
1348     return val;
1349 }
1350
1351 static int mjpeg_decode_frame(AVCodecContext *avctx,
1352                               void *data, int *data_size,
1353                               UINT8 *buf, int buf_size)
1354 {
1355     MJpegDecodeContext *s = avctx->priv_data;
1356     UINT8 *buf_end, *buf_ptr;
1357     int i, start_code;
1358     AVPicture *picture = data;
1359
1360     *data_size = 0;
1361
1362     /* no supplementary picture */
1363     if (buf_size == 0)
1364         return 0;
1365
1366     buf_ptr = buf;
1367     buf_end = buf + buf_size;
1368     while (buf_ptr < buf_end) {
1369         /* find start next marker */
1370         start_code = find_marker(&buf_ptr, buf_end);
1371         {
1372             /* EOF */
1373             if (start_code < 0) {
1374                 goto the_end;
1375             } else {
1376                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1377
1378                 if ((buf_end - buf_ptr) > s->buffer_size)
1379                 {
1380                     av_free(s->buffer);
1381                     s->buffer_size = buf_end-buf_ptr;
1382                     s->buffer = av_malloc(s->buffer_size);
1383                     dprintf("buffer too small, expanding to %d bytes\n",
1384                         s->buffer_size);
1385                 }
1386
1387                 /* unescape buffer of SOS */
1388                 if (start_code == SOS)
1389                 {
1390                     UINT8 *src = buf_ptr;
1391                     UINT8 *dst = s->buffer;
1392
1393                     while (src<buf_end)
1394                     {
1395                         UINT8 x = *(src++);
1396
1397                         *(dst++) = x;
1398                         if (x == 0xff)
1399                         {
1400                             while(*src == 0xff) src++;
1401
1402                             x = *(src++);
1403                             if (x >= 0xd0 && x <= 0xd7)
1404                                 *(dst++) = x;
1405                             else if (x)
1406                                 break;
1407                         }
1408                     }
1409                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1410
1411                     dprintf("escaping removed %d bytes\n",
1412                         (buf_end - buf_ptr) - (dst - s->buffer));
1413                 }
1414                 else
1415                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1416
1417                 s->start_code = start_code;
1418
1419                 /* process markers */
1420                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1421                     dprintf("restart marker: %d\n", start_code&0x0f);
1422                 } else if (s->first_picture) {
1423                     /* APP fields */
1424                     if (start_code >= 0xe0 && start_code <= 0xef)
1425                         mjpeg_decode_app(s);
1426                     /* Comment */
1427                     else if (start_code == COM)
1428                         mjpeg_decode_com(s);
1429                 }
1430
1431                 switch(start_code) {
1432                 case SOI:
1433                     s->restart_interval = 0;
1434                     /* nothing to do on SOI */
1435                     break;
1436                 case DQT:
1437                     mjpeg_decode_dqt(s);
1438                     break;
1439                 case DHT:
1440                     mjpeg_decode_dht(s);
1441                     break;
1442                 case SOF0:
1443                     if (mjpeg_decode_sof0(s) < 0)
1444                         return -1;
1445                     break;
1446                 case EOI:
1447 eoi_parser:
1448                     {
1449                         if (s->interlaced) {
1450                             s->bottom_field ^= 1;
1451                             /* if not bottom field, do not output image yet */
1452                             if (s->bottom_field)
1453                                 goto not_the_end;
1454                         }
1455                         for(i=0;i<3;i++) {
1456                             picture->data[i] = s->current_picture[i];
1457                             picture->linesize[i] = (s->interlaced) ?
1458                                 s->linesize[i] >> 1 : s->linesize[i];
1459                         }
1460                         *data_size = sizeof(AVPicture);
1461                         avctx->height = s->height;
1462                         if (s->interlaced)
1463                             avctx->height *= 2;
1464                         avctx->width = s->width;
1465                         /* XXX: not complete test ! */
1466                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1467                         case 0x11:
1468                             avctx->pix_fmt = PIX_FMT_YUV444P;
1469                             break;
1470                         case 0x21:
1471                             avctx->pix_fmt = PIX_FMT_YUV422P;
1472                             break;
1473                         default:
1474                         case 0x22:
1475                             avctx->pix_fmt = PIX_FMT_YUV420P;
1476                             break;
1477                         }
1478                         /* dummy quality */
1479                         /* XXX: infer it with matrix */
1480 //                      avctx->quality = 3;
1481                         goto the_end;
1482                     }
1483                     break;
1484                 case SOS:
1485                     mjpeg_decode_sos(s);
1486                     /* buggy avid puts EOI every 10-20th frame */
1487                     /* if restart period is over process EOI */
1488                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1489                         goto eoi_parser;
1490                     break;
1491                 case DRI:
1492                     mjpeg_decode_dri(s);
1493                     break;
1494                 case SOF1:
1495                 case SOF2:
1496                 case SOF3:
1497                 case SOF5:
1498                 case SOF6:
1499                 case SOF7:
1500                 case SOF9:
1501                 case SOF10:
1502                 case SOF11:
1503                 case SOF13:
1504                 case SOF14:
1505                 case SOF15:
1506                 case JPG:
1507                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1508                     break;
1509 //              default:
1510 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1511 //                  break;
1512                 }
1513
1514 not_the_end:
1515                 /* eof process start code */
1516                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1517                 dprintf("marker parser used %d bytes (%d bits)\n",
1518                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1519             }
1520         }
1521     }
1522 the_end:
1523     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1524 //    return buf_end - buf_ptr;
1525     return buf_ptr - buf;
1526 }
1527
1528 static int mjpegb_decode_frame(AVCodecContext *avctx,
1529                               void *data, int *data_size,
1530                               UINT8 *buf, int buf_size)
1531 {
1532     MJpegDecodeContext *s = avctx->priv_data;
1533     UINT8 *buf_end, *buf_ptr;
1534     int i;
1535     AVPicture *picture = data;
1536     GetBitContext hgb; /* for the header */
1537     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1538     uint32_t field_size;
1539
1540     *data_size = 0;
1541
1542     /* no supplementary picture */
1543     if (buf_size == 0)
1544         return 0;
1545
1546     buf_ptr = buf;
1547     buf_end = buf + buf_size;
1548
1549 read_header:
1550     /* reset on every SOI */
1551     s->restart_interval = 0;
1552
1553     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1554
1555     skip_bits(&hgb, 32); /* reserved zeros */
1556
1557     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1558     {
1559         dprintf("not mjpeg-b (bad fourcc)\n");
1560         return 0;
1561     }
1562
1563     field_size = get_bits(&hgb, 32); /* field size */
1564     dprintf("field size: 0x%x\n", field_size);
1565     skip_bits(&hgb, 32); /* padded field size */
1566     second_field_offs = get_bits(&hgb, 32);
1567     dprintf("second field offs: 0x%x\n", second_field_offs);
1568     if (second_field_offs)
1569         s->interlaced = 1;
1570
1571     dqt_offs = get_bits(&hgb, 32);
1572     dprintf("dqt offs: 0x%x\n", dqt_offs);
1573     if (dqt_offs)
1574     {
1575         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1576         s->start_code = DQT;
1577         mjpeg_decode_dqt(s);
1578     }
1579
1580     dht_offs = get_bits(&hgb, 32);
1581     dprintf("dht offs: 0x%x\n", dht_offs);
1582     if (dht_offs)
1583     {
1584         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1585         s->start_code = DHT;
1586         mjpeg_decode_dht(s);
1587     }
1588
1589     sof_offs = get_bits(&hgb, 32);
1590     dprintf("sof offs: 0x%x\n", sof_offs);
1591     if (sof_offs)
1592     {
1593         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1594         s->start_code = SOF0;
1595         if (mjpeg_decode_sof0(s) < 0)
1596             return -1;
1597     }
1598
1599     sos_offs = get_bits(&hgb, 32);
1600     dprintf("sos offs: 0x%x\n", sos_offs);
1601     if (sos_offs)
1602     {
1603 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1604         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1605         s->start_code = SOS;
1606         mjpeg_decode_sos(s);
1607     }
1608
1609     skip_bits(&hgb, 32); /* start of data offset */
1610
1611     if (s->interlaced) {
1612         s->bottom_field ^= 1;
1613         /* if not bottom field, do not output image yet */
1614         if (s->bottom_field && second_field_offs)
1615         {
1616             buf_ptr = buf + second_field_offs;
1617             second_field_offs = 0;
1618             goto read_header;
1619         }
1620     }
1621
1622     for(i=0;i<3;i++) {
1623         picture->data[i] = s->current_picture[i];
1624         picture->linesize[i] = (s->interlaced) ?
1625             s->linesize[i] >> 1 : s->linesize[i];
1626     }
1627     *data_size = sizeof(AVPicture);
1628     avctx->height = s->height;
1629     if (s->interlaced)
1630         avctx->height *= 2;
1631     avctx->width = s->width;
1632     /* XXX: not complete test ! */
1633     switch((s->h_count[0] << 4) | s->v_count[0]) {
1634         case 0x11:
1635             avctx->pix_fmt = PIX_FMT_YUV444P;
1636             break;
1637         case 0x21:
1638             avctx->pix_fmt = PIX_FMT_YUV422P;
1639             break;
1640         default:
1641         case 0x22:
1642             avctx->pix_fmt = PIX_FMT_YUV420P;
1643             break;
1644     }
1645     /* dummy quality */
1646     /* XXX: infer it with matrix */
1647 //    avctx->quality = 3;
1648
1649     return buf_ptr - buf;
1650 }
1651
1652
1653 static int mjpeg_decode_end(AVCodecContext *avctx)
1654 {
1655     MJpegDecodeContext *s = avctx->priv_data;
1656     int i, j;
1657
1658     av_free(s->buffer);
1659     for(i=0;i<MAX_COMPONENTS;i++)
1660         av_free(s->current_picture[i]);
1661     for(i=0;i<2;i++) {
1662         for(j=0;j<4;j++)
1663             free_vlc(&s->vlcs[i][j]);
1664     }
1665     return 0;
1666 }
1667
1668 AVCodec mjpeg_decoder = {
1669     "mjpeg",
1670     CODEC_TYPE_VIDEO,
1671     CODEC_ID_MJPEG,
1672     sizeof(MJpegDecodeContext),
1673     mjpeg_decode_init,
1674     NULL,
1675     mjpeg_decode_end,
1676     mjpeg_decode_frame,
1677     0,
1678     NULL
1679 };
1680
1681 AVCodec mjpegb_decoder = {
1682     "mjpegb",
1683     CODEC_TYPE_VIDEO,
1684     CODEC_ID_MJPEGB,
1685     sizeof(MJpegDecodeContext),
1686     mjpeg_decode_init,
1687     NULL,
1688     mjpeg_decode_end,
1689     mjpegb_decode_frame,
1690     0,
1691     NULL
1692 };