git.sesse.net Git - ffmpeg/blob - libavcodec/mjpeg.c

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