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
  24 /**
  25  * @file mjpeg.c
  26  * MJPEG encoder and decoder.
  27  */
  28
  29 //#define DEBUG
  30 #include <assert.h>
  31
  32 #include "avcodec.h"
  33 #include "dsputil.h"
  34 #include "mpegvideo.h"
  35
  36 /* use two quantizer tables (one for luminance and one for chrominance) */
  37 /* not yet working */
  38 #undef TWOMATRIXES
  39
  40 typedef struct MJpegContext {
  41     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
  42     uint16_t huff_code_dc_luminance[12];
  43     uint8_t huff_size_dc_chrominance[12];
  44     uint16_t huff_code_dc_chrominance[12];
  45
  46     uint8_t huff_size_ac_luminance[256];
  47     uint16_t huff_code_ac_luminance[256];
  48     uint8_t huff_size_ac_chrominance[256];
  49     uint16_t huff_code_ac_chrominance[256];
  50 } MJpegContext;
  51
  52 /* JPEG marker codes */
  53 typedef enum {
  54     /* start of frame */
  55     SOF0  = 0xc0,       /* baseline */
  56     SOF1  = 0xc1,       /* extended sequential, huffman */
  57     SOF2  = 0xc2,       /* progressive, huffman */
  58     SOF3  = 0xc3,       /* lossless, huffman */
  59
  60     SOF5  = 0xc5,       /* differential sequential, huffman */
  61     SOF6  = 0xc6,       /* differential progressive, huffman */
  62     SOF7  = 0xc7,       /* differential lossless, huffman */
  63     JPG   = 0xc8,       /* reserved for JPEG extension */
  64     SOF9  = 0xc9,       /* extended sequential, arithmetic */
  65     SOF10 = 0xca,       /* progressive, arithmetic */
  66     SOF11 = 0xcb,       /* lossless, arithmetic */
  67
  68     SOF13 = 0xcd,       /* differential sequential, arithmetic */
  69     SOF14 = 0xce,       /* differential progressive, arithmetic */
  70     SOF15 = 0xcf,       /* differential lossless, arithmetic */
  71
  72     DHT   = 0xc4,       /* define huffman tables */
  73
  74     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
  75
  76     /* restart with modulo 8 count "m" */
  77     RST0  = 0xd0,
  78     RST1  = 0xd1,
  79     RST2  = 0xd2,
  80     RST3  = 0xd3,
  81     RST4  = 0xd4,
  82     RST5  = 0xd5,
  83     RST6  = 0xd6,
  84     RST7  = 0xd7,
  85
  86     SOI   = 0xd8,       /* start of image */
  87     EOI   = 0xd9,       /* end of image */
  88     SOS   = 0xda,       /* start of scan */
  89     DQT   = 0xdb,       /* define quantization tables */
  90     DNL   = 0xdc,       /* define number of lines */
  91     DRI   = 0xdd,       /* define restart interval */
  92     DHP   = 0xde,       /* define hierarchical progression */
  93     EXP   = 0xdf,       /* expand reference components */
  94
  95     APP0  = 0xe0,
  96     APP1  = 0xe1,
  97     APP2  = 0xe2,
  98     APP3  = 0xe3,
  99     APP4  = 0xe4,
 100     APP5  = 0xe5,
 101     APP6  = 0xe6,
 102     APP7  = 0xe7,
 103     APP8  = 0xe8,
 104     APP9  = 0xe9,
 105     APP10 = 0xea,
 106     APP11 = 0xeb,
 107     APP12 = 0xec,
 108     APP13 = 0xed,
 109     APP14 = 0xee,
 110     APP15 = 0xef,
 111
 112     JPG0  = 0xf0,
 113     JPG1  = 0xf1,
 114     JPG2  = 0xf2,
 115     JPG3  = 0xf3,
 116     JPG4  = 0xf4,
 117     JPG5  = 0xf5,
 118     JPG6  = 0xf6,
 119     JPG7  = 0xf7,
 120     JPG8  = 0xf8,
 121     JPG9  = 0xf9,
 122     JPG10 = 0xfa,
 123     JPG11 = 0xfb,
 124     JPG12 = 0xfc,
 125     JPG13 = 0xfd,
 126
 127     COM   = 0xfe,       /* comment */
 128
 129     TEM   = 0x01,       /* temporary private use for arithmetic coding */
 130
 131     /* 0x02 -> 0xbf reserved */
 132 } JPEG_MARKER;
 133
 134 #if 0
 135 /* These are the sample quantization tables given in JPEG spec section K.1.
 136  * The spec says that the values given produce "good" quality, and
 137  * when divided by 2, "very good" quality.
 138  */
 139 static const unsigned char std_luminance_quant_tbl[64] = {
 140     16,  11,  10,  16,  24,  40,  51,  61,
 141     12,  12,  14,  19,  26,  58,  60,  55,
 142     14,  13,  16,  24,  40,  57,  69,  56,
 143     14,  17,  22,  29,  51,  87,  80,  62,
 144     18,  22,  37,  56,  68, 109, 103,  77,
 145     24,  35,  55,  64,  81, 104, 113,  92,
 146     49,  64,  78,  87, 103, 121, 120, 101,
 147     72,  92,  95,  98, 112, 100, 103,  99
 148 };
 149 static const unsigned char std_chrominance_quant_tbl[64] = {
 150     17,  18,  24,  47,  99,  99,  99,  99,
 151     18,  21,  26,  66,  99,  99,  99,  99,
 152     24,  26,  56,  99,  99,  99,  99,  99,
 153     47,  66,  99,  99,  99,  99,  99,  99,
 154     99,  99,  99,  99,  99,  99,  99,  99,
 155     99,  99,  99,  99,  99,  99,  99,  99,
 156     99,  99,  99,  99,  99,  99,  99,  99,
 157     99,  99,  99,  99,  99,  99,  99,  99
 158 };
 159 #endif
 160
 161 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 162 /* IMPORTANT: these are only valid for 8-bit data precision! */
 163 static const uint8_t bits_dc_luminance[17] =
 164 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
 165 static const uint8_t val_dc_luminance[] =
 166 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 167
 168 static const uint8_t bits_dc_chrominance[17] =
 169 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 170 static const uint8_t val_dc_chrominance[] =
 171 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 172
 173 static const uint8_t bits_ac_luminance[17] =
 174 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 175 static const uint8_t val_ac_luminance[] =
 176 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 177   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 178   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 179   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 180   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 181   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 182   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 183   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 184   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 185   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 186   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 187   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 188   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 189   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 190   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 191   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 192   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 193   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 194   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 195   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 196   0xf9, 0xfa
 197 };
 198
 199 static const uint8_t bits_ac_chrominance[17] =
 200 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 201
 202 static const uint8_t val_ac_chrominance[] =
 203 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 204   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 205   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 206   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 207   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 208   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 209   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 210   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 211   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 212   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 213   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 214   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 215   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 216   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 217   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 218   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 219   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 220   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 221   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 222   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 223   0xf9, 0xfa
 224 };
 225
 226 /* isn't this function nicer than the one in the libjpeg ? */
 227 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
 228                                 const uint8_t *bits_table, const uint8_t *val_table)
 229 {
 230     int i, j, k,nb, code, sym;
 231
 232     code = 0;
 233     k = 0;
 234     for(i=1;i<=16;i++) {
 235         nb = bits_table[i];
 236         for(j=0;j<nb;j++) {
 237             sym = val_table[k++];
 238             huff_size[sym] = i;
 239             huff_code[sym] = code;
 240             code++;
 241         }
 242         code <<= 1;
 243     }
 244 }
 245
 246 int mjpeg_init(MpegEncContext *s)
 247 {
 248     MJpegContext *m;
 249
 250     m = av_malloc(sizeof(MJpegContext));
 251     if (!m)
 252         return -1;
 253
 254     s->min_qcoeff=-1023;
 255     s->max_qcoeff= 1023;
 256
 257     /* build all the huffman tables */
 258     build_huffman_codes(m->huff_size_dc_luminance,
 259                         m->huff_code_dc_luminance,
 260                         bits_dc_luminance,
 261                         val_dc_luminance);
 262     build_huffman_codes(m->huff_size_dc_chrominance,
 263                         m->huff_code_dc_chrominance,
 264                         bits_dc_chrominance,
 265                         val_dc_chrominance);
 266     build_huffman_codes(m->huff_size_ac_luminance,
 267                         m->huff_code_ac_luminance,
 268                         bits_ac_luminance,
 269                         val_ac_luminance);
 270     build_huffman_codes(m->huff_size_ac_chrominance,
 271                         m->huff_code_ac_chrominance,
 272                         bits_ac_chrominance,
 273                         val_ac_chrominance);
 274
 275     s->mjpeg_ctx = m;
 276     return 0;
 277 }
 278
 279 void mjpeg_close(MpegEncContext *s)
 280 {
 281     av_free(s->mjpeg_ctx);
 282 }
 283
 284 #define PREDICT(ret, topleft, top, left, predictor)\
 285     switch(predictor){\
 286         case 1: ret= left; break;\
 287         case 2: ret= top; break;\
 288         case 3: ret= topleft; break;\
 289         case 4: ret= left   +   top - topleft; break;\
 290         case 5: ret= left   + ((top - topleft)>>1); break;\
 291         case 6: ret= top + ((left   - topleft)>>1); break;\
 292         case 7: ret= (left + top)>>1; break;\
 293     }
 294
 295 #ifdef CONFIG_ENCODERS
 296 static inline void put_marker(PutBitContext *p, int code)
 297 {
 298     put_bits(p, 8, 0xff);
 299     put_bits(p, 8, code);
 300 }
 301
 302 /* table_class: 0 = DC coef, 1 = AC coefs */
 303 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 304                              const uint8_t *bits_table, const uint8_t *value_table)
 305 {
 306     PutBitContext *p = &s->pb;
 307     int n, i;
 308
 309     put_bits(p, 4, table_class);
 310     put_bits(p, 4, table_id);
 311
 312     n = 0;
 313     for(i=1;i<=16;i++) {
 314         n += bits_table[i];
 315         put_bits(p, 8, bits_table[i]);
 316     }
 317
 318     for(i=0;i<n;i++)
 319         put_bits(p, 8, value_table[i]);
 320
 321     return n + 17;
 322 }
 323
 324 static void jpeg_table_header(MpegEncContext *s)
 325 {
 326     PutBitContext *p = &s->pb;
 327     int i, j, size;
 328     uint8_t *ptr;
 329
 330     /* quant matrixes */
 331     put_marker(p, DQT);
 332 #ifdef TWOMATRIXES
 333     put_bits(p, 16, 2 + 2 * (1 + 64));
 334 #else
 335     put_bits(p, 16, 2 + 1 * (1 + 64));
 336 #endif
 337     put_bits(p, 4, 0); /* 8 bit precision */
 338     put_bits(p, 4, 0); /* table 0 */
 339     for(i=0;i<64;i++) {
 340         j = s->intra_scantable.permutated[i];
 341         put_bits(p, 8, s->intra_matrix[j]);
 342     }
 343 #ifdef TWOMATRIXES
 344     put_bits(p, 4, 0); /* 8 bit precision */
 345     put_bits(p, 4, 1); /* table 1 */
 346     for(i=0;i<64;i++) {
 347         j = s->intra_scantable.permutated[i];
 348         put_bits(p, 8, s->chroma_intra_matrix[j]);
 349     }
 350 #endif
 351
 352     /* huffman table */
 353     put_marker(p, DHT);
 354     flush_put_bits(p);
 355     ptr = pbBufPtr(p);
 356     put_bits(p, 16, 0); /* patched later */
 357     size = 2;
 358     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 359     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 360
 361     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 362     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 363     ptr[0] = size >> 8;
 364     ptr[1] = size;
 365 }
 366
 367 static void jpeg_put_comments(MpegEncContext *s)
 368 {
 369     PutBitContext *p = &s->pb;
 370     int size;
 371     uint8_t *ptr;
 372
 373     if (s->aspect_ratio_info /* && !lossless */)
 374     {
 375     /* JFIF header */
 376     put_marker(p, APP0);
 377     put_bits(p, 16, 16);
 378     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
 379     put_bits(p, 16, 0x0201); /* v 1.02 */
 380     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
 381     switch(s->aspect_ratio_info)
 382     {
 383         case FF_ASPECT_4_3_625:
 384         case FF_ASPECT_4_3_525:
 385             put_bits(p, 16, 4);
 386             put_bits(p, 16, 3);
 387             break;
 388         case FF_ASPECT_16_9_625:
 389         case FF_ASPECT_16_9_525:
 390             put_bits(p, 16, 16);
 391             put_bits(p, 16, 9);
 392             break;
 393         case FF_ASPECT_EXTENDED:
 394             put_bits(p, 16, s->aspected_width);
 395             put_bits(p, 16, s->aspected_height);
 396             break;
 397         case FF_ASPECT_SQUARE:
 398         default:
 399             put_bits(p, 16, 1); /* aspect: 1:1 */
 400             put_bits(p, 16, 1);
 401             break;
 402     }
 403     put_bits(p, 8, 0); /* thumbnail width */
 404     put_bits(p, 8, 0); /* thumbnail height */
 405     }
 406
 407     /* comment */
 408     if(!(s->flags & CODEC_FLAG_BITEXACT)){
 409         put_marker(p, COM);
 410         flush_put_bits(p);
 411         ptr = pbBufPtr(p);
 412         put_bits(p, 16, 0); /* patched later */
 413         put_string(p, LIBAVCODEC_IDENT);
 414         size = strlen(LIBAVCODEC_IDENT)+3;
 415         ptr[0] = size >> 8;
 416         ptr[1] = size;
 417     }
 418 }
 419
 420 void mjpeg_picture_header(MpegEncContext *s)
 421 {
 422     const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
 423
 424     put_marker(&s->pb, SOI);
 425
 426     if (!s->mjpeg_data_only_frames)
 427     {
 428     jpeg_put_comments(s);
 429
 430     if (s->mjpeg_write_tables) jpeg_table_header(s);
 431
 432     put_marker(&s->pb, lossless ? SOF3 : SOF0);
 433
 434     put_bits(&s->pb, 16, 17);
 435     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
 436         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
 437     else
 438         put_bits(&s->pb, 8, 8); /* 8 bits/component */
 439     put_bits(&s->pb, 16, s->height);
 440     put_bits(&s->pb, 16, s->width);
 441     put_bits(&s->pb, 8, 3); /* 3 components */
 442
 443     /* Y component */
 444     put_bits(&s->pb, 8, 1); /* component number */
 445     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
 446     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
 447     put_bits(&s->pb, 8, 0); /* select matrix */
 448
 449     /* Cb component */
 450     put_bits(&s->pb, 8, 2); /* component number */
 451     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
 452     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 453 #ifdef TWOMATRIXES
 454     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 455 #else
 456     put_bits(&s->pb, 8, 0); /* select matrix */
 457 #endif
 458
 459     /* Cr component */
 460     put_bits(&s->pb, 8, 3); /* component number */
 461     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
 462     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 463 #ifdef TWOMATRIXES
 464     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 465 #else
 466     put_bits(&s->pb, 8, 0); /* select matrix */
 467 #endif
 468     }
 469
 470     /* scan header */
 471     put_marker(&s->pb, SOS);
 472     put_bits(&s->pb, 16, 12); /* length */
 473     put_bits(&s->pb, 8, 3); /* 3 components */
 474
 475     /* Y component */
 476     put_bits(&s->pb, 8, 1); /* index */
 477     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 478     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 479
 480     /* Cb component */
 481     put_bits(&s->pb, 8, 2); /* index */
 482     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 483     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 484
 485     /* Cr component */
 486     put_bits(&s->pb, 8, 3); /* index */
 487     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 488     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 489
 490     put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
 491     put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
 492     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 493 }
 494
 495 static void escape_FF(MpegEncContext *s, int start)
 496 {
 497     int size= get_bit_count(&s->pb) - start*8;
 498     int i, ff_count;
 499     uint8_t *buf= s->pb.buf + start;
 500     int align= (-(size_t)(buf))&3;
 501
 502     assert((size&7) == 0);
 503     size >>= 3;
 504
 505     ff_count=0;
 506     for(i=0; i<size && i<align; i++){
 507         if(buf[i]==0xFF) ff_count++;
 508     }
 509     for(; i<size-15; i+=16){
 510         int acc, v;
 511
 512         v= *(uint32_t*)(&buf[i]);
 513         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 514         v= *(uint32_t*)(&buf[i+4]);
 515         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 516         v= *(uint32_t*)(&buf[i+8]);
 517         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 518         v= *(uint32_t*)(&buf[i+12]);
 519         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 520
 521         acc>>=4;
 522         acc+= (acc>>16);
 523         acc+= (acc>>8);
 524         ff_count+= acc&0xFF;
 525     }
 526     for(; i<size; i++){
 527         if(buf[i]==0xFF) ff_count++;
 528     }
 529
 530     if(ff_count==0) return;
 531
 532     /* skip put bits */
 533     for(i=0; i<ff_count-3; i+=4)
 534         put_bits(&s->pb, 32, 0);
 535     put_bits(&s->pb, (ff_count-i)*8, 0);
 536     flush_put_bits(&s->pb);
 537
 538     for(i=size-1; ff_count; i--){
 539         int v= buf[i];
 540
 541         if(v==0xFF){
 542 //printf("%d %d\n", i, ff_count);
 543             buf[i+ff_count]= 0;
 544             ff_count--;
 545         }
 546
 547         buf[i+ff_count]= v;
 548     }
 549 }
 550
 551 void mjpeg_picture_trailer(MpegEncContext *s)
 552 {
 553     int pad= (-get_bit_count(&s->pb))&7;
 554
 555     put_bits(&s->pb, pad,0xFF>>(8-pad));
 556     flush_put_bits(&s->pb);
 557
 558     assert((s->header_bits&7)==0);
 559
 560     escape_FF(s, s->header_bits>>3);
 561
 562     put_marker(&s->pb, EOI);
 563 }
 564
 565 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 566                                    uint8_t *huff_size, uint16_t *huff_code)
 567 {
 568     int mant, nbits;
 569
 570     if (val == 0) {
 571         put_bits(&s->pb, huff_size[0], huff_code[0]);
 572     } else {
 573         mant = val;
 574         if (val < 0) {
 575             val = -val;
 576             mant--;
 577         }
 578
 579         nbits= av_log2_16bit(val) + 1;
 580
 581         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 582
 583         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 584     }
 585 }
 586
 587 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 588 {
 589     int mant, nbits, code, i, j;
 590     int component, dc, run, last_index, val;
 591     MJpegContext *m = s->mjpeg_ctx;
 592     uint8_t *huff_size_ac;
 593     uint16_t *huff_code_ac;
 594
 595     /* DC coef */
 596     component = (n <= 3 ? 0 : n - 4 + 1);
 597     dc = block[0]; /* overflow is impossible */
 598     val = dc - s->last_dc[component];
 599     if (n < 4) {
 600         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 601         huff_size_ac = m->huff_size_ac_luminance;
 602         huff_code_ac = m->huff_code_ac_luminance;
 603     } else {
 604         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 605         huff_size_ac = m->huff_size_ac_chrominance;
 606         huff_code_ac = m->huff_code_ac_chrominance;
 607     }
 608     s->last_dc[component] = dc;
 609
 610     /* AC coefs */
 611
 612     run = 0;
 613     last_index = s->block_last_index[n];
 614     for(i=1;i<=last_index;i++) {
 615         j = s->intra_scantable.permutated[i];
 616         val = block[j];
 617         if (val == 0) {
 618             run++;
 619         } else {
 620             while (run >= 16) {
 621                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 622                 run -= 16;
 623             }
 624             mant = val;
 625             if (val < 0) {
 626                 val = -val;
 627                 mant--;
 628             }
 629
 630             nbits= av_log2(val) + 1;
 631             code = (run << 4) | nbits;
 632
 633             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 634
 635             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 636             run = 0;
 637         }
 638     }
 639
 640     /* output EOB only if not already 64 values */
 641     if (last_index < 63 || run != 0)
 642         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 643 }
 644
 645 void mjpeg_encode_mb(MpegEncContext *s,
 646                      DCTELEM block[6][64])
 647 {
 648     int i;
 649     for(i=0;i<6;i++) {
 650         encode_block(s, block[i], i);
 651     }
 652 }
 653
 654 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 655     MpegEncContext * const s = avctx->priv_data;
 656     MJpegContext * const m = s->mjpeg_ctx;
 657     AVFrame *pict = data;
 658     const int width= s->width;
 659     const int height= s->height;
 660     AVFrame * const p= (AVFrame*)&s->current_picture;
 661     const int predictor= avctx->prediction_method+1;
 662
 663     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
 664
 665     *p = *pict;
 666     p->pict_type= FF_I_TYPE;
 667     p->key_frame= 1;
 668
 669     mjpeg_picture_header(s);
 670
 671     s->header_bits= get_bit_count(&s->pb);
 672
 673     if(avctx->pix_fmt == PIX_FMT_RGBA32){
 674         int x, y, i;
 675         const int linesize= p->linesize[0];
 676         uint16_t buffer[2048][4];
 677         int left[3], top[3], topleft[3];
 678
 679         for(i=0; i<3; i++){
 680             buffer[0][i]= 1 << (9 - 1);
 681         }
 682
 683         for(y = 0; y < height; y++) {
 684             const int modified_predictor= y ? 1 : predictor;
 685             uint8_t *ptr = p->data[0] + (linesize * y);
 686
 687             for(i=0; i<3; i++){
 688                 top[i]= left[i]= topleft[i]= buffer[0][i];
 689             }
 690             for(x = 0; x < width; x++) {
 691                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
 692                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
 693                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
 694
 695                 for(i=0;i<3;i++) {
 696                     int pred, diff;
 697
 698                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
 699
 700                     topleft[i]= top[i];
 701                     top[i]= buffer[x+1][i];
 702
 703                     left[i]= buffer[x][i];
 704
 705                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
 706
 707                     if(i==0)
 708                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 709                     else
 710                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 711                 }
 712             }
 713         }
 714     }else{
 715         int mb_x, mb_y, i;
 716         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
 717         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
 718
 719         for(mb_y = 0; mb_y < mb_height; mb_y++) {
 720             for(mb_x = 0; mb_x < mb_width; mb_x++) {
 721                 if(mb_x==0 || mb_y==0){
 722                     for(i=0;i<3;i++) {
 723                         uint8_t *ptr;
 724                         int x, y, h, v, linesize;
 725                         h = s->mjpeg_hsample[i];
 726                         v = s->mjpeg_vsample[i];
 727                         linesize= p->linesize[i];
 728
 729                         for(y=0; y<v; y++){
 730                             for(x=0; x<h; x++){
 731                                 int pred;
 732
 733                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 734                                 if(y==0 && mb_y==0){
 735                                     if(x==0 && mb_x==0){
 736                                         pred= 128;
 737                                     }else{
 738                                         pred= ptr[-1];
 739                                     }
 740                                 }else{
 741                                     if(x==0 && mb_x==0){
 742                                         pred= ptr[-linesize];
 743                                     }else{
 744                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 745                                     }
 746                                 }
 747
 748                                 if(i==0)
 749                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 750                                 else
 751                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 752                             }
 753                         }
 754                     }
 755                 }else{
 756                     for(i=0;i<3;i++) {
 757                         uint8_t *ptr;
 758                         int x, y, h, v, linesize;
 759                         h = s->mjpeg_hsample[i];
 760                         v = s->mjpeg_vsample[i];
 761                         linesize= p->linesize[i];
 762
 763                         for(y=0; y<v; y++){
 764                             for(x=0; x<h; x++){
 765                                 int pred;
 766
 767                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 768 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
 769                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 770
 771                                 if(i==0)
 772                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 773                                 else
 774                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 775                             }
 776                         }
 777                     }
 778                 }
 779             }
 780         }
 781     }
 782
 783     emms_c();
 784
 785     mjpeg_picture_trailer(s);
 786     s->picture_number++;
 787
 788     flush_put_bits(&s->pb);
 789     return pbBufPtr(&s->pb) - s->pb.buf;
 790 //    return (get_bit_count(&f->pb)+7)/8;
 791 }
 792
 793 #endif //CONFIG_ENCODERS
 794
 795 /******************************************/
 796 /* decoding */
 797
 798 #define MAX_COMPONENTS 4
 799
 800 typedef struct MJpegDecodeContext {
 801     AVCodecContext *avctx;
 802     GetBitContext gb;
 803     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 804
 805     int start_code; /* current start code */
 806     int buffer_size;
 807     uint8_t *buffer;
 808
 809     int16_t quant_matrixes[4][64];
 810     VLC vlcs[2][4];
 811
 812     int org_width, org_height;  /* size given at codec init */
 813     int first_picture;    /* true if decoding first picture */
 814     int interlaced;     /* true if interlaced */
 815     int bottom_field;   /* true if bottom field */
 816     int lossless;
 817     int rgb;
 818     int rct;            /* standard rct */
 819     int pegasus_rct;    /* pegasus reversible colorspace transform */
 820     int bits;           /* bits per component */
 821
 822     int width, height;
 823     int nb_components;
 824     int component_id[MAX_COMPONENTS];
 825     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 826     int v_count[MAX_COMPONENTS];
 827     int h_max, v_max; /* maximum h and v counts */
 828     int quant_index[4];   /* quant table index for each component */
 829     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 830     uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
 831     int linesize[MAX_COMPONENTS];
 832     DCTELEM block[64] __align8;
 833     ScanTable scantable;
 834     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 835
 836     int restart_interval;
 837     int restart_count;
 838
 839     int buggy_avid;
 840     int interlace_polarity;
 841 } MJpegDecodeContext;
 842
 843 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 844
 845 static void build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
 846                       int nb_codes)
 847 {
 848     uint8_t huff_size[256];
 849     uint16_t huff_code[256];
 850
 851     memset(huff_size, 0, sizeof(huff_size));
 852     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 853
 854     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 855 }
 856
 857 static int mjpeg_decode_init(AVCodecContext *avctx)
 858 {
 859     MJpegDecodeContext *s = avctx->priv_data;
 860     MpegEncContext s2;
 861
 862     s->avctx = avctx;
 863
 864     /* ugly way to get the idct & scantable FIXME */
 865     memset(&s2, 0, sizeof(MpegEncContext));
 866     s2.flags= avctx->flags;
 867     s2.avctx= avctx;
 868 //    s2->out_format = FMT_MJPEG;
 869     s2.width = 8;
 870     s2.height = 8;
 871     if (MPV_common_init(&s2) < 0)
 872        return -1;
 873     s->scantable= s2.intra_scantable;
 874     s->idct_put= s2.dsp.idct_put;
 875     MPV_common_end(&s2);
 876
 877     s->mpeg_enc_ctx_allocated = 0;
 878     s->buffer_size = 102400; /* smaller buffer should be enough,
 879                                 but photojpg files could ahive bigger sizes */
 880     s->buffer = av_malloc(s->buffer_size);
 881     if (!s->buffer)
 882         return -1;
 883     s->start_code = -1;
 884     s->first_picture = 1;
 885     s->org_width = avctx->width;
 886     s->org_height = avctx->height;
 887
 888     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 889     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 890     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 891     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 892
 893     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 894     {
 895         printf("mjpeg: using external huffman table\n");
 896         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 897         mjpeg_decode_dht(s);
 898         /* should check for error - but dunno */
 899     }
 900
 901     return 0;
 902 }
 903
 904 /* quantize tables */
 905 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 906 {
 907     int len, index, i, j;
 908
 909     len = get_bits(&s->gb, 16) - 2;
 910
 911     while (len >= 65) {
 912         /* only 8 bit precision handled */
 913         if (get_bits(&s->gb, 4) != 0)
 914         {
 915             dprintf("dqt: 16bit precision\n");
 916             return -1;
 917         }
 918         index = get_bits(&s->gb, 4);
 919         if (index >= 4)
 920             return -1;
 921         dprintf("index=%d\n", index);
 922         /* read quant table */
 923         for(i=0;i<64;i++) {
 924             j = s->scantable.permutated[i];
 925             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 926         }
 927         len -= 65;
 928     }
 929
 930     return 0;
 931 }
 932
 933 /* decode huffman tables and build VLC decoders */
 934 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 935 {
 936     int len, index, i, class, n, v, code_max;
 937     uint8_t bits_table[17];
 938     uint8_t val_table[256];
 939
 940     len = get_bits(&s->gb, 16) - 2;
 941
 942     while (len > 0) {
 943         if (len < 17)
 944             return -1;
 945         class = get_bits(&s->gb, 4);
 946         if (class >= 2)
 947             return -1;
 948         index = get_bits(&s->gb, 4);
 949         if (index >= 4)
 950             return -1;
 951         n = 0;
 952         for(i=1;i<=16;i++) {
 953             bits_table[i] = get_bits(&s->gb, 8);
 954             n += bits_table[i];
 955         }
 956         len -= 17;
 957         if (len < n || n > 256)
 958             return -1;
 959
 960         code_max = 0;
 961         for(i=0;i<n;i++) {
 962             v = get_bits(&s->gb, 8);
 963             if (v > code_max)
 964                 code_max = v;
 965             val_table[i] = v;
 966         }
 967         len -= n;
 968
 969         /* build VLC and flush previous vlc if present */
 970         free_vlc(&s->vlcs[class][index]);
 971         dprintf("class=%d index=%d nb_codes=%d\n",
 972                class, index, code_max + 1);
 973         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 974     }
 975     return 0;
 976 }
 977
 978 static int mjpeg_decode_sof(MJpegDecodeContext *s)
 979 {
 980     int len, nb_components, i, width, height;
 981
 982     /* XXX: verify len field validity */
 983     len = get_bits(&s->gb, 16);
 984     s->bits= get_bits(&s->gb, 8);
 985
 986     if(s->pegasus_rct) s->bits=9;
 987     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
 988
 989     if (s->bits != 8 && !s->lossless){
 990         printf("only 8 bits/component accepted\n");
 991         return -1;
 992     }
 993     height = get_bits(&s->gb, 16);
 994     width = get_bits(&s->gb, 16);
 995     dprintf("sof0: picture: %dx%d\n", width, height);
 996
 997     nb_components = get_bits(&s->gb, 8);
 998     if (nb_components <= 0 ||
 999         nb_components > MAX_COMPONENTS)
1000         return -1;
1001     s->nb_components = nb_components;
1002     s->h_max = 1;
1003     s->v_max = 1;
1004     for(i=0;i<nb_components;i++) {
1005         /* component id */
1006         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1007         s->h_count[i] = get_bits(&s->gb, 4);
1008         s->v_count[i] = get_bits(&s->gb, 4);
1009         /* compute hmax and vmax (only used in interleaved case) */
1010         if (s->h_count[i] > s->h_max)
1011             s->h_max = s->h_count[i];
1012         if (s->v_count[i] > s->v_max)
1013             s->v_max = s->v_count[i];
1014         s->quant_index[i] = get_bits(&s->gb, 8);
1015         if (s->quant_index[i] >= 4)
1016             return -1;
1017         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1018             s->v_count[i], s->component_id[i], s->quant_index[i]);
1019     }
1020
1021     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1022
1023     /* if different size, realloc/alloc picture */
1024     /* XXX: also check h_count and v_count */
1025     if (width != s->width || height != s->height) {
1026         for(i=0;i<MAX_COMPONENTS;i++)
1027             av_freep(&s->current_picture[i]);
1028         s->width = width;
1029         s->height = height;
1030         /* test interlaced mode */
1031         if (s->first_picture &&
1032             s->org_height != 0 &&
1033             s->height < ((s->org_height * 3) / 4)) {
1034             s->interlaced = 1;
1035 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1036             s->bottom_field = 0;
1037         }
1038
1039         if(s->rgb){
1040             int w, h;
1041             w = s->width;
1042             h = s->height;
1043             if (s->interlaced)
1044                 w *= 2;
1045             s->linesize[0] = 4*w;
1046             s->current_picture[0] = av_mallocz(4*w * h);
1047             s->current_picture[1] = s->current_picture[2] = NULL;
1048         }else{
1049           for(i=0;i<nb_components;i++) {
1050             int w, h;
1051             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
1052             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
1053             w = w * 8 * s->h_count[i];
1054             h = h * 8 * s->v_count[i];
1055             if (s->interlaced)
1056                 w *= 2;
1057             s->linesize[i] = w;
1058             s->current_picture[i] = av_mallocz(w * h);
1059             if (!s->current_picture[i])
1060             {
1061                 dprintf("error: no picture buffers allocated\n");
1062                 return -1;
1063             }
1064           }
1065         }
1066         s->first_picture = 0;
1067     }
1068
1069     if (len != (8+(3*nb_components)))
1070     {
1071         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1072     }
1073
1074     return 0;
1075 }
1076
1077 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1078 {
1079     int code;
1080     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1081     if (code < 0)
1082     {
1083         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1084                 &s->vlcs[0][dc_index]);
1085         return 0xffff;
1086     }
1087
1088     if(code)
1089         return get_xbits(&s->gb, code);
1090     else
1091         return 0;
1092 }
1093
1094 /* decode block and dequantize */
1095 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1096                         int component, int dc_index, int ac_index, int quant_index)
1097 {
1098     int code, i, j, level, val;
1099     VLC *ac_vlc;
1100     int16_t *quant_matrix;
1101
1102     /* DC coef */
1103     val = mjpeg_decode_dc(s, dc_index);
1104     if (val == 0xffff) {
1105         dprintf("error dc\n");
1106         return -1;
1107     }
1108     quant_matrix = s->quant_matrixes[quant_index];
1109     val = val * quant_matrix[0] + s->last_dc[component];
1110     s->last_dc[component] = val;
1111     block[0] = val;
1112     /* AC coefs */
1113     ac_vlc = &s->vlcs[1][ac_index];
1114     i = 1;
1115     for(;;) {
1116         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1117
1118         if (code < 0) {
1119             dprintf("error ac\n");
1120             return -1;
1121         }
1122         /* EOB */
1123         if (code == 0)
1124             break;
1125         if (code == 0xf0) {
1126             i += 16;
1127         } else {
1128             level = get_xbits(&s->gb, code & 0xf);
1129             i += code >> 4;
1130             if (i >= 64) {
1131                 dprintf("error count: %d\n", i);
1132                 return -1;
1133             }
1134             j = s->scantable.permutated[i];
1135             block[j] = level * quant_matrix[j];
1136             i++;
1137             if (i >= 64)
1138                 break;
1139         }
1140     }
1141     return 0;
1142 }
1143
1144 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1145 {
1146     int len, nb_components, i, j, n, h, v, ret, point_transform, predictor;
1147     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
1148     int comp_index[4];
1149     int dc_index[4];
1150     int ac_index[4];
1151     int nb_blocks[4];
1152     int h_count[4];
1153     int v_count[4];
1154     const int block_size= s->lossless ? 1 : 8;
1155
1156     /* XXX: verify len field validity */
1157     len = get_bits(&s->gb, 16);
1158     nb_components = get_bits(&s->gb, 8);
1159     if (len != 6+2*nb_components)
1160     {
1161         dprintf("decode_sos: invalid len (%d)\n", len);
1162         return -1;
1163     }
1164     /* XXX: only interleaved scan accepted */
1165     if (nb_components != 3)
1166     {
1167         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1168         return -1;
1169     }
1170     vmax = 0;
1171     hmax = 0;
1172     for(i=0;i<nb_components;i++) {
1173         id = get_bits(&s->gb, 8) - 1;
1174         dprintf("component: %d\n", id);
1175         /* find component index */
1176         for(index=0;index<s->nb_components;index++)
1177             if (id == s->component_id[index])
1178                 break;
1179         if (index == s->nb_components)
1180         {
1181             dprintf("decode_sos: index(%d) out of components\n", index);
1182             return -1;
1183         }
1184
1185         comp_index[i] = index;
1186
1187         nb_blocks[i] = s->h_count[index] * s->v_count[index];
1188         h_count[i] = s->h_count[index];
1189         v_count[i] = s->v_count[index];
1190
1191         dc_index[i] = get_bits(&s->gb, 4);
1192         ac_index[i] = get_bits(&s->gb, 4);
1193
1194         if (dc_index[i] < 0 || ac_index[i] < 0 ||
1195             dc_index[i] >= 4 || ac_index[i] >= 4)
1196             goto out_of_range;
1197         switch(s->start_code)
1198         {
1199             case SOF0:
1200                 if (dc_index[i] > 1 || ac_index[i] > 1)
1201                     goto out_of_range;
1202                 break;
1203             case SOF1:
1204             case SOF2:
1205                 if (dc_index[i] > 3 || ac_index[i] > 3)
1206                     goto out_of_range;
1207                 break;
1208             case SOF3:
1209                 if (dc_index[i] > 3 || ac_index[i] != 0)
1210                     goto out_of_range;
1211                 break;
1212         }
1213     }
1214
1215     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1216     skip_bits(&s->gb, 8); /* Se */
1217     skip_bits(&s->gb, 4); /* Ah */
1218     point_transform= get_bits(&s->gb, 4); /* Al */
1219
1220     for(i=0;i<nb_components;i++)
1221         s->last_dc[i] = 1024;
1222
1223     if (nb_components > 1) {
1224         /* interleaved stream */
1225         mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1226         mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1227     } else {
1228         h = s->h_max / s->h_count[comp_index[0]];
1229         v = s->v_max / s->v_count[comp_index[0]];
1230         mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1231         mb_height = (s->height + v * block_size - 1) / (v * block_size);
1232         nb_blocks[0] = 1;
1233         h_count[0] = 1;
1234         v_count[0] = 1;
1235     }
1236
1237     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1238         printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1239
1240     if(s->lossless){
1241         if(s->rgb){
1242             uint16_t buffer[2048][4];
1243             int left[3], top[3], topleft[3];
1244             const int linesize= s->linesize[0];
1245             const int mask= (1<<s->bits)-1;
1246
1247             for(i=0; i<3; i++){
1248                 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1249             }
1250             for(mb_y = 0; mb_y < mb_height; mb_y++) {
1251                 const int modified_predictor= mb_y ? 1 : predictor;
1252                 uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1253
1254                 if (s->interlaced && s->bottom_field)
1255                     ptr += linesize >> 1;
1256
1257                 for(i=0; i<3; i++){
1258                     top[i]= left[i]= topleft[i]= buffer[0][i];
1259                 }
1260                 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1261                     if (s->restart_interval && !s->restart_count)
1262                         s->restart_count = s->restart_interval;
1263
1264                     for(i=0;i<3;i++) {
1265                         int pred;
1266
1267                         topleft[i]= top[i];
1268                         top[i]= buffer[mb_x][i];
1269
1270                         PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1271
1272                         left[i]=
1273                         buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, dc_index[i]) << point_transform));
1274                     }
1275
1276                     if (s->restart_interval && !--s->restart_count) {
1277                         align_get_bits(&s->gb);
1278                         skip_bits(&s->gb, 16); /* skip RSTn */
1279                     }
1280                 }
1281
1282                 if(s->rct){
1283                     for(mb_x = 0; mb_x < mb_width; mb_x++) {
1284                         ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1285                         ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1286                         ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1287                     }
1288                 }else if(s->pegasus_rct){
1289                     for(mb_x = 0; mb_x < mb_width; mb_x++) {
1290                         ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1291                         ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1292                         ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1293                     }
1294                 }else{
1295                     for(mb_x = 0; mb_x < mb_width; mb_x++) {
1296                         ptr[4*mb_x+0] = buffer[mb_x][0];
1297                         ptr[4*mb_x+1] = buffer[mb_x][1];
1298                         ptr[4*mb_x+2] = buffer[mb_x][2];
1299                     }
1300                 }
1301             }
1302         }else{
1303             for(mb_y = 0; mb_y < mb_height; mb_y++) {
1304                 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1305                     if (s->restart_interval && !s->restart_count)
1306                         s->restart_count = s->restart_interval;
1307
1308                     if(mb_x==0 || mb_y==0 || s->interlaced){
1309                         for(i=0;i<nb_components;i++) {
1310                             uint8_t *ptr;
1311                             int x, y, c, linesize;
1312                             n = nb_blocks[i];
1313                             c = comp_index[i];
1314                             h = h_count[i];
1315                             v = v_count[i];
1316                             x = 0;
1317                             y = 0;
1318                             linesize= s->linesize[c];
1319
1320                             for(j=0; j<n; j++) {
1321                                 int pred;
1322
1323                                 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1324                                 if(y==0 && mb_y==0){
1325                                     if(x==0 && mb_x==0){
1326                                         pred= 128 << point_transform;
1327                                     }else{
1328                                         pred= ptr[-1];
1329                                     }
1330                                 }else{
1331                                     if(x==0 && mb_x==0){
1332                                         pred= ptr[-linesize];
1333                                     }else{
1334                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1335                                     }
1336                                 }
1337
1338                                 if (s->interlaced && s->bottom_field)
1339                                     ptr += linesize >> 1;
1340                                 *ptr= pred + (mjpeg_decode_dc(s, dc_index[i]) << point_transform);
1341
1342                                 if (++x == h) {
1343                                     x = 0;
1344                                     y++;
1345                                 }
1346                             }
1347                         }
1348                     }else{
1349                         for(i=0;i<nb_components;i++) {
1350                             uint8_t *ptr;
1351                             int x, y, c, linesize;
1352                             n = nb_blocks[i];
1353                             c = comp_index[i];
1354                             h = h_count[i];
1355                             v = v_count[i];
1356                             x = 0;
1357                             y = 0;
1358                             linesize= s->linesize[c];
1359
1360                             for(j=0; j<n; j++) {
1361                                 int pred;
1362
1363                                 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1364                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1365                                 *ptr= pred + (mjpeg_decode_dc(s, dc_index[i]) << point_transform);
1366                                 if (++x == h) {
1367                                     x = 0;
1368                                     y++;
1369                                 }
1370                             }
1371                         }
1372                     }
1373                     if (s->restart_interval && !--s->restart_count) {
1374                         align_get_bits(&s->gb);
1375                         skip_bits(&s->gb, 16); /* skip RSTn */
1376                     }
1377                 }
1378             }
1379         }
1380     }else{
1381       for(mb_y = 0; mb_y < mb_height; mb_y++) {
1382         for(mb_x = 0; mb_x < mb_width; mb_x++) {
1383             if (s->restart_interval && !s->restart_count)
1384                 s->restart_count = s->restart_interval;
1385
1386             for(i=0;i<nb_components;i++) {
1387                 uint8_t *ptr;
1388                 int x, y, c;
1389                 n = nb_blocks[i];
1390                 c = comp_index[i];
1391                 h = h_count[i];
1392                 v = v_count[i];
1393                 x = 0;
1394                 y = 0;
1395                 for(j=0;j<n;j++) {
1396                     memset(s->block, 0, sizeof(s->block));
1397                     if (decode_block(s, s->block, i,
1398                                      dc_index[i], ac_index[i],
1399                                      s->quant_index[c]) < 0) {
1400                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1401                         ret = -1;
1402                         goto the_end;
1403                     }
1404 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1405                     ptr = s->current_picture[c] +
1406                         (s->linesize[c] * (v * mb_y + y) * 8) +
1407                         (h * mb_x + x) * 8;
1408                     if (s->interlaced && s->bottom_field)
1409                         ptr += s->linesize[c] >> 1;
1410                     s->idct_put(ptr, s->linesize[c], s->block);
1411                     if (++x == h) {
1412                         x = 0;
1413                         y++;
1414                     }
1415                 }
1416             }
1417             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1418             if (s->restart_interval && (s->restart_interval < 1350) &&
1419                 !--s->restart_count) {
1420                 align_get_bits(&s->gb);
1421                 skip_bits(&s->gb, 16); /* skip RSTn */
1422                 for (j=0; j<nb_components; j++) /* reset dc */
1423                     s->last_dc[j] = 1024;
1424             }
1425         }
1426     }
1427   }
1428     ret = 0;
1429  the_end:
1430     emms_c();
1431     return ret;
1432  out_of_range:
1433     dprintf("decode_sos: ac/dc index out of range\n");
1434     return -1;
1435 }
1436
1437 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1438 {
1439     if (get_bits(&s->gb, 16) != 4)
1440         return -1;
1441     s->restart_interval = get_bits(&s->gb, 16);
1442     dprintf("restart interval: %d\n", s->restart_interval);
1443
1444     return 0;
1445 }
1446
1447 static int mjpeg_decode_app(MJpegDecodeContext *s)
1448 {
1449     int len, id;
1450
1451     /* XXX: verify len field validity */
1452     len = get_bits(&s->gb, 16);
1453     if (len < 5)
1454         return -1;
1455
1456     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1457     id = be2me_32(id);
1458     len -= 6;
1459
1460     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1461         printf("APPx %8X\n", id);
1462     }
1463
1464     /* buggy AVID, it puts EOI only at every 10th frame */
1465     /* also this fourcc is used by non-avid files too, it holds some
1466        informations, but it's always present in AVID creates files */
1467     if (id == ff_get_fourcc("AVI1"))
1468     {
1469         /* structure:
1470             4bytes      AVI1
1471             1bytes      polarity
1472             1bytes      always zero
1473             4bytes      field_size
1474             4bytes      field_size_less_padding
1475         */
1476         s->buggy_avid = 1;
1477 //      if (s->first_picture)
1478 //          printf("mjpeg: workarounding buggy AVID\n");
1479         s->interlace_polarity = get_bits(&s->gb, 8);
1480 #if 0
1481         skip_bits(&s->gb, 8);
1482         skip_bits(&s->gb, 32);
1483         skip_bits(&s->gb, 32);
1484         len -= 10;
1485 #endif
1486 //      if (s->interlace_polarity)
1487 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1488         goto out;
1489     }
1490
1491 //    len -= 2;
1492
1493     if (id == ff_get_fourcc("JFIF"))
1494     {
1495         int t_w, t_h;
1496         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1497         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1498             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1499         if (get_bits(&s->gb, 8) == 0)
1500         {
1501             int x_density, y_density;
1502             x_density = get_bits(&s->gb, 16);
1503             y_density = get_bits(&s->gb, 16);
1504
1505             dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1506                 (float)x_density, y_density, (float)y_density);
1507 #if 0
1508             //MN: needs to be checked
1509             if(x_density)
1510 //                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1511                 s->avctx->aspect_ratio = (float)x_density/y_density;
1512                 /* it's better, but every JFIF I have seen stores 1:1 */
1513             else
1514                 s->avctx->aspect_ratio= 0.0;
1515 #endif
1516         }
1517         else
1518         {
1519             skip_bits(&s->gb, 16);
1520             skip_bits(&s->gb, 16);
1521         }
1522
1523         t_w = get_bits(&s->gb, 8);
1524         t_h = get_bits(&s->gb, 8);
1525         if (t_w && t_h)
1526         {
1527             /* skip thumbnail */
1528             if (len-10-(t_w*t_h*3) > 0)
1529                 len -= t_w*t_h*3;
1530         }
1531         len -= 10;
1532         goto out;
1533     }
1534
1535     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1536     {
1537         printf("mjpeg: Adobe header found\n");
1538         skip_bits(&s->gb, 16); /* version */
1539         skip_bits(&s->gb, 16); /* flags0 */
1540         skip_bits(&s->gb, 16); /* flags1 */
1541         skip_bits(&s->gb, 8); /* transform */
1542         len -= 7;
1543         goto out;
1544     }
1545
1546     if (id == ff_get_fourcc("LJIF")){
1547         printf("Pegasus lossless jpeg header found\n");
1548         skip_bits(&s->gb, 16); /* version ? */
1549         skip_bits(&s->gb, 16); /* unknwon always 0? */
1550         skip_bits(&s->gb, 16); /* unknwon always 0? */
1551         skip_bits(&s->gb, 16); /* unknwon always 0? */
1552         switch( get_bits(&s->gb, 8)){
1553         case 1:
1554             s->rgb= 1;
1555             s->pegasus_rct=0;
1556             break;
1557         case 2:
1558             s->rgb= 1;
1559             s->pegasus_rct=1;
1560             break;
1561         default:
1562             printf("unknown colorspace\n");
1563         }
1564         len -= 9;
1565         goto out;
1566     }
1567
1568     /* Apple MJPEG-A */
1569     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1570     {
1571         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1572         id = be2me_32(id);
1573         len -= 4;
1574         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1575         {
1576 #if 0
1577             skip_bits(&s->gb, 32); /* field size */
1578             skip_bits(&s->gb, 32); /* pad field size */
1579             skip_bits(&s->gb, 32); /* next off */
1580             skip_bits(&s->gb, 32); /* quant off */
1581             skip_bits(&s->gb, 32); /* huff off */
1582             skip_bits(&s->gb, 32); /* image off */
1583             skip_bits(&s->gb, 32); /* scan off */
1584             skip_bits(&s->gb, 32); /* data off */
1585 #endif
1586             if (s->first_picture)
1587                 printf("mjpeg: Apple MJPEG-A header found\n");
1588         }
1589     }
1590
1591 out:
1592     /* slow but needed for extreme adobe jpegs */
1593     if (len < 0)
1594         printf("mjpeg: error, decode_app parser read over the end\n");
1595     while(--len > 0)
1596         skip_bits(&s->gb, 8);
1597
1598     return 0;
1599 }
1600
1601 static int mjpeg_decode_com(MJpegDecodeContext *s)
1602 {
1603     /* XXX: verify len field validity */
1604     int len = get_bits(&s->gb, 16);
1605     if (len >= 2 && len < 32768) {
1606         /* XXX: any better upper bound */
1607         uint8_t *cbuf = av_malloc(len - 1);
1608         if (cbuf) {
1609             int i;
1610             for (i = 0; i < len - 2; i++)
1611                 cbuf[i] = get_bits(&s->gb, 8);
1612             if (i > 0 && cbuf[i-1] == '\n')
1613                 cbuf[i-1] = 0;
1614             else
1615                 cbuf[i] = 0;
1616
1617             printf("mjpeg comment: '%s'\n", cbuf);
1618
1619             /* buggy avid, it puts EOI only at every 10th frame */
1620             if (!strcmp(cbuf, "AVID"))
1621             {
1622                 s->buggy_avid = 1;
1623                 //      if (s->first_picture)
1624                 //          printf("mjpeg: workarounding buggy AVID\n");
1625             }
1626
1627             av_free(cbuf);
1628         }
1629     }
1630
1631     return 0;
1632 }
1633
1634 #if 0
1635 static int valid_marker_list[] =
1636 {
1637         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1638 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1639 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1640 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1641 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1642 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1643 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1644 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1645 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1646 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1647 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1648 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1649 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1650 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1651 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1652 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1653 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1654 }
1655 #endif
1656
1657 /* return the 8 bit start code value and update the search
1658    state. Return -1 if no start code found */
1659 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1660 {
1661     uint8_t *buf_ptr;
1662     unsigned int v, v2;
1663     int val;
1664 #ifdef DEBUG
1665     int skipped=0;
1666 #endif
1667
1668     buf_ptr = *pbuf_ptr;
1669     while (buf_ptr < buf_end) {
1670         v = *buf_ptr++;
1671         v2 = *buf_ptr;
1672         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1673             val = *buf_ptr++;
1674             goto found;
1675         }
1676 #ifdef DEBUG
1677         skipped++;
1678 #endif
1679     }
1680     val = -1;
1681 found:
1682 #ifdef DEBUG
1683     dprintf("find_marker skipped %d bytes\n", skipped);
1684 #endif
1685     *pbuf_ptr = buf_ptr;
1686     return val;
1687 }
1688
1689 static int mjpeg_decode_frame(AVCodecContext *avctx,
1690                               void *data, int *data_size,
1691                               uint8_t *buf, int buf_size)
1692 {
1693     MJpegDecodeContext *s = avctx->priv_data;
1694     uint8_t *buf_end, *buf_ptr;
1695     int i, start_code;
1696     AVPicture *picture = data;
1697
1698     *data_size = 0;
1699
1700     /* no supplementary picture */
1701     if (buf_size == 0)
1702         return 0;
1703
1704     buf_ptr = buf;
1705     buf_end = buf + buf_size;
1706     while (buf_ptr < buf_end) {
1707         /* find start next marker */
1708         start_code = find_marker(&buf_ptr, buf_end);
1709         {
1710             /* EOF */
1711             if (start_code < 0) {
1712                 goto the_end;
1713             } else {
1714                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1715
1716                 if ((buf_end - buf_ptr) > s->buffer_size)
1717                 {
1718                     av_free(s->buffer);
1719                     s->buffer_size = buf_end-buf_ptr;
1720                     s->buffer = av_malloc(s->buffer_size);
1721                     dprintf("buffer too small, expanding to %d bytes\n",
1722                         s->buffer_size);
1723                 }
1724
1725                 /* unescape buffer of SOS */
1726                 if (start_code == SOS)
1727                 {
1728                     uint8_t *src = buf_ptr;
1729                     uint8_t *dst = s->buffer;
1730
1731                     while (src<buf_end)
1732                     {
1733                         uint8_t x = *(src++);
1734
1735                         *(dst++) = x;
1736                         if (x == 0xff)
1737                         {
1738                             while(*src == 0xff) src++;
1739
1740                             x = *(src++);
1741                             if (x >= 0xd0 && x <= 0xd7)
1742                                 *(dst++) = x;
1743                             else if (x)
1744                                 break;
1745                         }
1746                     }
1747                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1748
1749                     dprintf("escaping removed %d bytes\n",
1750                         (buf_end - buf_ptr) - (dst - s->buffer));
1751                 }
1752                 else
1753                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1754
1755                 s->start_code = start_code;
1756                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1757                     printf("startcode: %X\n", start_code);
1758                 }
1759
1760                 /* process markers */
1761                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1762                     dprintf("restart marker: %d\n", start_code&0x0f);
1763                 } else if (s->first_picture) {
1764                     /* APP fields */
1765                     if (start_code >= 0xe0 && start_code <= 0xef)
1766                         mjpeg_decode_app(s);
1767                     /* Comment */
1768                     else if (start_code == COM)
1769                         mjpeg_decode_com(s);
1770                 }
1771
1772                 switch(start_code) {
1773                 case SOI:
1774                     s->restart_interval = 0;
1775                     /* nothing to do on SOI */
1776                     break;
1777                 case DQT:
1778                     mjpeg_decode_dqt(s);
1779                     break;
1780                 case DHT:
1781                     mjpeg_decode_dht(s);
1782                     break;
1783                 case SOF0:
1784                     s->lossless=0;
1785                     if (mjpeg_decode_sof(s) < 0)
1786                         return -1;
1787                     break;
1788                 case SOF3:
1789                     s->lossless=1;
1790                     if (mjpeg_decode_sof(s) < 0)
1791                         return -1;
1792                     break;
1793                 case EOI:
1794 eoi_parser:
1795                     {
1796                         if (s->interlaced) {
1797                             s->bottom_field ^= 1;
1798                             /* if not bottom field, do not output image yet */
1799                             if (s->bottom_field)
1800                                 goto not_the_end;
1801                         }
1802                         for(i=0;i<3;i++) {
1803                             picture->data[i] = s->current_picture[i];
1804                             picture->linesize[i] = (s->interlaced) ?
1805                                 s->linesize[i] >> 1 : s->linesize[i];
1806                         }
1807                         *data_size = sizeof(AVPicture);
1808                         avctx->height = s->height;
1809                         if (s->interlaced)
1810                             avctx->height *= 2;
1811                         avctx->width = s->width;
1812                         /* XXX: not complete test ! */
1813                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1814                         case 0x11:
1815                             if(s->rgb){
1816                                 avctx->pix_fmt = PIX_FMT_RGBA32;
1817                             }else
1818                                 avctx->pix_fmt = PIX_FMT_YUV444P;
1819                             break;
1820                         case 0x21:
1821                             avctx->pix_fmt = PIX_FMT_YUV422P;
1822                             break;
1823                         default:
1824                         case 0x22:
1825                             avctx->pix_fmt = PIX_FMT_YUV420P;
1826                             break;
1827                         }
1828                         /* dummy quality */
1829                         /* XXX: infer it with matrix */
1830 //                      avctx->quality = 3;
1831                         goto the_end;
1832                     }
1833                     break;
1834                 case SOS:
1835                     mjpeg_decode_sos(s);
1836                     /* buggy avid puts EOI every 10-20th frame */
1837                     /* if restart period is over process EOI */
1838                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1839                         goto eoi_parser;
1840                     break;
1841                 case DRI:
1842                     mjpeg_decode_dri(s);
1843                     break;
1844                 case SOF1:
1845                 case SOF2:
1846                 case SOF5:
1847                 case SOF6:
1848                 case SOF7:
1849                 case SOF9:
1850                 case SOF10:
1851                 case SOF11:
1852                 case SOF13:
1853                 case SOF14:
1854                 case SOF15:
1855                 case JPG:
1856                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1857                     break;
1858 //              default:
1859 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1860 //                  break;
1861                 }
1862
1863 not_the_end:
1864                 /* eof process start code */
1865                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1866                 dprintf("marker parser used %d bytes (%d bits)\n",
1867                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1868             }
1869         }
1870     }
1871 the_end:
1872     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1873 //    return buf_end - buf_ptr;
1874     return buf_ptr - buf;
1875 }
1876
1877 static int mjpegb_decode_frame(AVCodecContext *avctx,
1878                               void *data, int *data_size,
1879                               uint8_t *buf, int buf_size)
1880 {
1881     MJpegDecodeContext *s = avctx->priv_data;
1882     uint8_t *buf_end, *buf_ptr;
1883     int i;
1884     AVPicture *picture = data;
1885     GetBitContext hgb; /* for the header */
1886     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1887     uint32_t field_size;
1888
1889     *data_size = 0;
1890
1891     /* no supplementary picture */
1892     if (buf_size == 0)
1893         return 0;
1894
1895     buf_ptr = buf;
1896     buf_end = buf + buf_size;
1897
1898 read_header:
1899     /* reset on every SOI */
1900     s->restart_interval = 0;
1901
1902     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1903
1904     skip_bits(&hgb, 32); /* reserved zeros */
1905
1906     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1907     {
1908         dprintf("not mjpeg-b (bad fourcc)\n");
1909         return 0;
1910     }
1911
1912     field_size = get_bits(&hgb, 32); /* field size */
1913     dprintf("field size: 0x%x\n", field_size);
1914     skip_bits(&hgb, 32); /* padded field size */
1915     second_field_offs = get_bits(&hgb, 32);
1916     dprintf("second field offs: 0x%x\n", second_field_offs);
1917     if (second_field_offs)
1918         s->interlaced = 1;
1919
1920     dqt_offs = get_bits(&hgb, 32);
1921     dprintf("dqt offs: 0x%x\n", dqt_offs);
1922     if (dqt_offs)
1923     {
1924         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1925         s->start_code = DQT;
1926         mjpeg_decode_dqt(s);
1927     }
1928
1929     dht_offs = get_bits(&hgb, 32);
1930     dprintf("dht offs: 0x%x\n", dht_offs);
1931     if (dht_offs)
1932     {
1933         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1934         s->start_code = DHT;
1935         mjpeg_decode_dht(s);
1936     }
1937
1938     sof_offs = get_bits(&hgb, 32);
1939     dprintf("sof offs: 0x%x\n", sof_offs);
1940     if (sof_offs)
1941     {
1942         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1943         s->start_code = SOF0;
1944         if (mjpeg_decode_sof(s) < 0)
1945             return -1;
1946     }
1947
1948     sos_offs = get_bits(&hgb, 32);
1949     dprintf("sos offs: 0x%x\n", sos_offs);
1950     if (sos_offs)
1951     {
1952 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1953         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1954         s->start_code = SOS;
1955         mjpeg_decode_sos(s);
1956     }
1957
1958     skip_bits(&hgb, 32); /* start of data offset */
1959
1960     if (s->interlaced) {
1961         s->bottom_field ^= 1;
1962         /* if not bottom field, do not output image yet */
1963         if (s->bottom_field && second_field_offs)
1964         {
1965             buf_ptr = buf + second_field_offs;
1966             second_field_offs = 0;
1967             goto read_header;
1968         }
1969     }
1970
1971     for(i=0;i<3;i++) {
1972         picture->data[i] = s->current_picture[i];
1973         picture->linesize[i] = (s->interlaced) ?
1974             s->linesize[i] >> 1 : s->linesize[i];
1975     }
1976     *data_size = sizeof(AVPicture);
1977     avctx->height = s->height;
1978     if (s->interlaced)
1979         avctx->height *= 2;
1980     avctx->width = s->width;
1981     /* XXX: not complete test ! */
1982     switch((s->h_count[0] << 4) | s->v_count[0]) {
1983         case 0x11:
1984             avctx->pix_fmt = PIX_FMT_YUV444P;
1985             break;
1986         case 0x21:
1987             avctx->pix_fmt = PIX_FMT_YUV422P;
1988             break;
1989         default:
1990         case 0x22:
1991             avctx->pix_fmt = PIX_FMT_YUV420P;
1992             break;
1993     }
1994     /* dummy quality */
1995     /* XXX: infer it with matrix */
1996 //    avctx->quality = 3;
1997
1998     return buf_ptr - buf;
1999 }
2000
2001
2002 static int mjpeg_decode_end(AVCodecContext *avctx)
2003 {
2004     MJpegDecodeContext *s = avctx->priv_data;
2005     int i, j;
2006
2007     av_free(s->buffer);
2008     for(i=0;i<MAX_COMPONENTS;i++)
2009         av_free(s->current_picture[i]);
2010     for(i=0;i<2;i++) {
2011         for(j=0;j<4;j++)
2012             free_vlc(&s->vlcs[i][j]);
2013     }
2014     return 0;
2015 }
2016
2017 AVCodec mjpeg_decoder = {
2018     "mjpeg",
2019     CODEC_TYPE_VIDEO,
2020     CODEC_ID_MJPEG,
2021     sizeof(MJpegDecodeContext),
2022     mjpeg_decode_init,
2023     NULL,
2024     mjpeg_decode_end,
2025     mjpeg_decode_frame,
2026     0,
2027     NULL
2028 };
2029
2030 AVCodec mjpegb_decoder = {
2031     "mjpegb",
2032     CODEC_TYPE_VIDEO,
2033     CODEC_ID_MJPEGB,
2034     sizeof(MJpegDecodeContext),
2035     mjpeg_decode_init,
2036     NULL,
2037     mjpeg_decode_end,
2038     mjpegb_decode_frame,
2039     0,
2040     NULL
2041 };
2042
2043 #ifdef CONFIG_ENCODERS
2044 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2045     "ljpeg",
2046     CODEC_TYPE_VIDEO,
2047     CODEC_ID_LJPEG,
2048     sizeof(MpegEncContext),
2049     MPV_encode_init,
2050     encode_picture_lossless,
2051     MPV_encode_end,
2052 };
2053 #endif