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 ? predictor : 1;
 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     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
 812
 813     int org_width, org_height;  /* size given at codec init */
 814     int first_picture;    /* true if decoding first picture */
 815     int interlaced;     /* true if interlaced */
 816     int bottom_field;   /* true if bottom field */
 817     int lossless;
 818     int rgb;
 819     int rct;            /* standard rct */
 820     int pegasus_rct;    /* pegasus reversible colorspace transform */
 821     int bits;           /* bits per component */
 822
 823     int width, height;
 824     int mb_width, mb_height;
 825     int nb_components;
 826     int component_id[MAX_COMPONENTS];
 827     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 828     int v_count[MAX_COMPONENTS];
 829     int comp_index[MAX_COMPONENTS];
 830     int dc_index[MAX_COMPONENTS];
 831     int ac_index[MAX_COMPONENTS];
 832     int nb_blocks[MAX_COMPONENTS];
 833     int h_scount[MAX_COMPONENTS];
 834     int v_scount[MAX_COMPONENTS];
 835     int h_max, v_max; /* maximum h and v counts */
 836     int quant_index[4];   /* quant table index for each component */
 837     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 838     uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
 839     int linesize[MAX_COMPONENTS];
 840     uint8_t *qscale_table;
 841     DCTELEM block[64] __align8;
 842     ScanTable scantable;
 843     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 844
 845     int restart_interval;
 846     int restart_count;
 847
 848     int buggy_avid;
 849     int interlace_polarity;
 850 } MJpegDecodeContext;
 851
 852 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 853
 854 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
 855                       int nb_codes)
 856 {
 857     uint8_t huff_size[256];
 858     uint16_t huff_code[256];
 859
 860     memset(huff_size, 0, sizeof(huff_size));
 861     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 862
 863     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 864 }
 865
 866 static int mjpeg_decode_init(AVCodecContext *avctx)
 867 {
 868     MJpegDecodeContext *s = avctx->priv_data;
 869     MpegEncContext s2;
 870
 871     s->avctx = avctx;
 872
 873     /* ugly way to get the idct & scantable FIXME */
 874     memset(&s2, 0, sizeof(MpegEncContext));
 875     s2.flags= avctx->flags;
 876     s2.avctx= avctx;
 877 //    s2->out_format = FMT_MJPEG;
 878     s2.width = 8;
 879     s2.height = 8;
 880     if (MPV_common_init(&s2) < 0)
 881        return -1;
 882     s->scantable= s2.intra_scantable;
 883     s->idct_put= s2.dsp.idct_put;
 884     MPV_common_end(&s2);
 885
 886     s->mpeg_enc_ctx_allocated = 0;
 887     s->buffer_size = 102400; /* smaller buffer should be enough,
 888                                 but photojpg files could ahive bigger sizes */
 889     s->buffer = av_malloc(s->buffer_size);
 890     if (!s->buffer)
 891         return -1;
 892     s->start_code = -1;
 893     s->first_picture = 1;
 894     s->org_width = avctx->width;
 895     s->org_height = avctx->height;
 896
 897     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 898     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 899     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 900     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 901
 902     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 903     {
 904         printf("mjpeg: using external huffman table\n");
 905         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 906         mjpeg_decode_dht(s);
 907         /* should check for error - but dunno */
 908     }
 909
 910     return 0;
 911 }
 912
 913 /* quantize tables */
 914 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 915 {
 916     int len, index, i, j;
 917
 918     len = get_bits(&s->gb, 16) - 2;
 919
 920     while (len >= 65) {
 921         /* only 8 bit precision handled */
 922         if (get_bits(&s->gb, 4) != 0)
 923         {
 924             dprintf("dqt: 16bit precision\n");
 925             return -1;
 926         }
 927         index = get_bits(&s->gb, 4);
 928         if (index >= 4)
 929             return -1;
 930         dprintf("index=%d\n", index);
 931         /* read quant table */
 932         for(i=0;i<64;i++) {
 933             j = s->scantable.permutated[i];
 934             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 935         }
 936
 937         //XXX FIXME finetune, and perhaps add dc too
 938         s->qscale[index]= FFMAX(
 939             s->quant_matrixes[index][s->scantable.permutated[1]],
 940             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
 941         len -= 65;
 942     }
 943
 944     return 0;
 945 }
 946
 947 /* decode huffman tables and build VLC decoders */
 948 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 949 {
 950     int len, index, i, class, n, v, code_max;
 951     uint8_t bits_table[17];
 952     uint8_t val_table[256];
 953
 954     len = get_bits(&s->gb, 16) - 2;
 955
 956     while (len > 0) {
 957         if (len < 17)
 958             return -1;
 959         class = get_bits(&s->gb, 4);
 960         if (class >= 2)
 961             return -1;
 962         index = get_bits(&s->gb, 4);
 963         if (index >= 4)
 964             return -1;
 965         n = 0;
 966         for(i=1;i<=16;i++) {
 967             bits_table[i] = get_bits(&s->gb, 8);
 968             n += bits_table[i];
 969         }
 970         len -= 17;
 971         if (len < n || n > 256)
 972             return -1;
 973
 974         code_max = 0;
 975         for(i=0;i<n;i++) {
 976             v = get_bits(&s->gb, 8);
 977             if (v > code_max)
 978                 code_max = v;
 979             val_table[i] = v;
 980         }
 981         len -= n;
 982
 983         /* build VLC and flush previous vlc if present */
 984         free_vlc(&s->vlcs[class][index]);
 985         dprintf("class=%d index=%d nb_codes=%d\n",
 986                class, index, code_max + 1);
 987         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
 988             return -1;
 989         }
 990     }
 991     return 0;
 992 }
 993
 994 static int mjpeg_decode_sof(MJpegDecodeContext *s)
 995 {
 996     int len, nb_components, i, width, height;
 997
 998     /* XXX: verify len field validity */
 999     len = get_bits(&s->gb, 16);
1000     s->bits= get_bits(&s->gb, 8);
1001
1002     if(s->pegasus_rct) s->bits=9;
1003     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1004
1005     if (s->bits != 8 && !s->lossless){
1006         printf("only 8 bits/component accepted\n");
1007         return -1;
1008     }
1009     height = get_bits(&s->gb, 16);
1010     width = get_bits(&s->gb, 16);
1011     dprintf("sof0: picture: %dx%d\n", width, height);
1012
1013     nb_components = get_bits(&s->gb, 8);
1014     if (nb_components <= 0 ||
1015         nb_components > MAX_COMPONENTS)
1016         return -1;
1017     s->nb_components = nb_components;
1018     s->h_max = 1;
1019     s->v_max = 1;
1020     for(i=0;i<nb_components;i++) {
1021         /* component id */
1022         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1023         s->h_count[i] = get_bits(&s->gb, 4);
1024         s->v_count[i] = get_bits(&s->gb, 4);
1025         /* compute hmax and vmax (only used in interleaved case) */
1026         if (s->h_count[i] > s->h_max)
1027             s->h_max = s->h_count[i];
1028         if (s->v_count[i] > s->v_max)
1029             s->v_max = s->v_count[i];
1030         s->quant_index[i] = get_bits(&s->gb, 8);
1031         if (s->quant_index[i] >= 4)
1032             return -1;
1033         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1034             s->v_count[i], s->component_id[i], s->quant_index[i]);
1035     }
1036
1037     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1038
1039     /* if different size, realloc/alloc picture */
1040     /* XXX: also check h_count and v_count */
1041     if (width != s->width || height != s->height) {
1042         for(i=0;i<MAX_COMPONENTS;i++)
1043             av_freep(&s->current_picture[i]);
1044
1045         av_freep(&s->qscale_table);
1046
1047         s->width = width;
1048         s->height = height;
1049         /* test interlaced mode */
1050         if (s->first_picture &&
1051             s->org_height != 0 &&
1052             s->height < ((s->org_height * 3) / 4)) {
1053             s->interlaced = 1;
1054 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1055             s->bottom_field = 0;
1056         }
1057
1058         if(s->rgb){
1059             int w, h;
1060             w = s->width;
1061             h = s->height;
1062             if (s->interlaced)
1063                 w *= 2;
1064             s->linesize[0] = 4*w;
1065             s->current_picture[0] = av_mallocz(4*w * h);
1066             s->current_picture[1] = s->current_picture[2] = NULL;
1067         }else{
1068           for(i=0;i<nb_components;i++) {
1069             int w, h;
1070             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
1071             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
1072             w = w * 8 * s->h_count[i];
1073             h = h * 8 * s->v_count[i];
1074             if (s->interlaced)
1075                 w *= 2;
1076             s->linesize[i] = w;
1077             s->current_picture[i] = av_mallocz(w * h);
1078             if (!s->current_picture[i])
1079             {
1080                 dprintf("error: no picture buffers allocated\n");
1081                 return -1;
1082             }
1083           }
1084         }
1085         s->qscale_table= av_mallocz((s->width+15)/16);
1086
1087         s->first_picture = 0;
1088     }
1089
1090     if (len != (8+(3*nb_components)))
1091     {
1092         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1093     }
1094
1095     return 0;
1096 }
1097
1098 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1099 {
1100     int code;
1101     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1102     if (code < 0)
1103     {
1104         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1105                 &s->vlcs[0][dc_index]);
1106         return 0xffff;
1107     }
1108
1109     if(code)
1110         return get_xbits(&s->gb, code);
1111     else
1112         return 0;
1113 }
1114
1115 /* decode block and dequantize */
1116 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1117                         int component, int dc_index, int ac_index, int quant_index)
1118 {
1119     int code, i, j, level, val;
1120     VLC *ac_vlc;
1121     int16_t *quant_matrix;
1122
1123     /* DC coef */
1124     val = mjpeg_decode_dc(s, dc_index);
1125     if (val == 0xffff) {
1126         dprintf("error dc\n");
1127         return -1;
1128     }
1129     quant_matrix = s->quant_matrixes[quant_index];
1130     val = val * quant_matrix[0] + s->last_dc[component];
1131     s->last_dc[component] = val;
1132     block[0] = val;
1133     /* AC coefs */
1134     ac_vlc = &s->vlcs[1][ac_index];
1135     i = 1;
1136     for(;;) {
1137         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1138
1139         if (code < 0) {
1140             dprintf("error ac\n");
1141             return -1;
1142         }
1143         /* EOB */
1144         if (code == 0)
1145             break;
1146         if (code == 0xf0) {
1147             i += 16;
1148         } else {
1149             level = get_xbits(&s->gb, code & 0xf);
1150             i += code >> 4;
1151             if (i >= 64) {
1152                 dprintf("error count: %d\n", i);
1153                 return -1;
1154             }
1155             j = s->scantable.permutated[i];
1156             block[j] = level * quant_matrix[j];
1157             i++;
1158             if (i >= 64)
1159                 break;
1160         }
1161     }
1162     return 0;
1163 }
1164
1165 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1166     int i, mb_x, mb_y;
1167     uint16_t buffer[2048][4];
1168     int left[3], top[3], topleft[3];
1169     const int linesize= s->linesize[0];
1170     const int mask= (1<<s->bits)-1;
1171
1172     for(i=0; i<3; i++){
1173         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1174     }
1175     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1176         const int modified_predictor= mb_y ? predictor : 1;
1177         uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1178
1179         if (s->interlaced && s->bottom_field)
1180             ptr += linesize >> 1;
1181
1182         for(i=0; i<3; i++){
1183             top[i]= left[i]= topleft[i]= buffer[0][i];
1184         }
1185         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1186             if (s->restart_interval && !s->restart_count)
1187                 s->restart_count = s->restart_interval;
1188
1189             for(i=0;i<3;i++) {
1190                 int pred;
1191
1192                 topleft[i]= top[i];
1193                 top[i]= buffer[mb_x][i];
1194
1195                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1196
1197                 left[i]=
1198                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1199             }
1200
1201             if (s->restart_interval && !--s->restart_count) {
1202                 align_get_bits(&s->gb);
1203                 skip_bits(&s->gb, 16); /* skip RSTn */
1204             }
1205         }
1206
1207         if(s->rct){
1208             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1209                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1210                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1211                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1212             }
1213         }else if(s->pegasus_rct){
1214             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1216                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1217                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1218             }
1219         }else{
1220             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1221                 ptr[4*mb_x+0] = buffer[mb_x][0];
1222                 ptr[4*mb_x+1] = buffer[mb_x][1];
1223                 ptr[4*mb_x+2] = buffer[mb_x][2];
1224             }
1225         }
1226     }
1227     return 0;
1228 }
1229
1230 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1231     int i, mb_x, mb_y;
1232     const int nb_components=3;
1233
1234     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1235         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1236             if (s->restart_interval && !s->restart_count)
1237                 s->restart_count = s->restart_interval;
1238
1239             if(mb_x==0 || mb_y==0 || s->interlaced){
1240                 for(i=0;i<nb_components;i++) {
1241                     uint8_t *ptr;
1242                     int n, h, v, x, y, c, j, linesize;
1243                     n = s->nb_blocks[i];
1244                     c = s->comp_index[i];
1245                     h = s->h_scount[i];
1246                     v = s->v_scount[i];
1247                     x = 0;
1248                     y = 0;
1249                     linesize= s->linesize[c];
1250
1251                     for(j=0; j<n; j++) {
1252                         int pred;
1253
1254                         ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1255                         if(y==0 && mb_y==0){
1256                             if(x==0 && mb_x==0){
1257                                 pred= 128 << point_transform;
1258                             }else{
1259                                 pred= ptr[-1];
1260                             }
1261                         }else{
1262                             if(x==0 && mb_x==0){
1263                                 pred= ptr[-linesize];
1264                             }else{
1265                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1266                             }
1267                         }
1268
1269                         if (s->interlaced && s->bottom_field)
1270                             ptr += linesize >> 1;
1271                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1272
1273                         if (++x == h) {
1274                             x = 0;
1275                             y++;
1276                         }
1277                     }
1278                 }
1279             }else{
1280                 for(i=0;i<nb_components;i++) {
1281                     uint8_t *ptr;
1282                     int n, h, v, x, y, c, j, linesize;
1283                     n = s->nb_blocks[i];
1284                     c = s->comp_index[i];
1285                     h = s->h_scount[i];
1286                     v = s->v_scount[i];
1287                     x = 0;
1288                     y = 0;
1289                     linesize= s->linesize[c];
1290
1291                     for(j=0; j<n; j++) {
1292                         int pred;
1293
1294                         ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1295                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1296                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1297                         if (++x == h) {
1298                             x = 0;
1299                             y++;
1300                         }
1301                     }
1302                 }
1303             }
1304             if (s->restart_interval && !--s->restart_count) {
1305                 align_get_bits(&s->gb);
1306                 skip_bits(&s->gb, 16); /* skip RSTn */
1307             }
1308         }
1309     }
1310     return 0;
1311 }
1312
1313 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1314     int i, mb_x, mb_y;
1315     const int nb_components=3;
1316
1317     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1318         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1319             if (s->restart_interval && !s->restart_count)
1320                 s->restart_count = s->restart_interval;
1321
1322             for(i=0;i<nb_components;i++) {
1323                 uint8_t *ptr;
1324                 int n, h, v, x, y, c, j;
1325                 n = s->nb_blocks[i];
1326                 c = s->comp_index[i];
1327                 h = s->h_scount[i];
1328                 v = s->v_scount[i];
1329                 x = 0;
1330                 y = 0;
1331                 for(j=0;j<n;j++) {
1332                     memset(s->block, 0, sizeof(s->block));
1333                     if (decode_block(s, s->block, i,
1334                                      s->dc_index[i], s->ac_index[i],
1335                                      s->quant_index[c]) < 0) {
1336                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1337                         return -1;
1338                     }
1339 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1340                     ptr = s->current_picture[c] +
1341                         (s->linesize[c] * (v * mb_y + y) * 8) +
1342                         (h * mb_x + x) * 8;
1343                     if (s->interlaced && s->bottom_field)
1344                         ptr += s->linesize[c] >> 1;
1345                     s->idct_put(ptr, s->linesize[c], s->block);
1346                     if (++x == h) {
1347                         x = 0;
1348                         y++;
1349                     }
1350                 }
1351             }
1352             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1353             if (s->restart_interval && (s->restart_interval < 1350) &&
1354                 !--s->restart_count) {
1355                 align_get_bits(&s->gb);
1356                 skip_bits(&s->gb, 16); /* skip RSTn */
1357                 for (i=0; i<nb_components; i++) /* reset dc */
1358                     s->last_dc[i] = 1024;
1359             }
1360         }
1361     }
1362     return 0;
1363 }
1364
1365 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1366 {
1367     int len, nb_components, i, h, v, predictor, point_transform, ilv;
1368     int vmax, hmax, index, id;
1369     const int block_size= s->lossless ? 1 : 8;
1370
1371     /* XXX: verify len field validity */
1372     len = get_bits(&s->gb, 16);
1373     nb_components = get_bits(&s->gb, 8);
1374     if (len != 6+2*nb_components)
1375     {
1376         dprintf("decode_sos: invalid len (%d)\n", len);
1377         return -1;
1378     }
1379     /* XXX: only interleaved scan accepted */
1380     if (nb_components != 3)
1381     {
1382         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1383         return -1;
1384     }
1385     vmax = 0;
1386     hmax = 0;
1387     for(i=0;i<nb_components;i++) {
1388         id = get_bits(&s->gb, 8) - 1;
1389         dprintf("component: %d\n", id);
1390         /* find component index */
1391         for(index=0;index<s->nb_components;index++)
1392             if (id == s->component_id[index])
1393                 break;
1394         if (index == s->nb_components)
1395         {
1396             dprintf("decode_sos: index(%d) out of components\n", index);
1397             return -1;
1398         }
1399
1400         s->comp_index[i] = index;
1401
1402         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1403         s->h_scount[i] = s->h_count[index];
1404         s->v_scount[i] = s->v_count[index];
1405
1406         s->dc_index[i] = get_bits(&s->gb, 4);
1407         s->ac_index[i] = get_bits(&s->gb, 4);
1408
1409         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1410             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1411             goto out_of_range;
1412 #if 0 //buggy
1413         switch(s->start_code)
1414         {
1415             case SOF0:
1416                 if (dc_index[i] > 1 || ac_index[i] > 1)
1417                     goto out_of_range;
1418                 break;
1419             case SOF1:
1420             case SOF2:
1421                 if (dc_index[i] > 3 || ac_index[i] > 3)
1422                     goto out_of_range;
1423                 break;
1424             case SOF3:
1425                 if (dc_index[i] > 3 || ac_index[i] != 0)
1426                     goto out_of_range;
1427                 break;
1428         }
1429 #endif
1430     }
1431
1432     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1433     skip_bits(&s->gb, 8); /* Se */
1434     skip_bits(&s->gb, 4); /* Ah */
1435     point_transform= get_bits(&s->gb, 4); /* Al */
1436
1437     for(i=0;i<nb_components;i++)
1438         s->last_dc[i] = 1024;
1439
1440     if (nb_components > 1) {
1441         /* interleaved stream */
1442         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1443         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1444     } else {
1445         h = s->h_max / s->h_scount[s->comp_index[0]];
1446         v = s->v_max / s->v_scount[s->comp_index[0]];
1447         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1448         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1449         s->nb_blocks[0] = 1;
1450         s->h_scount[0] = 1;
1451         s->v_scount[0] = 1;
1452     }
1453
1454     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1455         printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1456
1457     if(s->lossless){
1458             if(s->rgb){
1459                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1460                     return -1;
1461             }else{
1462                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1463                     return -1;
1464             }
1465     }else{
1466         if(mjpeg_decode_scan(s) < 0)
1467             return -1;
1468     }
1469     emms_c();
1470     return 0;
1471  out_of_range:
1472     dprintf("decode_sos: ac/dc index out of range\n");
1473     return -1;
1474 }
1475
1476 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1477 {
1478     if (get_bits(&s->gb, 16) != 4)
1479         return -1;
1480     s->restart_interval = get_bits(&s->gb, 16);
1481     dprintf("restart interval: %d\n", s->restart_interval);
1482
1483     return 0;
1484 }
1485
1486 static int mjpeg_decode_app(MJpegDecodeContext *s)
1487 {
1488     int len, id;
1489
1490     /* XXX: verify len field validity */
1491     len = get_bits(&s->gb, 16);
1492     if (len < 5)
1493         return -1;
1494
1495     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1496     id = be2me_32(id);
1497     len -= 6;
1498
1499     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1500         printf("APPx %8X\n", id);
1501     }
1502
1503     /* buggy AVID, it puts EOI only at every 10th frame */
1504     /* also this fourcc is used by non-avid files too, it holds some
1505        informations, but it's always present in AVID creates files */
1506     if (id == ff_get_fourcc("AVI1"))
1507     {
1508         /* structure:
1509             4bytes      AVI1
1510             1bytes      polarity
1511             1bytes      always zero
1512             4bytes      field_size
1513             4bytes      field_size_less_padding
1514         */
1515         s->buggy_avid = 1;
1516 //      if (s->first_picture)
1517 //          printf("mjpeg: workarounding buggy AVID\n");
1518         s->interlace_polarity = get_bits(&s->gb, 8);
1519 #if 0
1520         skip_bits(&s->gb, 8);
1521         skip_bits(&s->gb, 32);
1522         skip_bits(&s->gb, 32);
1523         len -= 10;
1524 #endif
1525 //      if (s->interlace_polarity)
1526 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1527         goto out;
1528     }
1529
1530 //    len -= 2;
1531
1532     if (id == ff_get_fourcc("JFIF"))
1533     {
1534         int t_w, t_h;
1535         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1536         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1537             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1538         if (get_bits(&s->gb, 8) == 0)
1539         {
1540             int x_density, y_density;
1541             x_density = get_bits(&s->gb, 16);
1542             y_density = get_bits(&s->gb, 16);
1543
1544             dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1545                 (float)x_density, y_density, (float)y_density);
1546 #if 0
1547             //MN: needs to be checked
1548             if(x_density)
1549 //                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1550                 s->avctx->aspect_ratio = (float)x_density/y_density;
1551                 /* it's better, but every JFIF I have seen stores 1:1 */
1552             else
1553                 s->avctx->aspect_ratio= 0.0;
1554 #endif
1555         }
1556         else
1557         {
1558             skip_bits(&s->gb, 16);
1559             skip_bits(&s->gb, 16);
1560         }
1561
1562         t_w = get_bits(&s->gb, 8);
1563         t_h = get_bits(&s->gb, 8);
1564         if (t_w && t_h)
1565         {
1566             /* skip thumbnail */
1567             if (len-10-(t_w*t_h*3) > 0)
1568                 len -= t_w*t_h*3;
1569         }
1570         len -= 10;
1571         goto out;
1572     }
1573
1574     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1575     {
1576         printf("mjpeg: Adobe header found\n");
1577         skip_bits(&s->gb, 16); /* version */
1578         skip_bits(&s->gb, 16); /* flags0 */
1579         skip_bits(&s->gb, 16); /* flags1 */
1580         skip_bits(&s->gb, 8); /* transform */
1581         len -= 7;
1582         goto out;
1583     }
1584
1585     if (id == ff_get_fourcc("LJIF")){
1586         printf("Pegasus lossless jpeg header found\n");
1587         skip_bits(&s->gb, 16); /* version ? */
1588         skip_bits(&s->gb, 16); /* unknwon always 0? */
1589         skip_bits(&s->gb, 16); /* unknwon always 0? */
1590         skip_bits(&s->gb, 16); /* unknwon always 0? */
1591         switch( get_bits(&s->gb, 8)){
1592         case 1:
1593             s->rgb= 1;
1594             s->pegasus_rct=0;
1595             break;
1596         case 2:
1597             s->rgb= 1;
1598             s->pegasus_rct=1;
1599             break;
1600         default:
1601             printf("unknown colorspace\n");
1602         }
1603         len -= 9;
1604         goto out;
1605     }
1606
1607     /* Apple MJPEG-A */
1608     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1609     {
1610         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1611         id = be2me_32(id);
1612         len -= 4;
1613         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1614         {
1615 #if 0
1616             skip_bits(&s->gb, 32); /* field size */
1617             skip_bits(&s->gb, 32); /* pad field size */
1618             skip_bits(&s->gb, 32); /* next off */
1619             skip_bits(&s->gb, 32); /* quant off */
1620             skip_bits(&s->gb, 32); /* huff off */
1621             skip_bits(&s->gb, 32); /* image off */
1622             skip_bits(&s->gb, 32); /* scan off */
1623             skip_bits(&s->gb, 32); /* data off */
1624 #endif
1625             if (s->first_picture)
1626                 printf("mjpeg: Apple MJPEG-A header found\n");
1627         }
1628     }
1629
1630 out:
1631     /* slow but needed for extreme adobe jpegs */
1632     if (len < 0)
1633         printf("mjpeg: error, decode_app parser read over the end\n");
1634     while(--len > 0)
1635         skip_bits(&s->gb, 8);
1636
1637     return 0;
1638 }
1639
1640 static int mjpeg_decode_com(MJpegDecodeContext *s)
1641 {
1642     /* XXX: verify len field validity */
1643     int len = get_bits(&s->gb, 16);
1644     if (len >= 2 && len < 32768) {
1645         /* XXX: any better upper bound */
1646         uint8_t *cbuf = av_malloc(len - 1);
1647         if (cbuf) {
1648             int i;
1649             for (i = 0; i < len - 2; i++)
1650                 cbuf[i] = get_bits(&s->gb, 8);
1651             if (i > 0 && cbuf[i-1] == '\n')
1652                 cbuf[i-1] = 0;
1653             else
1654                 cbuf[i] = 0;
1655
1656             printf("mjpeg comment: '%s'\n", cbuf);
1657
1658             /* buggy avid, it puts EOI only at every 10th frame */
1659             if (!strcmp(cbuf, "AVID"))
1660             {
1661                 s->buggy_avid = 1;
1662                 //      if (s->first_picture)
1663                 //          printf("mjpeg: workarounding buggy AVID\n");
1664             }
1665
1666             av_free(cbuf);
1667         }
1668     }
1669
1670     return 0;
1671 }
1672
1673 #if 0
1674 static int valid_marker_list[] =
1675 {
1676         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1677 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1678 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1682 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1683 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1684 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1685 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1686 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1690 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1691 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1692 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1693 }
1694 #endif
1695
1696 /* return the 8 bit start code value and update the search
1697    state. Return -1 if no start code found */
1698 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1699 {
1700     uint8_t *buf_ptr;
1701     unsigned int v, v2;
1702     int val;
1703 #ifdef DEBUG
1704     int skipped=0;
1705 #endif
1706
1707     buf_ptr = *pbuf_ptr;
1708     while (buf_ptr < buf_end) {
1709         v = *buf_ptr++;
1710         v2 = *buf_ptr;
1711         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1712             val = *buf_ptr++;
1713             goto found;
1714         }
1715 #ifdef DEBUG
1716         skipped++;
1717 #endif
1718     }
1719     val = -1;
1720 found:
1721 #ifdef DEBUG
1722     dprintf("find_marker skipped %d bytes\n", skipped);
1723 #endif
1724     *pbuf_ptr = buf_ptr;
1725     return val;
1726 }
1727
1728 static int mjpeg_decode_frame(AVCodecContext *avctx,
1729                               void *data, int *data_size,
1730                               uint8_t *buf, int buf_size)
1731 {
1732     MJpegDecodeContext *s = avctx->priv_data;
1733     uint8_t *buf_end, *buf_ptr;
1734     int i, start_code;
1735     AVFrame *picture = data;
1736
1737     *data_size = 0;
1738
1739     /* no supplementary picture */
1740     if (buf_size == 0)
1741         return 0;
1742
1743     buf_ptr = buf;
1744     buf_end = buf + buf_size;
1745     while (buf_ptr < buf_end) {
1746         /* find start next marker */
1747         start_code = find_marker(&buf_ptr, buf_end);
1748         {
1749             /* EOF */
1750             if (start_code < 0) {
1751                 goto the_end;
1752             } else {
1753                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1754
1755                 if ((buf_end - buf_ptr) > s->buffer_size)
1756                 {
1757                     av_free(s->buffer);
1758                     s->buffer_size = buf_end-buf_ptr;
1759                     s->buffer = av_malloc(s->buffer_size);
1760                     dprintf("buffer too small, expanding to %d bytes\n",
1761                         s->buffer_size);
1762                 }
1763
1764                 /* unescape buffer of SOS */
1765                 if (start_code == SOS)
1766                 {
1767                     uint8_t *src = buf_ptr;
1768                     uint8_t *dst = s->buffer;
1769
1770                     while (src<buf_end)
1771                     {
1772                         uint8_t x = *(src++);
1773
1774                         *(dst++) = x;
1775                         if (x == 0xff)
1776                         {
1777                             while(*src == 0xff) src++;
1778
1779                             x = *(src++);
1780                             if (x >= 0xd0 && x <= 0xd7)
1781                                 *(dst++) = x;
1782                             else if (x)
1783                                 break;
1784                         }
1785                     }
1786                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1787
1788                     dprintf("escaping removed %d bytes\n",
1789                         (buf_end - buf_ptr) - (dst - s->buffer));
1790                 }
1791                 else
1792                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1793
1794                 s->start_code = start_code;
1795                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1796                     printf("startcode: %X\n", start_code);
1797                 }
1798
1799                 /* process markers */
1800                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1801                     dprintf("restart marker: %d\n", start_code&0x0f);
1802                 } else if (s->first_picture) {
1803                     /* APP fields */
1804                     if (start_code >= 0xe0 && start_code <= 0xef)
1805                         mjpeg_decode_app(s);
1806                     /* Comment */
1807                     else if (start_code == COM)
1808                         mjpeg_decode_com(s);
1809                 }
1810
1811                 switch(start_code) {
1812                 case SOI:
1813                     s->restart_interval = 0;
1814                     /* nothing to do on SOI */
1815                     break;
1816                 case DQT:
1817                     mjpeg_decode_dqt(s);
1818                     break;
1819                 case DHT:
1820                     if(mjpeg_decode_dht(s) < 0){
1821                         fprintf(stderr, "huffman table decode error\n");
1822                         return -1;
1823                     }
1824                     break;
1825                 case SOF0:
1826                     s->lossless=0;
1827                     if (mjpeg_decode_sof(s) < 0)
1828                         return -1;
1829                     break;
1830                 case SOF3:
1831                     s->lossless=1;
1832                     if (mjpeg_decode_sof(s) < 0)
1833                         return -1;
1834                     break;
1835                 case EOI:
1836                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1837                         break;
1838 eoi_parser:
1839                     {
1840                         if (s->interlaced) {
1841                             s->bottom_field ^= 1;
1842                             /* if not bottom field, do not output image yet */
1843                             if (s->bottom_field)
1844                                 goto not_the_end;
1845                         }
1846                         for(i=0;i<3;i++) {
1847                             picture->data[i] = s->current_picture[i];
1848                             picture->linesize[i] = (s->interlaced) ?
1849                                 s->linesize[i] >> 1 : s->linesize[i];
1850                         }
1851                         *data_size = sizeof(AVFrame);
1852                         avctx->height = s->height;
1853                         if (s->interlaced)
1854                             avctx->height *= 2;
1855                         avctx->width = s->width;
1856                         /* XXX: not complete test ! */
1857                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1858                         case 0x11:
1859                             if(s->rgb){
1860                                 avctx->pix_fmt = PIX_FMT_RGBA32;
1861                             }else
1862                                 avctx->pix_fmt = PIX_FMT_YUV444P;
1863                             break;
1864                         case 0x21:
1865                             avctx->pix_fmt = PIX_FMT_YUV422P;
1866                             break;
1867                         default:
1868                         case 0x22:
1869                             avctx->pix_fmt = PIX_FMT_YUV420P;
1870                             break;
1871                         }
1872
1873                         if(!s->lossless){
1874                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1875                             picture->qstride= 0;
1876                             picture->qscale_table= s->qscale_table;
1877                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1878                             if(avctx->debug & FF_DEBUG_QP)
1879                                 printf("QP: %d\n", (int)picture->quality);
1880                         }
1881
1882                         goto the_end;
1883                     }
1884                     break;
1885                 case SOS:
1886                     mjpeg_decode_sos(s);
1887                     /* buggy avid puts EOI every 10-20th frame */
1888                     /* if restart period is over process EOI */
1889                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1890                         goto eoi_parser;
1891                     break;
1892                 case DRI:
1893                     mjpeg_decode_dri(s);
1894                     break;
1895                 case SOF1:
1896                 case SOF2:
1897                 case SOF5:
1898                 case SOF6:
1899                 case SOF7:
1900                 case SOF9:
1901                 case SOF10:
1902                 case SOF11:
1903                 case SOF13:
1904                 case SOF14:
1905                 case SOF15:
1906                 case JPG:
1907                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1908                     break;
1909 //              default:
1910 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1911 //                  break;
1912                 }
1913
1914 not_the_end:
1915                 /* eof process start code */
1916                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1917                 dprintf("marker parser used %d bytes (%d bits)\n",
1918                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1919             }
1920         }
1921     }
1922 the_end:
1923     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1924 //    return buf_end - buf_ptr;
1925     return buf_ptr - buf;
1926 }
1927
1928 static int mjpegb_decode_frame(AVCodecContext *avctx,
1929                               void *data, int *data_size,
1930                               uint8_t *buf, int buf_size)
1931 {
1932     MJpegDecodeContext *s = avctx->priv_data;
1933     uint8_t *buf_end, *buf_ptr;
1934     int i;
1935     AVFrame *picture = data;
1936     GetBitContext hgb; /* for the header */
1937     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1938     uint32_t field_size;
1939
1940     *data_size = 0;
1941
1942     /* no supplementary picture */
1943     if (buf_size == 0)
1944         return 0;
1945
1946     buf_ptr = buf;
1947     buf_end = buf + buf_size;
1948
1949 read_header:
1950     /* reset on every SOI */
1951     s->restart_interval = 0;
1952
1953     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1954
1955     skip_bits(&hgb, 32); /* reserved zeros */
1956
1957     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1958     {
1959         dprintf("not mjpeg-b (bad fourcc)\n");
1960         return 0;
1961     }
1962
1963     field_size = get_bits(&hgb, 32); /* field size */
1964     dprintf("field size: 0x%x\n", field_size);
1965     skip_bits(&hgb, 32); /* padded field size */
1966     second_field_offs = get_bits(&hgb, 32);
1967     dprintf("second field offs: 0x%x\n", second_field_offs);
1968     if (second_field_offs)
1969         s->interlaced = 1;
1970
1971     dqt_offs = get_bits(&hgb, 32);
1972     dprintf("dqt offs: 0x%x\n", dqt_offs);
1973     if (dqt_offs)
1974     {
1975         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1976         s->start_code = DQT;
1977         mjpeg_decode_dqt(s);
1978     }
1979
1980     dht_offs = get_bits(&hgb, 32);
1981     dprintf("dht offs: 0x%x\n", dht_offs);
1982     if (dht_offs)
1983     {
1984         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1985         s->start_code = DHT;
1986         mjpeg_decode_dht(s);
1987     }
1988
1989     sof_offs = get_bits(&hgb, 32);
1990     dprintf("sof offs: 0x%x\n", sof_offs);
1991     if (sof_offs)
1992     {
1993         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1994         s->start_code = SOF0;
1995         if (mjpeg_decode_sof(s) < 0)
1996             return -1;
1997     }
1998
1999     sos_offs = get_bits(&hgb, 32);
2000     dprintf("sos offs: 0x%x\n", sos_offs);
2001     if (sos_offs)
2002     {
2003 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2004         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2005         s->start_code = SOS;
2006         mjpeg_decode_sos(s);
2007     }
2008
2009     skip_bits(&hgb, 32); /* start of data offset */
2010
2011     if (s->interlaced) {
2012         s->bottom_field ^= 1;
2013         /* if not bottom field, do not output image yet */
2014         if (s->bottom_field && second_field_offs)
2015         {
2016             buf_ptr = buf + second_field_offs;
2017             second_field_offs = 0;
2018             goto read_header;
2019         }
2020     }
2021
2022     //XXX FIXME factorize, this looks very similar to the EOI code
2023
2024     for(i=0;i<3;i++) {
2025         picture->data[i] = s->current_picture[i];
2026         picture->linesize[i] = (s->interlaced) ?
2027             s->linesize[i] >> 1 : s->linesize[i];
2028     }
2029     *data_size = sizeof(AVFrame);
2030     avctx->height = s->height;
2031     if (s->interlaced)
2032         avctx->height *= 2;
2033     avctx->width = s->width;
2034     /* XXX: not complete test ! */
2035     switch((s->h_count[0] << 4) | s->v_count[0]) {
2036         case 0x11:
2037             avctx->pix_fmt = PIX_FMT_YUV444P;
2038             break;
2039         case 0x21:
2040             avctx->pix_fmt = PIX_FMT_YUV422P;
2041             break;
2042         default:
2043         case 0x22:
2044             avctx->pix_fmt = PIX_FMT_YUV420P;
2045             break;
2046     }
2047
2048     if(!s->lossless){
2049         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2050         picture->qstride= 0;
2051         picture->qscale_table= s->qscale_table;
2052         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2053         if(avctx->debug & FF_DEBUG_QP)
2054             printf("QP: %f\n", picture->quality);
2055     }
2056
2057     return buf_ptr - buf;
2058 }
2059
2060
2061 static int mjpeg_decode_end(AVCodecContext *avctx)
2062 {
2063     MJpegDecodeContext *s = avctx->priv_data;
2064     int i, j;
2065
2066     av_free(s->buffer);
2067     av_free(s->qscale_table);
2068     for(i=0;i<MAX_COMPONENTS;i++)
2069         av_free(s->current_picture[i]);
2070     for(i=0;i<2;i++) {
2071         for(j=0;j<4;j++)
2072             free_vlc(&s->vlcs[i][j]);
2073     }
2074     return 0;
2075 }
2076
2077 AVCodec mjpeg_decoder = {
2078     "mjpeg",
2079     CODEC_TYPE_VIDEO,
2080     CODEC_ID_MJPEG,
2081     sizeof(MJpegDecodeContext),
2082     mjpeg_decode_init,
2083     NULL,
2084     mjpeg_decode_end,
2085     mjpeg_decode_frame,
2086     0,
2087     NULL
2088 };
2089
2090 AVCodec mjpegb_decoder = {
2091     "mjpegb",
2092     CODEC_TYPE_VIDEO,
2093     CODEC_ID_MJPEGB,
2094     sizeof(MJpegDecodeContext),
2095     mjpeg_decode_init,
2096     NULL,
2097     mjpeg_decode_end,
2098     mjpegb_decode_frame,
2099     0,
2100     NULL
2101 };
2102
2103 #ifdef CONFIG_ENCODERS
2104 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2105     "ljpeg",
2106     CODEC_TYPE_VIDEO,
2107     CODEC_ID_LJPEG,
2108     sizeof(MpegEncContext),
2109     MPV_encode_init,
2110     encode_picture_lossless,
2111     MPV_encode_end,
2112 };
2113 #endif