synfig-core/tags/synfig_0_61_03/synfig-core/src/modules/mod_libavcodec/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         default:\
 293         case 7: ret= (left + top)>>1; break;\
 294     }
 295
 296 #ifdef CONFIG_ENCODERS
 297 static inline void put_marker(PutBitContext *p, int code)
 298 {
 299     put_bits(p, 8, 0xff);
 300     put_bits(p, 8, code);
 301 }
 302
 303 /* table_class: 0 = DC coef, 1 = AC coefs */
 304 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 305                              const uint8_t *bits_table, const uint8_t *value_table)
 306 {
 307     PutBitContext *p = &s->pb;
 308     int n, i;
 309
 310     put_bits(p, 4, table_class);
 311     put_bits(p, 4, table_id);
 312
 313     n = 0;
 314     for(i=1;i<=16;i++) {
 315         n += bits_table[i];
 316         put_bits(p, 8, bits_table[i]);
 317     }
 318
 319     for(i=0;i<n;i++)
 320         put_bits(p, 8, value_table[i]);
 321
 322     return n + 17;
 323 }
 324
 325 static void jpeg_table_header(MpegEncContext *s)
 326 {
 327     PutBitContext *p = &s->pb;
 328     int i, j, size;
 329     uint8_t *ptr;
 330
 331     /* quant matrixes */
 332     put_marker(p, DQT);
 333 #ifdef TWOMATRIXES
 334     put_bits(p, 16, 2 + 2 * (1 + 64));
 335 #else
 336     put_bits(p, 16, 2 + 1 * (1 + 64));
 337 #endif
 338     put_bits(p, 4, 0); /* 8 bit precision */
 339     put_bits(p, 4, 0); /* table 0 */
 340     for(i=0;i<64;i++) {
 341         j = s->intra_scantable.permutated[i];
 342         put_bits(p, 8, s->intra_matrix[j]);
 343     }
 344 #ifdef TWOMATRIXES
 345     put_bits(p, 4, 0); /* 8 bit precision */
 346     put_bits(p, 4, 1); /* table 1 */
 347     for(i=0;i<64;i++) {
 348         j = s->intra_scantable.permutated[i];
 349         put_bits(p, 8, s->chroma_intra_matrix[j]);
 350     }
 351 #endif
 352
 353     /* huffman table */
 354     put_marker(p, DHT);
 355     flush_put_bits(p);
 356     ptr = pbBufPtr(p);
 357     put_bits(p, 16, 0); /* patched later */
 358     size = 2;
 359     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 360     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 361
 362     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 363     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 364     ptr[0] = size >> 8;
 365     ptr[1] = size;
 366 }
 367
 368 static void jpeg_put_comments(MpegEncContext *s)
 369 {
 370     PutBitContext *p = &s->pb;
 371     int size;
 372     uint8_t *ptr;
 373
 374     if (s->aspect_ratio_info /* && !lossless */)
 375     {
 376     /* JFIF header */
 377     put_marker(p, APP0);
 378     put_bits(p, 16, 16);
 379     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
 380     put_bits(p, 16, 0x0201); /* v 1.02 */
 381     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
 382     switch(s->aspect_ratio_info)
 383     {
 384         case FF_ASPECT_4_3_625:
 385         case FF_ASPECT_4_3_525:
 386             put_bits(p, 16, 4);
 387             put_bits(p, 16, 3);
 388             break;
 389         case FF_ASPECT_16_9_625:
 390         case FF_ASPECT_16_9_525:
 391             put_bits(p, 16, 16);
 392             put_bits(p, 16, 9);
 393             break;
 394         case FF_ASPECT_EXTENDED:
 395             put_bits(p, 16, s->aspected_width);
 396             put_bits(p, 16, s->aspected_height);
 397             break;
 398         case FF_ASPECT_SQUARE:
 399         default:
 400             put_bits(p, 16, 1); /* aspect: 1:1 */
 401             put_bits(p, 16, 1);
 402             break;
 403     }
 404     put_bits(p, 8, 0); /* thumbnail width */
 405     put_bits(p, 8, 0); /* thumbnail height */
 406     }
 407
 408     /* comment */
 409     if(!(s->flags & CODEC_FLAG_BITEXACT)){
 410         put_marker(p, COM);
 411         flush_put_bits(p);
 412         ptr = pbBufPtr(p);
 413         put_bits(p, 16, 0); /* patched later */
 414         put_string(p, LIBAVCODEC_IDENT);
 415         size = strlen(LIBAVCODEC_IDENT)+3;
 416         ptr[0] = size >> 8;
 417         ptr[1] = size;
 418     }
 419 }
 420
 421 void mjpeg_picture_header(MpegEncContext *s)
 422 {
 423     const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
 424
 425     put_marker(&s->pb, SOI);
 426
 427     if (!s->mjpeg_data_only_frames)
 428     {
 429     jpeg_put_comments(s);
 430
 431     if (s->mjpeg_write_tables) jpeg_table_header(s);
 432
 433     put_marker(&s->pb, lossless ? SOF3 : SOF0);
 434
 435     put_bits(&s->pb, 16, 17);
 436     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
 437         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
 438     else
 439         put_bits(&s->pb, 8, 8); /* 8 bits/component */
 440     put_bits(&s->pb, 16, s->height);
 441     put_bits(&s->pb, 16, s->width);
 442     put_bits(&s->pb, 8, 3); /* 3 components */
 443
 444     /* Y component */
 445     put_bits(&s->pb, 8, 1); /* component number */
 446     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
 447     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
 448     put_bits(&s->pb, 8, 0); /* select matrix */
 449
 450     /* Cb component */
 451     put_bits(&s->pb, 8, 2); /* component number */
 452     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
 453     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 454 #ifdef TWOMATRIXES
 455     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 456 #else
 457     put_bits(&s->pb, 8, 0); /* select matrix */
 458 #endif
 459
 460     /* Cr component */
 461     put_bits(&s->pb, 8, 3); /* component number */
 462     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
 463     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 464 #ifdef TWOMATRIXES
 465     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 466 #else
 467     put_bits(&s->pb, 8, 0); /* select matrix */
 468 #endif
 469     }
 470
 471     /* scan header */
 472     put_marker(&s->pb, SOS);
 473     put_bits(&s->pb, 16, 12); /* length */
 474     put_bits(&s->pb, 8, 3); /* 3 components */
 475
 476     /* Y component */
 477     put_bits(&s->pb, 8, 1); /* index */
 478     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 479     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 480
 481     /* Cb component */
 482     put_bits(&s->pb, 8, 2); /* index */
 483     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 484     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 485
 486     /* Cr component */
 487     put_bits(&s->pb, 8, 3); /* index */
 488     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 489     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 490
 491     put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
 492     put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
 493     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 494 }
 495
 496 static void escape_FF(MpegEncContext *s, int start)
 497 {
 498     int size= get_bit_count(&s->pb) - start*8;
 499     int i, ff_count;
 500     uint8_t *buf= s->pb.buf + start;
 501     int align= (-(size_t)(buf))&3;
 502
 503     assert((size&7) == 0);
 504     size >>= 3;
 505
 506     ff_count=0;
 507     for(i=0; i<size && i<align; i++){
 508         if(buf[i]==0xFF) ff_count++;
 509     }
 510     for(; i<size-15; i+=16){
 511         int acc, v;
 512
 513         v= *(uint32_t*)(&buf[i]);
 514         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 515         v= *(uint32_t*)(&buf[i+4]);
 516         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 517         v= *(uint32_t*)(&buf[i+8]);
 518         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 519         v= *(uint32_t*)(&buf[i+12]);
 520         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 521
 522         acc>>=4;
 523         acc+= (acc>>16);
 524         acc+= (acc>>8);
 525         ff_count+= acc&0xFF;
 526     }
 527     for(; i<size; i++){
 528         if(buf[i]==0xFF) ff_count++;
 529     }
 530
 531     if(ff_count==0) return;
 532
 533     /* skip put bits */
 534     for(i=0; i<ff_count-3; i+=4)
 535         put_bits(&s->pb, 32, 0);
 536     put_bits(&s->pb, (ff_count-i)*8, 0);
 537     flush_put_bits(&s->pb);
 538
 539     for(i=size-1; ff_count; i--){
 540         int v= buf[i];
 541
 542         if(v==0xFF){
 543 //printf("%d %d\n", i, ff_count);
 544             buf[i+ff_count]= 0;
 545             ff_count--;
 546         }
 547
 548         buf[i+ff_count]= v;
 549     }
 550 }
 551
 552 void mjpeg_picture_trailer(MpegEncContext *s)
 553 {
 554     int pad= (-get_bit_count(&s->pb))&7;
 555
 556     put_bits(&s->pb, pad,0xFF>>(8-pad));
 557     flush_put_bits(&s->pb);
 558
 559     assert((s->header_bits&7)==0);
 560
 561     escape_FF(s, s->header_bits>>3);
 562
 563     put_marker(&s->pb, EOI);
 564 }
 565
 566 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 567                                    uint8_t *huff_size, uint16_t *huff_code)
 568 {
 569     int mant, nbits;
 570
 571     if (val == 0) {
 572         put_bits(&s->pb, huff_size[0], huff_code[0]);
 573     } else {
 574         mant = val;
 575         if (val < 0) {
 576             val = -val;
 577             mant--;
 578         }
 579
 580         nbits= av_log2_16bit(val) + 1;
 581
 582         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 583
 584         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 585     }
 586 }
 587
 588 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 589 {
 590     int mant, nbits, code, i, j;
 591     int component, dc, run, last_index, val;
 592     MJpegContext *m = s->mjpeg_ctx;
 593     uint8_t *huff_size_ac;
 594     uint16_t *huff_code_ac;
 595
 596     /* DC coef */
 597     component = (n <= 3 ? 0 : n - 4 + 1);
 598     dc = block[0]; /* overflow is impossible */
 599     val = dc - s->last_dc[component];
 600     if (n < 4) {
 601         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 602         huff_size_ac = m->huff_size_ac_luminance;
 603         huff_code_ac = m->huff_code_ac_luminance;
 604     } else {
 605         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 606         huff_size_ac = m->huff_size_ac_chrominance;
 607         huff_code_ac = m->huff_code_ac_chrominance;
 608     }
 609     s->last_dc[component] = dc;
 610
 611     /* AC coefs */
 612
 613     run = 0;
 614     last_index = s->block_last_index[n];
 615     for(i=1;i<=last_index;i++) {
 616         j = s->intra_scantable.permutated[i];
 617         val = block[j];
 618         if (val == 0) {
 619             run++;
 620         } else {
 621             while (run >= 16) {
 622                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 623                 run -= 16;
 624             }
 625             mant = val;
 626             if (val < 0) {
 627                 val = -val;
 628                 mant--;
 629             }
 630
 631             nbits= av_log2(val) + 1;
 632             code = (run << 4) | nbits;
 633
 634             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 635
 636             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 637             run = 0;
 638         }
 639     }
 640
 641     /* output EOB only if not already 64 values */
 642     if (last_index < 63 || run != 0)
 643         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 644 }
 645
 646 void mjpeg_encode_mb(MpegEncContext *s,
 647                      DCTELEM block[6][64])
 648 {
 649     int i;
 650     for(i=0;i<6;i++) {
 651         encode_block(s, block[i], i);
 652     }
 653 }
 654
 655 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 656     MpegEncContext * const s = avctx->priv_data;
 657     MJpegContext * const m = s->mjpeg_ctx;
 658     AVFrame *pict = data;
 659     const int width= s->width;
 660     const int height= s->height;
 661     AVFrame * const p= (AVFrame*)&s->current_picture;
 662     const int predictor= avctx->prediction_method+1;
 663
 664     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
 665
 666     *p = *pict;
 667     p->pict_type= FF_I_TYPE;
 668     p->key_frame= 1;
 669
 670     mjpeg_picture_header(s);
 671
 672     s->header_bits= get_bit_count(&s->pb);
 673
 674     if(avctx->pix_fmt == PIX_FMT_RGBA32){
 675         int x, y, i;
 676         const int linesize= p->linesize[0];
 677         uint16_t buffer[2048][4];
 678         int left[3], top[3], topleft[3];
 679
 680         for(i=0; i<3; i++){
 681             buffer[0][i]= 1 << (9 - 1);
 682         }
 683
 684         for(y = 0; y < height; y++) {
 685             const int modified_predictor= y ? predictor : 1;
 686             uint8_t *ptr = p->data[0] + (linesize * y);
 687
 688             for(i=0; i<3; i++){
 689                 top[i]= left[i]= topleft[i]= buffer[0][i];
 690             }
 691             for(x = 0; x < width; x++) {
 692                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
 693                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
 694                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
 695
 696                 for(i=0;i<3;i++) {
 697                     int pred, diff;
 698
 699                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
 700
 701                     topleft[i]= top[i];
 702                     top[i]= buffer[x+1][i];
 703
 704                     left[i]= buffer[x][i];
 705
 706                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
 707
 708                     if(i==0)
 709                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 710                     else
 711                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 712                 }
 713             }
 714         }
 715     }else{
 716         int mb_x, mb_y, i;
 717         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
 718         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
 719
 720         for(mb_y = 0; mb_y < mb_height; mb_y++) {
 721             for(mb_x = 0; mb_x < mb_width; mb_x++) {
 722                 if(mb_x==0 || mb_y==0){
 723                     for(i=0;i<3;i++) {
 724                         uint8_t *ptr;
 725                         int x, y, h, v, linesize;
 726                         h = s->mjpeg_hsample[i];
 727                         v = s->mjpeg_vsample[i];
 728                         linesize= p->linesize[i];
 729
 730                         for(y=0; y<v; y++){
 731                             for(x=0; x<h; x++){
 732                                 int pred;
 733
 734                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 735                                 if(y==0 && mb_y==0){
 736                                     if(x==0 && mb_x==0){
 737                                         pred= 128;
 738                                     }else{
 739                                         pred= ptr[-1];
 740                                     }
 741                                 }else{
 742                                     if(x==0 && mb_x==0){
 743                                         pred= ptr[-linesize];
 744                                     }else{
 745                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 746                                     }
 747                                 }
 748
 749                                 if(i==0)
 750                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 751                                 else
 752                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 753                             }
 754                         }
 755                     }
 756                 }else{
 757                     for(i=0;i<3;i++) {
 758                         uint8_t *ptr;
 759                         int x, y, h, v, linesize;
 760                         h = s->mjpeg_hsample[i];
 761                         v = s->mjpeg_vsample[i];
 762                         linesize= p->linesize[i];
 763
 764                         for(y=0; y<v; y++){
 765                             for(x=0; x<h; x++){
 766                                 int pred;
 767
 768                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 769 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
 770                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 771
 772                                 if(i==0)
 773                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 774                                 else
 775                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 776                             }
 777                         }
 778                     }
 779                 }
 780             }
 781         }
 782     }
 783
 784     emms_c();
 785
 786     mjpeg_picture_trailer(s);
 787     s->picture_number++;
 788
 789     flush_put_bits(&s->pb);
 790     return pbBufPtr(&s->pb) - s->pb.buf;
 791 //    return (get_bit_count(&f->pb)+7)/8;
 792 }
 793
 794 #endif //CONFIG_ENCODERS
 795
 796 /******************************************/
 797 /* decoding */
 798
 799 #define MAX_COMPONENTS 4
 800
 801 typedef struct MJpegDecodeContext {
 802     AVCodecContext *avctx;
 803     GetBitContext gb;
 804     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 805
 806     int start_code; /* current start code */
 807     int buffer_size;
 808     uint8_t *buffer;
 809
 810     int16_t quant_matrixes[4][64];
 811     VLC vlcs[2][4];
 812     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
 813
 814     int org_width, org_height;  /* size given at codec init */
 815     int first_picture;    /* true if decoding first picture */
 816     int interlaced;     /* true if interlaced */
 817     int bottom_field;   /* true if bottom field */
 818     int lossless;
 819     int rgb;
 820     int rct;            /* standard rct */
 821     int pegasus_rct;    /* pegasus reversible colorspace transform */
 822     int bits;           /* bits per component */
 823
 824     int width, height;
 825     int mb_width, mb_height;
 826     int nb_components;
 827     int component_id[MAX_COMPONENTS];
 828     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 829     int v_count[MAX_COMPONENTS];
 830     int comp_index[MAX_COMPONENTS];
 831     int dc_index[MAX_COMPONENTS];
 832     int ac_index[MAX_COMPONENTS];
 833     int nb_blocks[MAX_COMPONENTS];
 834     int h_scount[MAX_COMPONENTS];
 835     int v_scount[MAX_COMPONENTS];
 836     int h_max, v_max; /* maximum h and v counts */
 837     int quant_index[4];   /* quant table index for each component */
 838     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 839     uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
 840     int linesize[MAX_COMPONENTS];
 841     uint8_t *qscale_table;
 842     DCTELEM block[64] __align8;
 843     ScanTable scantable;
 844     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 845
 846     int restart_interval;
 847     int restart_count;
 848
 849     int buggy_avid;
 850     int interlace_polarity;
 851 } MJpegDecodeContext;
 852
 853 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 854
 855 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
 856                       int nb_codes)
 857 {
 858     uint8_t huff_size[256];
 859     uint16_t huff_code[256];
 860
 861     memset(huff_size, 0, sizeof(huff_size));
 862     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 863
 864     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 865 }
 866
 867 static int mjpeg_decode_init(AVCodecContext *avctx)
 868 {
 869     MJpegDecodeContext *s = avctx->priv_data;
 870     MpegEncContext s2;
 871
 872     s->avctx = avctx;
 873
 874     /* ugly way to get the idct & scantable FIXME */
 875     memset(&s2, 0, sizeof(MpegEncContext));
 876     s2.flags= avctx->flags;
 877     s2.avctx= avctx;
 878 //    s2->out_format = FMT_MJPEG;
 879     s2.width = 8;
 880     s2.height = 8;
 881     if (MPV_common_init(&s2) < 0)
 882        return -1;
 883     s->scantable= s2.intra_scantable;
 884     s->idct_put= s2.dsp.idct_put;
 885     MPV_common_end(&s2);
 886
 887     s->mpeg_enc_ctx_allocated = 0;
 888     s->buffer_size = 102400; /* smaller buffer should be enough,
 889                                 but photojpg files could ahive bigger sizes */
 890     s->buffer = av_malloc(s->buffer_size);
 891     if (!s->buffer)
 892         return -1;
 893     s->start_code = -1;
 894     s->first_picture = 1;
 895     s->org_width = avctx->width;
 896     s->org_height = avctx->height;
 897
 898     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 899     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 900     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 901     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 902
 903     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 904     {
 905         printf("mjpeg: using external huffman table\n");
 906         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 907         mjpeg_decode_dht(s);
 908         /* should check for error - but dunno */
 909     }
 910
 911     return 0;
 912 }
 913
 914 /* quantize tables */
 915 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 916 {
 917     int len, index, i, j;
 918
 919     len = get_bits(&s->gb, 16) - 2;
 920
 921     while (len >= 65) {
 922         /* only 8 bit precision handled */
 923         if (get_bits(&s->gb, 4) != 0)
 924         {
 925             dprintf("dqt: 16bit precision\n");
 926             return -1;
 927         }
 928         index = get_bits(&s->gb, 4);
 929         if (index >= 4)
 930             return -1;
 931         dprintf("index=%d\n", index);
 932         /* read quant table */
 933         for(i=0;i<64;i++) {
 934             j = s->scantable.permutated[i];
 935             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 936         }
 937
 938         //XXX FIXME finetune, and perhaps add dc too
 939         s->qscale[index]= FFMAX(
 940             s->quant_matrixes[index][s->scantable.permutated[1]],
 941             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
 942         len -= 65;
 943     }
 944
 945     return 0;
 946 }
 947
 948 /* decode huffman tables and build VLC decoders */
 949 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 950 {
 951     int len, index, i, class, n, v, code_max;
 952     uint8_t bits_table[17];
 953     uint8_t val_table[256];
 954
 955     len = get_bits(&s->gb, 16) - 2;
 956
 957     while (len > 0) {
 958         if (len < 17)
 959             return -1;
 960         class = get_bits(&s->gb, 4);
 961         if (class >= 2)
 962             return -1;
 963         index = get_bits(&s->gb, 4);
 964         if (index >= 4)
 965             return -1;
 966         n = 0;
 967         for(i=1;i<=16;i++) {
 968             bits_table[i] = get_bits(&s->gb, 8);
 969             n += bits_table[i];
 970         }
 971         len -= 17;
 972         if (len < n || n > 256)
 973             return -1;
 974
 975         code_max = 0;
 976         for(i=0;i<n;i++) {
 977             v = get_bits(&s->gb, 8);
 978             if (v > code_max)
 979                 code_max = v;
 980             val_table[i] = v;
 981         }
 982         len -= n;
 983
 984         /* build VLC and flush previous vlc if present */
 985         free_vlc(&s->vlcs[class][index]);
 986         dprintf("class=%d index=%d nb_codes=%d\n",
 987                class, index, code_max + 1);
 988         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
 989             return -1;
 990         }
 991     }
 992     return 0;
 993 }
 994
 995 static int mjpeg_decode_sof(MJpegDecodeContext *s)
 996 {
 997     int len, nb_components, i, width, height;
 998
 999     /* XXX: verify len field validity */
1000     len = get_bits(&s->gb, 16);
1001     s->bits= get_bits(&s->gb, 8);
1002
1003     if(s->pegasus_rct) s->bits=9;
1004     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1005
1006     if (s->bits != 8 && !s->lossless){
1007         printf("only 8 bits/component accepted\n");
1008         return -1;
1009     }
1010     height = get_bits(&s->gb, 16);
1011     width = get_bits(&s->gb, 16);
1012     dprintf("sof0: picture: %dx%d\n", width, height);
1013
1014     nb_components = get_bits(&s->gb, 8);
1015     if (nb_components <= 0 ||
1016         nb_components > MAX_COMPONENTS)
1017         return -1;
1018     s->nb_components = nb_components;
1019     s->h_max = 1;
1020     s->v_max = 1;
1021     for(i=0;i<nb_components;i++) {
1022         /* component id */
1023         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1024         s->h_count[i] = get_bits(&s->gb, 4);
1025         s->v_count[i] = get_bits(&s->gb, 4);
1026         /* compute hmax and vmax (only used in interleaved case) */
1027         if (s->h_count[i] > s->h_max)
1028             s->h_max = s->h_count[i];
1029         if (s->v_count[i] > s->v_max)
1030             s->v_max = s->v_count[i];
1031         s->quant_index[i] = get_bits(&s->gb, 8);
1032         if (s->quant_index[i] >= 4)
1033             return -1;
1034         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1035             s->v_count[i], s->component_id[i], s->quant_index[i]);
1036     }
1037
1038     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1039
1040     /* if different size, realloc/alloc picture */
1041     /* XXX: also check h_count and v_count */
1042     if (width != s->width || height != s->height) {
1043         for(i=0;i<MAX_COMPONENTS;i++)
1044             av_freep(&s->current_picture[i]);
1045
1046         av_freep(&s->qscale_table);
1047
1048         s->width = width;
1049         s->height = height;
1050         /* test interlaced mode */
1051         if (s->first_picture &&
1052             s->org_height != 0 &&
1053             s->height < ((s->org_height * 3) / 4)) {
1054             s->interlaced = 1;
1055 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1056             s->bottom_field = 0;
1057         }
1058
1059         if(s->rgb){
1060             int w, h;
1061             w = s->width;
1062             h = s->height;
1063             if (s->interlaced)
1064                 w *= 2;
1065             s->linesize[0] = 4*w;
1066             s->current_picture[0] = av_mallocz(4*w * h);
1067             s->current_picture[1] = s->current_picture[2] = NULL;
1068         }else{
1069           for(i=0;i<nb_components;i++) {
1070             int w, h;
1071             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
1072             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
1073             w = w * 8 * s->h_count[i];
1074             h = h * 8 * s->v_count[i];
1075             if (s->interlaced)
1076                 w *= 2;
1077             s->linesize[i] = w;
1078             s->current_picture[i] = av_mallocz(w * h);
1079             if (!s->current_picture[i])
1080             {
1081                 dprintf("error: no picture buffers allocated\n");
1082                 return -1;
1083             }
1084           }
1085         }
1086         s->qscale_table= av_mallocz((s->width+15)/16);
1087
1088         s->first_picture = 0;
1089     }
1090
1091     if (len != (8+(3*nb_components)))
1092     {
1093         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1094     }
1095
1096     return 0;
1097 }
1098
1099 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1100 {
1101     int code;
1102     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1103     if (code < 0)
1104     {
1105         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1106                 &s->vlcs[0][dc_index]);
1107         return 0xffff;
1108     }
1109
1110     if(code)
1111         return get_xbits(&s->gb, code);
1112     else
1113         return 0;
1114 }
1115
1116 /* decode block and dequantize */
1117 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1118                         int component, int dc_index, int ac_index, int quant_index)
1119 {
1120     int code, i, j, level, val;
1121     VLC *ac_vlc;
1122     int16_t *quant_matrix;
1123
1124     /* DC coef */
1125     val = mjpeg_decode_dc(s, dc_index);
1126     if (val == 0xffff) {
1127         dprintf("error dc\n");
1128         return -1;
1129     }
1130     quant_matrix = s->quant_matrixes[quant_index];
1131     val = val * quant_matrix[0] + s->last_dc[component];
1132     s->last_dc[component] = val;
1133     block[0] = val;
1134     /* AC coefs */
1135     ac_vlc = &s->vlcs[1][ac_index];
1136     i = 1;
1137     for(;;) {
1138         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1139
1140         if (code < 0) {
1141             dprintf("error ac\n");
1142             return -1;
1143         }
1144         /* EOB */
1145         if (code == 0)
1146             break;
1147         if (code == 0xf0) {
1148             i += 16;
1149         } else {
1150             level = get_xbits(&s->gb, code & 0xf);
1151             i += code >> 4;
1152             if (i >= 64) {
1153                 dprintf("error count: %d\n", i);
1154                 return -1;
1155             }
1156             j = s->scantable.permutated[i];
1157             block[j] = level * quant_matrix[j];
1158             i++;
1159             if (i >= 64)
1160                 break;
1161         }
1162     }
1163     return 0;
1164 }
1165
1166 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1167     int i, mb_x, mb_y;
1168     uint16_t buffer[2048][4];
1169     int left[3], top[3], topleft[3];
1170     const int linesize= s->linesize[0];
1171     const int mask= (1<<s->bits)-1;
1172
1173     for(i=0; i<3; i++){
1174         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1175     }
1176     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1177         const int modified_predictor= mb_y ? predictor : 1;
1178         uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1179
1180         if (s->interlaced && s->bottom_field)
1181             ptr += linesize >> 1;
1182
1183         for(i=0; i<3; i++){
1184             top[i]= left[i]= topleft[i]= buffer[0][i];
1185         }
1186         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1187             if (s->restart_interval && !s->restart_count)
1188                 s->restart_count = s->restart_interval;
1189
1190             for(i=0;i<3;i++) {
1191                 int pred;
1192
1193                 topleft[i]= top[i];
1194                 top[i]= buffer[mb_x][i];
1195
1196                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1197
1198                 left[i]=
1199                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1200             }
1201
1202             if (s->restart_interval && !--s->restart_count) {
1203                 align_get_bits(&s->gb);
1204                 skip_bits(&s->gb, 16); /* skip RSTn */
1205             }
1206         }
1207
1208         if(s->rct){
1209             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1210                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1211                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1212                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1213             }
1214         }else if(s->pegasus_rct){
1215             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1216                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1217                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1218                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1219             }
1220         }else{
1221             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1222                 ptr[4*mb_x+0] = buffer[mb_x][0];
1223                 ptr[4*mb_x+1] = buffer[mb_x][1];
1224                 ptr[4*mb_x+2] = buffer[mb_x][2];
1225             }
1226         }
1227     }
1228     return 0;
1229 }
1230
1231 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1232     int i, mb_x, mb_y;
1233     const int nb_components=3;
1234
1235     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1236         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1237             if (s->restart_interval && !s->restart_count)
1238                 s->restart_count = s->restart_interval;
1239
1240             if(mb_x==0 || mb_y==0 || s->interlaced){
1241                 for(i=0;i<nb_components;i++) {
1242                     uint8_t *ptr;
1243                     int n, h, v, x, y, c, j, linesize;
1244                     n = s->nb_blocks[i];
1245                     c = s->comp_index[i];
1246                     h = s->h_scount[i];
1247                     v = s->v_scount[i];
1248                     x = 0;
1249                     y = 0;
1250                     linesize= s->linesize[c];
1251
1252                     for(j=0; j<n; j++) {
1253                         int pred;
1254
1255                         ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1256                         if(y==0 && mb_y==0){
1257                             if(x==0 && mb_x==0){
1258                                 pred= 128 << point_transform;
1259                             }else{
1260                                 pred= ptr[-1];
1261                             }
1262                         }else{
1263                             if(x==0 && mb_x==0){
1264                                 pred= ptr[-linesize];
1265                             }else{
1266                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1267                             }
1268                         }
1269
1270                         if (s->interlaced && s->bottom_field)
1271                             ptr += linesize >> 1;
1272                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1273
1274                         if (++x == h) {
1275                             x = 0;
1276                             y++;
1277                         }
1278                     }
1279                 }
1280             }else{
1281                 for(i=0;i<nb_components;i++) {
1282                     uint8_t *ptr;
1283                     int n, h, v, x, y, c, j, linesize;
1284                     n = s->nb_blocks[i];
1285                     c = s->comp_index[i];
1286                     h = s->h_scount[i];
1287                     v = s->v_scount[i];
1288                     x = 0;
1289                     y = 0;
1290                     linesize= s->linesize[c];
1291
1292                     for(j=0; j<n; j++) {
1293                         int pred;
1294
1295                         ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1296                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1297                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1298                         if (++x == h) {
1299                             x = 0;
1300                             y++;
1301                         }
1302                     }
1303                 }
1304             }
1305             if (s->restart_interval && !--s->restart_count) {
1306                 align_get_bits(&s->gb);
1307                 skip_bits(&s->gb, 16); /* skip RSTn */
1308             }
1309         }
1310     }
1311     return 0;
1312 }
1313
1314 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1315     int i, mb_x, mb_y;
1316     const int nb_components=3;
1317
1318     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1319         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1320             if (s->restart_interval && !s->restart_count)
1321                 s->restart_count = s->restart_interval;
1322
1323             for(i=0;i<nb_components;i++) {
1324                 uint8_t *ptr;
1325                 int n, h, v, x, y, c, j;
1326                 n = s->nb_blocks[i];
1327                 c = s->comp_index[i];
1328                 h = s->h_scount[i];
1329                 v = s->v_scount[i];
1330                 x = 0;
1331                 y = 0;
1332                 for(j=0;j<n;j++) {
1333                     memset(s->block, 0, sizeof(s->block));
1334                     if (decode_block(s, s->block, i,
1335                                      s->dc_index[i], s->ac_index[i],
1336                                      s->quant_index[c]) < 0) {
1337                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1338                         return -1;
1339                     }
1340 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1341                     ptr = s->current_picture[c] +
1342                         (s->linesize[c] * (v * mb_y + y) * 8) +
1343                         (h * mb_x + x) * 8;
1344                     if (s->interlaced && s->bottom_field)
1345                         ptr += s->linesize[c] >> 1;
1346                     s->idct_put(ptr, s->linesize[c], s->block);
1347                     if (++x == h) {
1348                         x = 0;
1349                         y++;
1350                     }
1351                 }
1352             }
1353             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1354             if (s->restart_interval && (s->restart_interval < 1350) &&
1355                 !--s->restart_count) {
1356                 align_get_bits(&s->gb);
1357                 skip_bits(&s->gb, 16); /* skip RSTn */
1358                 for (i=0; i<nb_components; i++) /* reset dc */
1359                     s->last_dc[i] = 1024;
1360             }
1361         }
1362     }
1363     return 0;
1364 }
1365
1366 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1367 {
1368     int len, nb_components, i, h, v, predictor, point_transform;
1369     int vmax, hmax, index, id;
1370     const int block_size= s->lossless ? 1 : 8;
1371
1372     /* XXX: verify len field validity */
1373     len = get_bits(&s->gb, 16);
1374     nb_components = get_bits(&s->gb, 8);
1375     if (len != 6+2*nb_components)
1376     {
1377         dprintf("decode_sos: invalid len (%d)\n", len);
1378         return -1;
1379     }
1380     /* XXX: only interleaved scan accepted */
1381     if (nb_components != 3)
1382     {
1383         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1384         return -1;
1385     }
1386     vmax = 0;
1387     hmax = 0;
1388     for(i=0;i<nb_components;i++) {
1389         id = get_bits(&s->gb, 8) - 1;
1390         dprintf("component: %d\n", id);
1391         /* find component index */
1392         for(index=0;index<s->nb_components;index++)
1393             if (id == s->component_id[index])
1394                 break;
1395         if (index == s->nb_components)
1396         {
1397             dprintf("decode_sos: index(%d) out of components\n", index);
1398             return -1;
1399         }
1400
1401         s->comp_index[i] = index;
1402
1403         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1404         s->h_scount[i] = s->h_count[index];
1405         s->v_scount[i] = s->v_count[index];
1406
1407         s->dc_index[i] = get_bits(&s->gb, 4);
1408         s->ac_index[i] = get_bits(&s->gb, 4);
1409
1410         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1411             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1412             goto out_of_range;
1413 #if 0 //buggy
1414         switch(s->start_code)
1415         {
1416             case SOF0:
1417                 if (dc_index[i] > 1 || ac_index[i] > 1)
1418                     goto out_of_range;
1419                 break;
1420             case SOF1:
1421             case SOF2:
1422                 if (dc_index[i] > 3 || ac_index[i] > 3)
1423                     goto out_of_range;
1424                 break;
1425             case SOF3:
1426                 if (dc_index[i] > 3 || ac_index[i] != 0)
1427                     goto out_of_range;
1428                 break;
1429         }
1430 #endif
1431     }
1432
1433     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1434     skip_bits(&s->gb, 8); /* Se */
1435     skip_bits(&s->gb, 4); /* Ah */
1436     point_transform= get_bits(&s->gb, 4); /* Al */
1437
1438     for(i=0;i<nb_components;i++)
1439         s->last_dc[i] = 1024;
1440
1441     if (nb_components > 1) {
1442         /* interleaved stream */
1443         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1444         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1445     } else {
1446         h = s->h_max / s->h_scount[s->comp_index[0]];
1447         v = s->v_max / s->v_scount[s->comp_index[0]];
1448         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1449         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1450         s->nb_blocks[0] = 1;
1451         s->h_scount[0] = 1;
1452         s->v_scount[0] = 1;
1453     }
1454
1455     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1456         printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1457
1458     if(s->lossless){
1459             if(s->rgb){
1460                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1461                     return -1;
1462             }else{
1463                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1464                     return -1;
1465             }
1466     }else{
1467         if(mjpeg_decode_scan(s) < 0)
1468             return -1;
1469     }
1470     emms_c();
1471     return 0;
1472  out_of_range:
1473     dprintf("decode_sos: ac/dc index out of range\n");
1474     return -1;
1475 }
1476
1477 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1478 {
1479     if (get_bits(&s->gb, 16) != 4)
1480         return -1;
1481     s->restart_interval = get_bits(&s->gb, 16);
1482     dprintf("restart interval: %d\n", s->restart_interval);
1483
1484     return 0;
1485 }
1486
1487 static int mjpeg_decode_app(MJpegDecodeContext *s)
1488 {
1489     int len, id;
1490
1491     /* XXX: verify len field validity */
1492     len = get_bits(&s->gb, 16);
1493     if (len < 5)
1494         return -1;
1495
1496     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1497     id = be2me_32(id);
1498     len -= 6;
1499
1500     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1501         printf("APPx %8X\n", id);
1502     }
1503
1504     /* buggy AVID, it puts EOI only at every 10th frame */
1505     /* also this fourcc is used by non-avid files too, it holds some
1506        informations, but it's always present in AVID creates files */
1507     if (id == ff_get_fourcc("AVI1"))
1508     {
1509         /* structure:
1510             4bytes      AVI1
1511             1bytes      polarity
1512             1bytes      always zero
1513             4bytes      field_size
1514             4bytes      field_size_less_padding
1515         */
1516         s->buggy_avid = 1;
1517 //      if (s->first_picture)
1518 //          printf("mjpeg: workarounding buggy AVID\n");
1519         s->interlace_polarity = get_bits(&s->gb, 8);
1520 #if 0
1521         skip_bits(&s->gb, 8);
1522         skip_bits(&s->gb, 32);
1523         skip_bits(&s->gb, 32);
1524         len -= 10;
1525 #endif
1526 //      if (s->interlace_polarity)
1527 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1528         goto out;
1529     }
1530
1531 //    len -= 2;
1532
1533     if (id == ff_get_fourcc("JFIF"))
1534     {
1535         int t_w, t_h;
1536         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1537         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1538             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1539         if (get_bits(&s->gb, 8) == 0)
1540         {
1541             int x_density, y_density;
1542             x_density = get_bits(&s->gb, 16);
1543             y_density = get_bits(&s->gb, 16);
1544
1545             dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1546                 (float)x_density, y_density, (float)y_density);
1547 #if 0
1548             //MN: needs to be checked
1549             if(x_density)
1550 //                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1551                 s->avctx->aspect_ratio = (float)x_density/y_density;
1552                 /* it's better, but every JFIF I have seen stores 1:1 */
1553             else
1554                 s->avctx->aspect_ratio= 0.0;
1555 #endif
1556         }
1557         else
1558         {
1559             skip_bits(&s->gb, 16);
1560             skip_bits(&s->gb, 16);
1561         }
1562
1563         t_w = get_bits(&s->gb, 8);
1564         t_h = get_bits(&s->gb, 8);
1565         if (t_w && t_h)
1566         {
1567             /* skip thumbnail */
1568             if (len-10-(t_w*t_h*3) > 0)
1569                 len -= t_w*t_h*3;
1570         }
1571         len -= 10;
1572         goto out;
1573     }
1574
1575     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1576     {
1577         printf("mjpeg: Adobe header found\n");
1578         skip_bits(&s->gb, 16); /* version */
1579         skip_bits(&s->gb, 16); /* flags0 */
1580         skip_bits(&s->gb, 16); /* flags1 */
1581         skip_bits(&s->gb, 8); /* transform */
1582         len -= 7;
1583         goto out;
1584     }
1585
1586     if (id == ff_get_fourcc("LJIF")){
1587         printf("Pegasus lossless jpeg header found\n");
1588         skip_bits(&s->gb, 16); /* version ? */
1589         skip_bits(&s->gb, 16); /* unknwon always 0? */
1590         skip_bits(&s->gb, 16); /* unknwon always 0? */
1591         skip_bits(&s->gb, 16); /* unknwon always 0? */
1592         switch( get_bits(&s->gb, 8)){
1593         case 1:
1594             s->rgb= 1;
1595             s->pegasus_rct=0;
1596             break;
1597         case 2:
1598             s->rgb= 1;
1599             s->pegasus_rct=1;
1600             break;
1601         default:
1602             printf("unknown colorspace\n");
1603         }
1604         len -= 9;
1605         goto out;
1606     }
1607
1608     /* Apple MJPEG-A */
1609     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1610     {
1611         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1612         id = be2me_32(id);
1613         len -= 4;
1614         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1615         {
1616 #if 0
1617             skip_bits(&s->gb, 32); /* field size */
1618             skip_bits(&s->gb, 32); /* pad field size */
1619             skip_bits(&s->gb, 32); /* next off */
1620             skip_bits(&s->gb, 32); /* quant off */
1621             skip_bits(&s->gb, 32); /* huff off */
1622             skip_bits(&s->gb, 32); /* image off */
1623             skip_bits(&s->gb, 32); /* scan off */
1624             skip_bits(&s->gb, 32); /* data off */
1625 #endif
1626             if (s->first_picture)
1627                 printf("mjpeg: Apple MJPEG-A header found\n");
1628         }
1629     }
1630
1631 out:
1632     /* slow but needed for extreme adobe jpegs */
1633     if (len < 0)
1634         printf("mjpeg: error, decode_app parser read over the end\n");
1635     while(--len > 0)
1636         skip_bits(&s->gb, 8);
1637
1638     return 0;
1639 }
1640
1641 static int mjpeg_decode_com(MJpegDecodeContext *s)
1642 {
1643     /* XXX: verify len field validity */
1644     int len = get_bits(&s->gb, 16);
1645     if (len >= 2 && len < 32768) {
1646         /* XXX: any better upper bound */
1647         uint8_t *cbuf = av_malloc(len - 1);
1648         if (cbuf) {
1649             int i;
1650             for (i = 0; i < len - 2; i++)
1651                 cbuf[i] = get_bits(&s->gb, 8);
1652             if (i > 0 && cbuf[i-1] == '\n')
1653                 cbuf[i-1] = 0;
1654             else
1655                 cbuf[i] = 0;
1656
1657             printf("mjpeg comment: '%s'\n", cbuf);
1658
1659             /* buggy avid, it puts EOI only at every 10th frame */
1660             if (!strcmp(cbuf, "AVID"))
1661             {
1662                 s->buggy_avid = 1;
1663                 //      if (s->first_picture)
1664                 //          printf("mjpeg: workarounding buggy AVID\n");
1665             }
1666
1667             av_free(cbuf);
1668         }
1669     }
1670
1671     return 0;
1672 }
1673
1674 #if 0
1675 static int valid_marker_list[] =
1676 {
1677         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1678 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1682 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1683 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1684 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1685 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1686 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1691 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1692 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1693 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1694 }
1695 #endif
1696
1697 /* return the 8 bit start code value and update the search
1698    state. Return -1 if no start code found */
1699 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1700 {
1701     uint8_t *buf_ptr;
1702     unsigned int v, v2;
1703     int val;
1704 #ifdef DEBUG
1705     int skipped=0;
1706 #endif
1707
1708     buf_ptr = *pbuf_ptr;
1709     while (buf_ptr < buf_end) {
1710         v = *buf_ptr++;
1711         v2 = *buf_ptr;
1712         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1713             val = *buf_ptr++;
1714             goto found;
1715         }
1716 #ifdef DEBUG
1717         skipped++;
1718 #endif
1719     }
1720     val = -1;
1721 found:
1722 #ifdef DEBUG
1723     dprintf("find_marker skipped %d bytes\n", skipped);
1724 #endif
1725     *pbuf_ptr = buf_ptr;
1726     return val;
1727 }
1728
1729 static int mjpeg_decode_frame(AVCodecContext *avctx,
1730                               void *data, int *data_size,
1731                               uint8_t *buf, int buf_size)
1732 {
1733     MJpegDecodeContext *s = avctx->priv_data;
1734     uint8_t *buf_end, *buf_ptr;
1735     int i, start_code;
1736     AVFrame *picture = data;
1737
1738     *data_size = 0;
1739
1740     /* no supplementary picture */
1741     if (buf_size == 0)
1742         return 0;
1743
1744     buf_ptr = buf;
1745     buf_end = buf + buf_size;
1746     while (buf_ptr < buf_end) {
1747         /* find start next marker */
1748         start_code = find_marker(&buf_ptr, buf_end);
1749         {
1750             /* EOF */
1751             if (start_code < 0) {
1752                 goto the_end;
1753             } else {
1754                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1755
1756                 if ((buf_end - buf_ptr) > s->buffer_size)
1757                 {
1758                     av_free(s->buffer);
1759                     s->buffer_size = buf_end-buf_ptr;
1760                     s->buffer = av_malloc(s->buffer_size);
1761                     dprintf("buffer too small, expanding to %d bytes\n",
1762                         s->buffer_size);
1763                 }
1764
1765                 /* unescape buffer of SOS */
1766                 if (start_code == SOS)
1767                 {
1768                     uint8_t *src = buf_ptr;
1769                     uint8_t *dst = s->buffer;
1770
1771                     while (src<buf_end)
1772                     {
1773                         uint8_t x = *(src++);
1774
1775                         *(dst++) = x;
1776                         if (x == 0xff)
1777                         {
1778                             while(*src == 0xff) src++;
1779
1780                             x = *(src++);
1781                             if (x >= 0xd0 && x <= 0xd7)
1782                                 *(dst++) = x;
1783                             else if (x)
1784                                 break;
1785                         }
1786                     }
1787                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1788
1789                     dprintf("escaping removed %d bytes\n",
1790                         (buf_end - buf_ptr) - (dst - s->buffer));
1791                 }
1792                 else
1793                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1794
1795                 s->start_code = start_code;
1796                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1797                     printf("startcode: %X\n", start_code);
1798                 }
1799
1800                 /* process markers */
1801                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1802                     dprintf("restart marker: %d\n", start_code&0x0f);
1803                 } else if (s->first_picture) {
1804                     /* APP fields */
1805                     if (start_code >= 0xe0 && start_code <= 0xef)
1806                         mjpeg_decode_app(s);
1807                     /* Comment */
1808                     else if (start_code == COM)
1809                         mjpeg_decode_com(s);
1810                 }
1811
1812                 switch(start_code) {
1813                 case SOI:
1814                     s->restart_interval = 0;
1815                     /* nothing to do on SOI */
1816                     break;
1817                 case DQT:
1818                     mjpeg_decode_dqt(s);
1819                     break;
1820                 case DHT:
1821                     if(mjpeg_decode_dht(s) < 0){
1822                         fprintf(stderr, "huffman table decode error\n");
1823                         return -1;
1824                     }
1825                     break;
1826                 case SOF0:
1827                     s->lossless=0;
1828                     if (mjpeg_decode_sof(s) < 0)
1829                         return -1;
1830                     break;
1831                 case SOF3:
1832                     s->lossless=1;
1833                     if (mjpeg_decode_sof(s) < 0)
1834                         return -1;
1835                     break;
1836                 case EOI:
1837                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1838                         break;
1839 eoi_parser:
1840                     {
1841                         if (s->interlaced) {
1842                             s->bottom_field ^= 1;
1843                             /* if not bottom field, do not output image yet */
1844                             if (s->bottom_field)
1845                                 goto not_the_end;
1846                         }
1847                         for(i=0;i<3;i++) {
1848                             picture->data[i] = s->current_picture[i];
1849                             picture->linesize[i] = (s->interlaced) ?
1850                                 s->linesize[i] >> 1 : s->linesize[i];
1851                         }
1852                         *data_size = sizeof(AVFrame);
1853                         avctx->height = s->height;
1854                         if (s->interlaced)
1855                             avctx->height *= 2;
1856                         avctx->width = s->width;
1857                         /* XXX: not complete test ! */
1858                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1859                         case 0x11:
1860                             if(s->rgb){
1861                                 avctx->pix_fmt = PIX_FMT_RGBA32;
1862                             }else
1863                                 avctx->pix_fmt = PIX_FMT_YUV444P;
1864                             break;
1865                         case 0x21:
1866                             avctx->pix_fmt = PIX_FMT_YUV422P;
1867                             break;
1868                         default:
1869                         case 0x22:
1870                             avctx->pix_fmt = PIX_FMT_YUV420P;
1871                             break;
1872                         }
1873
1874                         if(!s->lossless){
1875                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1876                             picture->qstride= 0;
1877                             picture->qscale_table= s->qscale_table;
1878                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1879                             if(avctx->debug & FF_DEBUG_QP)
1880                                 printf("QP: %d\n", (int)picture->quality);
1881                         }
1882
1883                         goto the_end;
1884                     }
1885                     break;
1886                 case SOS:
1887                     mjpeg_decode_sos(s);
1888                     /* buggy avid puts EOI every 10-20th frame */
1889                     /* if restart period is over process EOI */
1890                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1891                         goto eoi_parser;
1892                     break;
1893                 case DRI:
1894                     mjpeg_decode_dri(s);
1895                     break;
1896                 case SOF1:
1897                 case SOF2:
1898                 case SOF5:
1899                 case SOF6:
1900                 case SOF7:
1901                 case SOF9:
1902                 case SOF10:
1903                 case SOF11:
1904                 case SOF13:
1905                 case SOF14:
1906                 case SOF15:
1907                 case JPG:
1908                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1909                     break;
1910 //              default:
1911 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1912 //                  break;
1913                 }
1914
1915 not_the_end:
1916                 /* eof process start code */
1917                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1918                 dprintf("marker parser used %d bytes (%d bits)\n",
1919                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1920             }
1921         }
1922     }
1923 the_end:
1924     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1925 //    return buf_end - buf_ptr;
1926     return buf_ptr - buf;
1927 }
1928
1929 static int mjpegb_decode_frame(AVCodecContext *avctx,
1930                               void *data, int *data_size,
1931                               uint8_t *buf, int buf_size)
1932 {
1933     MJpegDecodeContext *s = avctx->priv_data;
1934     uint8_t *buf_end, *buf_ptr;
1935     int i;
1936     AVFrame *picture = data;
1937     GetBitContext hgb; /* for the header */
1938     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1939     uint32_t field_size;
1940
1941     *data_size = 0;
1942
1943     /* no supplementary picture */
1944     if (buf_size == 0)
1945         return 0;
1946
1947     buf_ptr = buf;
1948     buf_end = buf + buf_size;
1949
1950 read_header:
1951     /* reset on every SOI */
1952     s->restart_interval = 0;
1953
1954     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1955
1956     skip_bits(&hgb, 32); /* reserved zeros */
1957
1958     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1959     {
1960         dprintf("not mjpeg-b (bad fourcc)\n");
1961         return 0;
1962     }
1963
1964     field_size = get_bits(&hgb, 32); /* field size */
1965     dprintf("field size: 0x%x\n", field_size);
1966     skip_bits(&hgb, 32); /* padded field size */
1967     second_field_offs = get_bits(&hgb, 32);
1968     dprintf("second field offs: 0x%x\n", second_field_offs);
1969     if (second_field_offs)
1970         s->interlaced = 1;
1971
1972     dqt_offs = get_bits(&hgb, 32);
1973     dprintf("dqt offs: 0x%x\n", dqt_offs);
1974     if (dqt_offs)
1975     {
1976         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1977         s->start_code = DQT;
1978         mjpeg_decode_dqt(s);
1979     }
1980
1981     dht_offs = get_bits(&hgb, 32);
1982     dprintf("dht offs: 0x%x\n", dht_offs);
1983     if (dht_offs)
1984     {
1985         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1986         s->start_code = DHT;
1987         mjpeg_decode_dht(s);
1988     }
1989
1990     sof_offs = get_bits(&hgb, 32);
1991     dprintf("sof offs: 0x%x\n", sof_offs);
1992     if (sof_offs)
1993     {
1994         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1995         s->start_code = SOF0;
1996         if (mjpeg_decode_sof(s) < 0)
1997             return -1;
1998     }
1999
2000     sos_offs = get_bits(&hgb, 32);
2001     dprintf("sos offs: 0x%x\n", sos_offs);
2002     if (sos_offs)
2003     {
2004 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2005         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2006         s->start_code = SOS;
2007         mjpeg_decode_sos(s);
2008     }
2009
2010     skip_bits(&hgb, 32); /* start of data offset */
2011
2012     if (s->interlaced) {
2013         s->bottom_field ^= 1;
2014         /* if not bottom field, do not output image yet */
2015         if (s->bottom_field && second_field_offs)
2016         {
2017             buf_ptr = buf + second_field_offs;
2018             second_field_offs = 0;
2019             goto read_header;
2020         }
2021     }
2022
2023     //XXX FIXME factorize, this looks very similar to the EOI code
2024
2025     for(i=0;i<3;i++) {
2026         picture->data[i] = s->current_picture[i];
2027         picture->linesize[i] = (s->interlaced) ?
2028             s->linesize[i] >> 1 : s->linesize[i];
2029     }
2030     *data_size = sizeof(AVFrame);
2031     avctx->height = s->height;
2032     if (s->interlaced)
2033         avctx->height *= 2;
2034     avctx->width = s->width;
2035     /* XXX: not complete test ! */
2036     switch((s->h_count[0] << 4) | s->v_count[0]) {
2037         case 0x11:
2038             avctx->pix_fmt = PIX_FMT_YUV444P;
2039             break;
2040         case 0x21:
2041             avctx->pix_fmt = PIX_FMT_YUV422P;
2042             break;
2043         default:
2044         case 0x22:
2045             avctx->pix_fmt = PIX_FMT_YUV420P;
2046             break;
2047     }
2048
2049     if(!s->lossless){
2050         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2051         picture->qstride= 0;
2052         picture->qscale_table= s->qscale_table;
2053         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2054         if(avctx->debug & FF_DEBUG_QP)
2055             printf("QP: %f\n", picture->quality);
2056     }
2057
2058     return buf_ptr - buf;
2059 }
2060
2061
2062 static int mjpeg_decode_end(AVCodecContext *avctx)
2063 {
2064     MJpegDecodeContext *s = avctx->priv_data;
2065     int i, j;
2066
2067     av_free(s->buffer);
2068     av_free(s->qscale_table);
2069     for(i=0;i<MAX_COMPONENTS;i++)
2070         av_free(s->current_picture[i]);
2071     for(i=0;i<2;i++) {
2072         for(j=0;j<4;j++)
2073             free_vlc(&s->vlcs[i][j]);
2074     }
2075     return 0;
2076 }
2077
2078 AVCodec mjpeg_decoder = {
2079     "mjpeg",
2080     CODEC_TYPE_VIDEO,
2081     CODEC_ID_MJPEG,
2082     sizeof(MJpegDecodeContext),
2083     mjpeg_decode_init,
2084     NULL,
2085     mjpeg_decode_end,
2086     mjpeg_decode_frame,
2087     0,
2088     NULL
2089 };
2090
2091 AVCodec mjpegb_decoder = {
2092     "mjpegb",
2093     CODEC_TYPE_VIDEO,
2094     CODEC_ID_MJPEGB,
2095     sizeof(MJpegDecodeContext),
2096     mjpeg_decode_init,
2097     NULL,
2098     mjpeg_decode_end,
2099     mjpegb_decode_frame,
2100     0,
2101     NULL
2102 };
2103
2104 #ifdef CONFIG_ENCODERS
2105 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2106     "ljpeg",
2107     CODEC_TYPE_VIDEO,
2108     CODEC_ID_LJPEG,
2109     sizeof(MpegEncContext),
2110     MPV_encode_init,
2111     encode_picture_lossless,
2112     MPV_encode_end,
2113 };
2114 #endif