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)
 898 {
 899     uint8_t huff_size[256];
 900     uint16_t huff_code[256];
 901
 902     memset(huff_size, 0, sizeof(huff_size));
 903     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 904
 905     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
 906 }
 907
 908 static int mjpeg_decode_init(AVCodecContext *avctx)
 909 {
 910     MJpegDecodeContext *s = avctx->priv_data;
 911     MpegEncContext s2;
 912     memset(s, 0, sizeof(MJpegDecodeContext));
 913
 914     s->avctx = avctx;
 915
 916     /* ugly way to get the idct & scantable FIXME */
 917     memset(&s2, 0, sizeof(MpegEncContext));
 918     s2.avctx= avctx;
 919 //    s2->out_format = FMT_MJPEG;
 920     dsputil_init(&s2.dsp, avctx);
 921     DCT_common_init(&s2);
 922
 923     s->scantable= s2.intra_scantable;
 924     s->idct_put= s2.dsp.idct_put;
 925
 926     s->mpeg_enc_ctx_allocated = 0;
 927     s->buffer_size = 0;
 928     s->buffer = NULL;
 929     s->start_code = -1;
 930     s->first_picture = 1;
 931     s->org_height = avctx->coded_height;
 932
 933     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0);
 934     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0);
 935     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0);
 936     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0);
 937
 938     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 939     {
 940         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
 941         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 942         mjpeg_decode_dht(s);
 943         /* should check for error - but dunno */
 944     }
 945
 946     return 0;
 947 }
 948
 949
 950 /**
 951  * finds the end of the current frame in the bitstream.
 952  * @return the position of the first byte of the next frame, or -1
 953  */
 954 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
 955     int vop_found, i;
 956     uint16_t state;
 957
 958     vop_found= pc->frame_start_found;
 959     state= pc->state;
 960
 961     i=0;
 962     if(!vop_found){
 963         for(i=0; i<buf_size; i++){
 964             state= (state<<8) | buf[i];
 965             if(state == 0xFFD8){
 966                 i++;
 967                 vop_found=1;
 968                 break;
 969             }
 970         }
 971     }
 972
 973     if(vop_found){
 974         /* EOF considered as end of frame */
 975         if (buf_size == 0)
 976             return 0;
 977         for(; i<buf_size; i++){
 978             state= (state<<8) | buf[i];
 979             if(state == 0xFFD8){
 980                 pc->frame_start_found=0;
 981                 pc->state=0;
 982                 return i-1;
 983             }
 984         }
 985     }
 986     pc->frame_start_found= vop_found;
 987     pc->state= state;
 988     return END_NOT_FOUND;
 989 }
 990
 991 static int jpeg_parse(AVCodecParserContext *s,
 992                            AVCodecContext *avctx,
 993                            uint8_t **poutbuf, int *poutbuf_size,
 994                            const uint8_t *buf, int buf_size)
 995 {
 996     ParseContext *pc = s->priv_data;
 997     int next;
 998
 999     next= find_frame_end(pc, buf, buf_size);
1000
1001     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1002         *poutbuf = NULL;
1003         *poutbuf_size = 0;
1004         return buf_size;
1005     }
1006
1007     *poutbuf = (uint8_t *)buf;
1008     *poutbuf_size = buf_size;
1009     return next;
1010 }
1011
1012 /* quantize tables */
1013 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1014 {
1015     int len, index, i, j;
1016
1017     len = get_bits(&s->gb, 16) - 2;
1018
1019     while (len >= 65) {
1020         /* only 8 bit precision handled */
1021         if (get_bits(&s->gb, 4) != 0)
1022         {
1023             dprintf("dqt: 16bit precision\n");
1024             return -1;
1025         }
1026         index = get_bits(&s->gb, 4);
1027         if (index >= 4)
1028             return -1;
1029         dprintf("index=%d\n", index);
1030         /* read quant table */
1031         for(i=0;i<64;i++) {
1032             j = s->scantable.permutated[i];
1033             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1034         }
1035
1036         //XXX FIXME finetune, and perhaps add dc too
1037         s->qscale[index]= FFMAX(
1038             s->quant_matrixes[index][s->scantable.permutated[1]],
1039             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1040         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1041         len -= 65;
1042     }
1043
1044     return 0;
1045 }
1046
1047 /* decode huffman tables and build VLC decoders */
1048 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1049 {
1050     int len, index, i, class, n, v, code_max;
1051     uint8_t bits_table[17];
1052     uint8_t val_table[256];
1053
1054     len = get_bits(&s->gb, 16) - 2;
1055
1056     while (len > 0) {
1057         if (len < 17)
1058             return -1;
1059         class = get_bits(&s->gb, 4);
1060         if (class >= 2)
1061             return -1;
1062         index = get_bits(&s->gb, 4);
1063         if (index >= 4)
1064             return -1;
1065         n = 0;
1066         for(i=1;i<=16;i++) {
1067             bits_table[i] = get_bits(&s->gb, 8);
1068             n += bits_table[i];
1069         }
1070         len -= 17;
1071         if (len < n || n > 256)
1072             return -1;
1073
1074         code_max = 0;
1075         for(i=0;i<n;i++) {
1076             v = get_bits(&s->gb, 8);
1077             if (v > code_max)
1078                 code_max = v;
1079             val_table[i] = v;
1080         }
1081         len -= n;
1082
1083         /* build VLC and flush previous vlc if present */
1084         free_vlc(&s->vlcs[class][index]);
1085         dprintf("class=%d index=%d nb_codes=%d\n",
1086                class, index, code_max + 1);
1087         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){
1088             return -1;
1089         }
1090     }
1091     return 0;
1092 }
1093
1094 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1095 {
1096     int len, nb_components, i, width, height;
1097
1098     /* XXX: verify len field validity */
1099     len = get_bits(&s->gb, 16);
1100     s->bits= get_bits(&s->gb, 8);
1101
1102     if(s->pegasus_rct) s->bits=9;
1103     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1104
1105     if (s->bits != 8 && !s->lossless){
1106         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1107         return -1;
1108     }
1109     if (s->bits > 8 && s->ls){
1110         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1111         return -1;
1112     }
1113
1114     height = get_bits(&s->gb, 16);
1115     width = get_bits(&s->gb, 16);
1116
1117     dprintf("sof0: picture: %dx%d\n", width, height);
1118     if(avcodec_check_dimensions(s->avctx, width, height))
1119         return -1;
1120
1121     nb_components = get_bits(&s->gb, 8);
1122     if (nb_components <= 0 ||
1123         nb_components > MAX_COMPONENTS)
1124         return -1;
1125     s->nb_components = nb_components;
1126     s->h_max = 1;
1127     s->v_max = 1;
1128     for(i=0;i<nb_components;i++) {
1129         /* component id */
1130         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1131         s->h_count[i] = get_bits(&s->gb, 4);
1132         s->v_count[i] = get_bits(&s->gb, 4);
1133         /* compute hmax and vmax (only used in interleaved case) */
1134         if (s->h_count[i] > s->h_max)
1135             s->h_max = s->h_count[i];
1136         if (s->v_count[i] > s->v_max)
1137             s->v_max = s->v_count[i];
1138         s->quant_index[i] = get_bits(&s->gb, 8);
1139         if (s->quant_index[i] >= 4)
1140             return -1;
1141         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1142             s->v_count[i], s->component_id[i], s->quant_index[i]);
1143     }
1144
1145     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1146         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1147         return -1;
1148     }
1149
1150     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1151
1152     /* if different size, realloc/alloc picture */
1153     /* XXX: also check h_count and v_count */
1154     if (width != s->width || height != s->height) {
1155         av_freep(&s->qscale_table);
1156
1157         s->width = width;
1158         s->height = height;
1159
1160         /* test interlaced mode */
1161         if (s->first_picture &&
1162             s->org_height != 0 &&
1163             s->height < ((s->org_height * 3) / 4)) {
1164             s->interlaced = 1;
1165 //            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1166             s->bottom_field = 0;
1167             height *= 2;
1168         }
1169
1170         avcodec_set_dimensions(s->avctx, width, height);
1171
1172         s->qscale_table= av_mallocz((s->width+15)/16);
1173
1174         s->first_picture = 0;
1175     }
1176
1177     if(s->interlaced && s->bottom_field)
1178         return 0;
1179
1180     /* XXX: not complete test ! */
1181     switch((s->h_count[0] << 4) | s->v_count[0]) {
1182     case 0x11:
1183         if(s->rgb){
1184             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1185         }else if(s->nb_components==3)
1186             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1187         else
1188             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1189         break;
1190     case 0x21:
1191         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1192         break;
1193     default:
1194     case 0x22:
1195         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1196         break;
1197     }
1198     if(s->ls){
1199         if(s->nb_components > 1)
1200             s->avctx->pix_fmt = PIX_FMT_RGB24;
1201         else
1202             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1203     }
1204
1205     if(s->picture.data[0])
1206         s->avctx->release_buffer(s->avctx, &s->picture);
1207
1208     s->picture.reference= 0;
1209     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1210         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1211         return -1;
1212     }
1213     s->picture.pict_type= I_TYPE;
1214     s->picture.key_frame= 1;
1215
1216     for(i=0; i<3; i++){
1217         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1218     }
1219
1220 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1221
1222     if (len != (8+(3*nb_components)))
1223     {
1224         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1225     }
1226
1227     return 0;
1228 }
1229
1230 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1231 {
1232     int code;
1233     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1234     if (code < 0)
1235     {
1236         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1237                 &s->vlcs[0][dc_index]);
1238         return 0xffff;
1239     }
1240
1241     if(code)
1242         return get_xbits(&s->gb, code);
1243     else
1244         return 0;
1245 }
1246
1247 /* decode block and dequantize */
1248 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1249                         int component, int dc_index, int ac_index, int quant_index)
1250 {
1251     int code, i, j, level, val;
1252     VLC *ac_vlc;
1253     int16_t *quant_matrix;
1254
1255     /* DC coef */
1256     val = mjpeg_decode_dc(s, dc_index);
1257     if (val == 0xffff) {
1258         dprintf("error dc\n");
1259         return -1;
1260     }
1261     quant_matrix = s->quant_matrixes[quant_index];
1262     val = val * quant_matrix[0] + s->last_dc[component];
1263     s->last_dc[component] = val;
1264     block[0] = val;
1265     /* AC coefs */
1266     ac_vlc = &s->vlcs[1][ac_index];
1267     i = 1;
1268     for(;;) {
1269         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1270
1271         if (code < 0) {
1272             dprintf("error ac\n");
1273             return -1;
1274         }
1275         /* EOB */
1276         if (code == 0)
1277             break;
1278         if (code == 0xf0) {
1279             i += 16;
1280         } else {
1281             level = get_xbits(&s->gb, code & 0xf);
1282             i += code >> 4;
1283             if (i >= 64) {
1284                 dprintf("error count: %d\n", i);
1285                 return -1;
1286             }
1287             j = s->scantable.permutated[i];
1288             block[j] = level * quant_matrix[j];
1289             i++;
1290             if (i >= 64)
1291                 break;
1292         }
1293     }
1294     return 0;
1295 }
1296
1297 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1298     int i, mb_x, mb_y;
1299     uint16_t buffer[32768][4];
1300     int left[3], top[3], topleft[3];
1301     const int linesize= s->linesize[0];
1302     const int mask= (1<<s->bits)-1;
1303
1304     if((unsigned)s->mb_width > 32768) //dynamic alloc
1305         return -1;
1306
1307     for(i=0; i<3; i++){
1308         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1309     }
1310     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1311         const int modified_predictor= mb_y ? predictor : 1;
1312         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1313
1314         if (s->interlaced && s->bottom_field)
1315             ptr += linesize >> 1;
1316
1317         for(i=0; i<3; i++){
1318             top[i]= left[i]= topleft[i]= buffer[0][i];
1319         }
1320         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1321             if (s->restart_interval && !s->restart_count)
1322                 s->restart_count = s->restart_interval;
1323
1324             for(i=0;i<3;i++) {
1325                 int pred;
1326
1327                 topleft[i]= top[i];
1328                 top[i]= buffer[mb_x][i];
1329
1330                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1331
1332                 left[i]=
1333                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1334             }
1335
1336             if (s->restart_interval && !--s->restart_count) {
1337                 align_get_bits(&s->gb);
1338                 skip_bits(&s->gb, 16); /* skip RSTn */
1339             }
1340         }
1341
1342         if(s->rct){
1343             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1344                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1345                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1346                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1347             }
1348         }else if(s->pegasus_rct){
1349             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1350                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1351                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1352                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1353             }
1354         }else{
1355             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1356                 ptr[4*mb_x+0] = buffer[mb_x][0];
1357                 ptr[4*mb_x+1] = buffer[mb_x][1];
1358                 ptr[4*mb_x+2] = buffer[mb_x][2];
1359             }
1360         }
1361     }
1362     return 0;
1363 }
1364
1365 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1366     int i, mb_x, mb_y;
1367     const int nb_components=3;
1368
1369     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1370         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1371             if (s->restart_interval && !s->restart_count)
1372                 s->restart_count = s->restart_interval;
1373
1374             if(mb_x==0 || mb_y==0 || s->interlaced){
1375                 for(i=0;i<nb_components;i++) {
1376                     uint8_t *ptr;
1377                     int n, h, v, x, y, c, j, linesize;
1378                     n = s->nb_blocks[i];
1379                     c = s->comp_index[i];
1380                     h = s->h_scount[i];
1381                     v = s->v_scount[i];
1382                     x = 0;
1383                     y = 0;
1384                     linesize= s->linesize[c];
1385
1386                     for(j=0; j<n; j++) {
1387                         int pred;
1388
1389                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1390                         if(y==0 && mb_y==0){
1391                             if(x==0 && mb_x==0){
1392                                 pred= 128 << point_transform;
1393                             }else{
1394                                 pred= ptr[-1];
1395                             }
1396                         }else{
1397                             if(x==0 && mb_x==0){
1398                                 pred= ptr[-linesize];
1399                             }else{
1400                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1401                             }
1402                         }
1403
1404                         if (s->interlaced && s->bottom_field)
1405                             ptr += linesize >> 1;
1406                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1407
1408                         if (++x == h) {
1409                             x = 0;
1410                             y++;
1411                         }
1412                     }
1413                 }
1414             }else{
1415                 for(i=0;i<nb_components;i++) {
1416                     uint8_t *ptr;
1417                     int n, h, v, x, y, c, j, linesize;
1418                     n = s->nb_blocks[i];
1419                     c = s->comp_index[i];
1420                     h = s->h_scount[i];
1421                     v = s->v_scount[i];
1422                     x = 0;
1423                     y = 0;
1424                     linesize= s->linesize[c];
1425
1426                     for(j=0; j<n; j++) {
1427                         int pred;
1428
1429                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1430                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1431                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1432                         if (++x == h) {
1433                             x = 0;
1434                             y++;
1435                         }
1436                     }
1437                 }
1438             }
1439             if (s->restart_interval && !--s->restart_count) {
1440                 align_get_bits(&s->gb);
1441                 skip_bits(&s->gb, 16); /* skip RSTn */
1442             }
1443         }
1444     }
1445     return 0;
1446 }
1447
1448 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1449     int i, mb_x, mb_y;
1450     const int nb_components=3;
1451
1452     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1453         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1454             if (s->restart_interval && !s->restart_count)
1455                 s->restart_count = s->restart_interval;
1456
1457             for(i=0;i<nb_components;i++) {
1458                 uint8_t *ptr;
1459                 int n, h, v, x, y, c, j;
1460                 n = s->nb_blocks[i];
1461                 c = s->comp_index[i];
1462                 h = s->h_scount[i];
1463                 v = s->v_scount[i];
1464                 x = 0;
1465                 y = 0;
1466                 for(j=0;j<n;j++) {
1467                     memset(s->block, 0, sizeof(s->block));
1468                     if (decode_block(s, s->block, i,
1469                                      s->dc_index[i], s->ac_index[i],
1470                                      s->quant_index[c]) < 0) {
1471                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1472                         return -1;
1473                     }
1474 //                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1475                     ptr = s->picture.data[c] +
1476                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1477                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1478                     if (s->interlaced && s->bottom_field)
1479                         ptr += s->linesize[c] >> 1;
1480 //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);
1481                     s->idct_put(ptr, s->linesize[c], s->block);
1482                     if (++x == h) {
1483                         x = 0;
1484                         y++;
1485                     }
1486                 }
1487             }
1488             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1489             if (s->restart_interval && (s->restart_interval < 1350) &&
1490                 !--s->restart_count) {
1491                 align_get_bits(&s->gb);
1492                 skip_bits(&s->gb, 16); /* skip RSTn */
1493                 for (i=0; i<nb_components; i++) /* reset dc */
1494                     s->last_dc[i] = 1024;
1495             }
1496         }
1497     }
1498     return 0;
1499 }
1500
1501 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1502 {
1503     int len, nb_components, i, h, v, predictor, point_transform;
1504     int vmax, hmax, index, id;
1505     const int block_size= s->lossless ? 1 : 8;
1506     int ilv;
1507
1508     /* XXX: verify len field validity */
1509     len = get_bits(&s->gb, 16);
1510     nb_components = get_bits(&s->gb, 8);
1511     if (len != 6+2*nb_components)
1512     {
1513         dprintf("decode_sos: invalid len (%d)\n", len);
1514         return -1;
1515     }
1516     /* XXX: only interleaved scan accepted */
1517     if ((nb_components != s->nb_components) && !s->ls)
1518     {
1519         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1520         return -1;
1521     }
1522     vmax = 0;
1523     hmax = 0;
1524     for(i=0;i<nb_components;i++) {
1525         id = get_bits(&s->gb, 8) - 1;
1526         dprintf("component: %d\n", id);
1527         /* find component index */
1528         for(index=0;index<s->nb_components;index++)
1529             if (id == s->component_id[index])
1530                 break;
1531         if (index == s->nb_components)
1532         {
1533             dprintf("decode_sos: index(%d) out of components\n", index);
1534             return -1;
1535         }
1536
1537         s->comp_index[i] = index;
1538
1539         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1540         s->h_scount[i] = s->h_count[index];
1541         s->v_scount[i] = s->v_count[index];
1542
1543         s->dc_index[i] = get_bits(&s->gb, 4);
1544         s->ac_index[i] = get_bits(&s->gb, 4);
1545
1546         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1547             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1548             goto out_of_range;
1549 #if 0 //buggy
1550         switch(s->start_code)
1551         {
1552             case SOF0:
1553                 if (dc_index[i] > 1 || ac_index[i] > 1)
1554                     goto out_of_range;
1555                 break;
1556             case SOF1:
1557             case SOF2:
1558                 if (dc_index[i] > 3 || ac_index[i] > 3)
1559                     goto out_of_range;
1560                 break;
1561             case SOF3:
1562                 if (dc_index[i] > 3 || ac_index[i] != 0)
1563                     goto out_of_range;
1564                 break;
1565         }
1566 #endif
1567     }
1568
1569     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1570     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1571     skip_bits(&s->gb, 4); /* Ah */
1572     point_transform= get_bits(&s->gb, 4); /* Al */
1573
1574     for(i=0;i<nb_components;i++)
1575         s->last_dc[i] = 1024;
1576
1577     if (nb_components > 1) {
1578         /* interleaved stream */
1579         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1580         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1581     } else if(!s->ls) { /* skip this for JPEG-LS */
1582         h = s->h_max / s->h_scount[s->comp_index[0]];
1583         v = s->v_max / s->v_scount[s->comp_index[0]];
1584         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1585         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1586         s->nb_blocks[0] = 1;
1587         s->h_scount[0] = 1;
1588         s->v_scount[0] = 1;
1589     }
1590
1591     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1592         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" : "",
1593                predictor, point_transform, ilv, s->bits,
1594                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1595
1596
1597     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1598     for (i = s->mjpb_skiptosod; i > 0; i--)
1599         skip_bits(&s->gb, 8);
1600
1601     if(s->lossless){
1602         if(s->ls){
1603 //            for(){
1604 //            reset_ls_coding_parameters(s, 0);
1605
1606             ls_decode_picture(s, predictor, point_transform, ilv);
1607         }else{
1608             if(s->rgb){
1609                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1610                     return -1;
1611             }else{
1612                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1613                     return -1;
1614             }
1615         }
1616     }else{
1617         if(mjpeg_decode_scan(s) < 0)
1618             return -1;
1619     }
1620     emms_c();
1621     return 0;
1622  out_of_range:
1623     dprintf("decode_sos: ac/dc index out of range\n");
1624     return -1;
1625 }
1626
1627 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1628 {
1629     if (get_bits(&s->gb, 16) != 4)
1630         return -1;
1631     s->restart_interval = get_bits(&s->gb, 16);
1632     s->restart_count = 0;
1633     dprintf("restart interval: %d\n", s->restart_interval);
1634
1635     return 0;
1636 }
1637
1638 static int mjpeg_decode_app(MJpegDecodeContext *s)
1639 {
1640     int len, id;
1641
1642     len = get_bits(&s->gb, 16);
1643     if (len < 5)
1644         return -1;
1645     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1646         return -1;
1647
1648     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1649     id = be2me_32(id);
1650     len -= 6;
1651
1652     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1653         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1654     }
1655
1656     /* buggy AVID, it puts EOI only at every 10th frame */
1657     /* also this fourcc is used by non-avid files too, it holds some
1658        informations, but it's always present in AVID creates files */
1659     if (id == ff_get_fourcc("AVI1"))
1660     {
1661         /* structure:
1662             4bytes      AVI1
1663             1bytes      polarity
1664             1bytes      always zero
1665             4bytes      field_size
1666             4bytes      field_size_less_padding
1667         */
1668             s->buggy_avid = 1;
1669 //        if (s->first_picture)
1670 //            printf("mjpeg: workarounding buggy AVID\n");
1671         s->interlace_polarity = get_bits(&s->gb, 8);
1672 #if 0
1673         skip_bits(&s->gb, 8);
1674         skip_bits(&s->gb, 32);
1675         skip_bits(&s->gb, 32);
1676         len -= 10;
1677 #endif
1678 //        if (s->interlace_polarity)
1679 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1680         goto out;
1681     }
1682
1683 //    len -= 2;
1684
1685     if (id == ff_get_fourcc("JFIF"))
1686     {
1687         int t_w, t_h, v1, v2;
1688         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1689         v1= get_bits(&s->gb, 8);
1690         v2= get_bits(&s->gb, 8);
1691         skip_bits(&s->gb, 8);
1692
1693         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1694         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1695
1696         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1697             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1698                 v1, v2,
1699                 s->avctx->sample_aspect_ratio.num,
1700                 s->avctx->sample_aspect_ratio.den
1701             );
1702
1703         t_w = get_bits(&s->gb, 8);
1704         t_h = get_bits(&s->gb, 8);
1705         if (t_w && t_h)
1706         {
1707             /* skip thumbnail */
1708             if (len-10-(t_w*t_h*3) > 0)
1709                 len -= t_w*t_h*3;
1710         }
1711         len -= 10;
1712         goto out;
1713     }
1714
1715     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1716     {
1717         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1718             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1719         skip_bits(&s->gb, 16); /* version */
1720         skip_bits(&s->gb, 16); /* flags0 */
1721         skip_bits(&s->gb, 16); /* flags1 */
1722         skip_bits(&s->gb, 8);  /* transform */
1723         len -= 7;
1724         goto out;
1725     }
1726
1727     if (id == ff_get_fourcc("LJIF")){
1728         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1729             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1730         skip_bits(&s->gb, 16); /* version ? */
1731         skip_bits(&s->gb, 16); /* unknwon always 0? */
1732         skip_bits(&s->gb, 16); /* unknwon always 0? */
1733         skip_bits(&s->gb, 16); /* unknwon always 0? */
1734         switch( get_bits(&s->gb, 8)){
1735         case 1:
1736             s->rgb= 1;
1737             s->pegasus_rct=0;
1738             break;
1739         case 2:
1740             s->rgb= 1;
1741             s->pegasus_rct=1;
1742             break;
1743         default:
1744             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1745         }
1746         len -= 9;
1747         goto out;
1748     }
1749
1750     /* Apple MJPEG-A */
1751     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1752     {
1753         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1754         id = be2me_32(id);
1755         len -= 4;
1756         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1757         {
1758 #if 0
1759             skip_bits(&s->gb, 32); /* field size */
1760             skip_bits(&s->gb, 32); /* pad field size */
1761             skip_bits(&s->gb, 32); /* next off */
1762             skip_bits(&s->gb, 32); /* quant off */
1763             skip_bits(&s->gb, 32); /* huff off */
1764             skip_bits(&s->gb, 32); /* image off */
1765             skip_bits(&s->gb, 32); /* scan off */
1766             skip_bits(&s->gb, 32); /* data off */
1767 #endif
1768             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1769                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1770         }
1771     }
1772
1773 out:
1774     /* slow but needed for extreme adobe jpegs */
1775     if (len < 0)
1776         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1777     while(--len > 0)
1778         skip_bits(&s->gb, 8);
1779
1780     return 0;
1781 }
1782
1783 static int mjpeg_decode_com(MJpegDecodeContext *s)
1784 {
1785     int len = get_bits(&s->gb, 16);
1786     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1787         uint8_t *cbuf = av_malloc(len - 1);
1788         if (cbuf) {
1789             int i;
1790             for (i = 0; i < len - 2; i++)
1791                 cbuf[i] = get_bits(&s->gb, 8);
1792             if (i > 0 && cbuf[i-1] == '\n')
1793                 cbuf[i-1] = 0;
1794             else
1795                 cbuf[i] = 0;
1796
1797             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1798                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1799
1800             /* buggy avid, it puts EOI only at every 10th frame */
1801             if (!strcmp(cbuf, "AVID"))
1802             {
1803                 s->buggy_avid = 1;
1804                 //        if (s->first_picture)
1805                 //            printf("mjpeg: workarounding buggy AVID\n");
1806             }
1807             else if(!strcmp(cbuf, "CS=ITU601")){
1808                 s->cs_itu601= 1;
1809             }
1810
1811             av_free(cbuf);
1812         }
1813     }
1814
1815     return 0;
1816 }
1817
1818 #if 0
1819 static int valid_marker_list[] =
1820 {
1821         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1822 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1823 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1824 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1825 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1826 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1827 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1828 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1829 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1830 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1831 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1832 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1833 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1834 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1835 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1836 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1837 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1838 }
1839 #endif
1840
1841 /* return the 8 bit start code value and update the search
1842    state. Return -1 if no start code found */
1843 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1844 {
1845     uint8_t *buf_ptr;
1846     unsigned int v, v2;
1847     int val;
1848 #ifdef DEBUG
1849     int skipped=0;
1850 #endif
1851
1852     buf_ptr = *pbuf_ptr;
1853     while (buf_ptr < buf_end) {
1854         v = *buf_ptr++;
1855         v2 = *buf_ptr;
1856         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1857             val = *buf_ptr++;
1858             goto found;
1859         }
1860 #ifdef DEBUG
1861         skipped++;
1862 #endif
1863     }
1864     val = -1;
1865 found:
1866 #ifdef DEBUG
1867     dprintf("find_marker skipped %d bytes\n", skipped);
1868 #endif
1869     *pbuf_ptr = buf_ptr;
1870     return val;
1871 }
1872
1873 static int mjpeg_decode_frame(AVCodecContext *avctx,
1874                               void *data, int *data_size,
1875                               uint8_t *buf, int buf_size)
1876 {
1877     MJpegDecodeContext *s = avctx->priv_data;
1878     uint8_t *buf_end, *buf_ptr;
1879     int start_code;
1880     AVFrame *picture = data;
1881
1882     buf_ptr = buf;
1883     buf_end = buf + buf_size;
1884     while (buf_ptr < buf_end) {
1885         /* find start next marker */
1886         start_code = find_marker(&buf_ptr, buf_end);
1887         {
1888             /* EOF */
1889             if (start_code < 0) {
1890                 goto the_end;
1891             } else {
1892                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1893
1894                 if ((buf_end - buf_ptr) > s->buffer_size)
1895                 {
1896                     av_free(s->buffer);
1897                     s->buffer_size = buf_end-buf_ptr;
1898                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1899                     dprintf("buffer too small, expanding to %d bytes\n",
1900                         s->buffer_size);
1901                 }
1902
1903                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1904                 if (start_code == SOS && !s->ls)
1905                 {
1906                     uint8_t *src = buf_ptr;
1907                     uint8_t *dst = s->buffer;
1908
1909                     while (src<buf_end)
1910                     {
1911                         uint8_t x = *(src++);
1912
1913                         *(dst++) = x;
1914                         if (x == 0xff)
1915                         {
1916                             while(src<buf_end && x == 0xff)
1917                                 x = *(src++);
1918
1919                             if (x >= 0xd0 && x <= 0xd7)
1920                                 *(dst++) = x;
1921                             else if (x)
1922                                 break;
1923                         }
1924                     }
1925                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1926
1927                     dprintf("escaping removed %d bytes\n",
1928                         (buf_end - buf_ptr) - (dst - s->buffer));
1929                 }
1930                 else if(start_code == SOS && s->ls){
1931                     uint8_t *src = buf_ptr;
1932                     uint8_t *dst = s->buffer;
1933                     int bit_count = 0;
1934                     int t = 0, b = 0;
1935                     PutBitContext pb;
1936
1937                     s->cur_scan++;
1938
1939                     /* find marker */
1940                     while (src + t < buf_end){
1941                         uint8_t x = src[t++];
1942                         if (x == 0xff){
1943                             while((src + t < buf_end) && x == 0xff)
1944                                 x = src[t++];
1945                             if (x & 0x80) {
1946                                 t -= 2;
1947                                 break;
1948                             }
1949                         }
1950                     }
1951                     bit_count = t * 8;
1952
1953                     init_put_bits(&pb, dst, t);
1954
1955                     /* unescape bitstream */
1956                     while(b < t){
1957                         uint8_t x = src[b++];
1958                         put_bits(&pb, 8, x);
1959                         if(x == 0xFF){
1960                             x = src[b++];
1961                             put_bits(&pb, 7, x);
1962                             bit_count--;
1963                         }
1964                     }
1965                     flush_put_bits(&pb);
1966
1967                     init_get_bits(&s->gb, dst, bit_count);
1968                 }
1969                 else
1970                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1971
1972                 s->start_code = start_code;
1973                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1974                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1975                 }
1976
1977                 /* process markers */
1978                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1979                     dprintf("restart marker: %d\n", start_code&0x0f);
1980                     /* APP fields */
1981                 } else if (start_code >= APP0 && start_code <= APP15) {
1982                     mjpeg_decode_app(s);
1983                     /* Comment */
1984                 } else if (start_code == COM){
1985                     mjpeg_decode_com(s);
1986                 }
1987
1988                 switch(start_code) {
1989                 case SOI:
1990                     s->restart_interval = 0;
1991
1992                     s->restart_count = 0;
1993                     /* nothing to do on SOI */
1994                     break;
1995                 case DQT:
1996                     mjpeg_decode_dqt(s);
1997                     break;
1998                 case DHT:
1999                     if(mjpeg_decode_dht(s) < 0){
2000                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2001                         return -1;
2002                     }
2003                     break;
2004                 case SOF0:
2005                     s->lossless=0;
2006                     if (mjpeg_decode_sof(s) < 0)
2007                         return -1;
2008                     break;
2009                 case SOF3:
2010                     s->lossless=1;
2011                     if (mjpeg_decode_sof(s) < 0)
2012                         return -1;
2013                     break;
2014                 case SOF48:
2015                     s->lossless=1;
2016                     s->ls=1;
2017                     if (mjpeg_decode_sof(s) < 0)
2018                         return -1;
2019                     break;
2020                 case LSE:
2021                     if (decode_lse(s) < 0)
2022                         return -1;
2023                     break;
2024                 case EOI:
2025                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2026                         break;
2027 eoi_parser:
2028                     {
2029                         if (s->interlaced) {
2030                             s->bottom_field ^= 1;
2031                             /* if not bottom field, do not output image yet */
2032                             if (s->bottom_field)
2033                                 goto not_the_end;
2034                         }
2035                         *picture = s->picture;
2036                         *data_size = sizeof(AVFrame);
2037
2038                         if(!s->lossless){
2039                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2040                             picture->qstride= 0;
2041                             picture->qscale_table= s->qscale_table;
2042                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2043                             if(avctx->debug & FF_DEBUG_QP)
2044                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2045                             picture->quality*= FF_QP2LAMBDA;
2046                         }
2047
2048                         goto the_end;
2049                     }
2050                     break;
2051                 case SOS:
2052                     mjpeg_decode_sos(s);
2053                     /* buggy avid puts EOI every 10-20th frame */
2054                     /* if restart period is over process EOI */
2055                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2056                         goto eoi_parser;
2057                     break;
2058                 case DRI:
2059                     mjpeg_decode_dri(s);
2060                     break;
2061                 case SOF1:
2062                 case SOF2:
2063                 case SOF5:
2064                 case SOF6:
2065                 case SOF7:
2066                 case SOF9:
2067                 case SOF10:
2068                 case SOF11:
2069                 case SOF13:
2070                 case SOF14:
2071                 case SOF15:
2072                 case JPG:
2073                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2074                     break;
2075 //                default:
2076 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2077 //                    break;
2078                 }
2079
2080 not_the_end:
2081                 /* eof process start code */
2082                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2083                 dprintf("marker parser used %d bytes (%d bits)\n",
2084                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2085             }
2086         }
2087     }
2088 the_end:
2089     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2090 //    return buf_end - buf_ptr;
2091     return buf_ptr - buf;
2092 }
2093
2094 static int mjpegb_decode_frame(AVCodecContext *avctx,
2095                               void *data, int *data_size,
2096                               uint8_t *buf, int buf_size)
2097 {
2098     MJpegDecodeContext *s = avctx->priv_data;
2099     uint8_t *buf_end, *buf_ptr;
2100     AVFrame *picture = data;
2101     GetBitContext hgb; /* for the header */
2102     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2103     uint32_t field_size, sod_offs;
2104
2105     buf_ptr = buf;
2106     buf_end = buf + buf_size;
2107
2108 read_header:
2109     /* reset on every SOI */
2110     s->restart_interval = 0;
2111     s->restart_count = 0;
2112     s->mjpb_skiptosod = 0;
2113
2114     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2115
2116     skip_bits(&hgb, 32); /* reserved zeros */
2117
2118     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2119     {
2120         dprintf("not mjpeg-b (bad fourcc)\n");
2121         return 0;
2122     }
2123
2124     field_size = get_bits_long(&hgb, 32); /* field size */
2125     dprintf("field size: 0x%x\n", field_size);
2126     skip_bits(&hgb, 32); /* padded field size */
2127     second_field_offs = get_bits_long(&hgb, 32);
2128     dprintf("second field offs: 0x%x\n", second_field_offs);
2129     if (second_field_offs)
2130         s->interlaced = 1;
2131
2132     dqt_offs = get_bits_long(&hgb, 32);
2133     dprintf("dqt offs: 0x%x\n", dqt_offs);
2134     if (dqt_offs)
2135     {
2136         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2137         s->start_code = DQT;
2138         mjpeg_decode_dqt(s);
2139     }
2140
2141     dht_offs = get_bits_long(&hgb, 32);
2142     dprintf("dht offs: 0x%x\n", dht_offs);
2143     if (dht_offs)
2144     {
2145         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2146         s->start_code = DHT;
2147         mjpeg_decode_dht(s);
2148     }
2149
2150     sof_offs = get_bits_long(&hgb, 32);
2151     dprintf("sof offs: 0x%x\n", sof_offs);
2152     if (sof_offs)
2153     {
2154         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2155         s->start_code = SOF0;
2156         if (mjpeg_decode_sof(s) < 0)
2157             return -1;
2158     }
2159
2160     sos_offs = get_bits_long(&hgb, 32);
2161     dprintf("sos offs: 0x%x\n", sos_offs);
2162     sod_offs = get_bits_long(&hgb, 32);
2163     dprintf("sod offs: 0x%x\n", sod_offs);
2164     if (sos_offs)
2165     {
2166 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2167         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2168         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2169         s->start_code = SOS;
2170         mjpeg_decode_sos(s);
2171     }
2172
2173     if (s->interlaced) {
2174         s->bottom_field ^= 1;
2175         /* if not bottom field, do not output image yet */
2176         if (s->bottom_field && second_field_offs)
2177         {
2178             buf_ptr = buf + second_field_offs;
2179             second_field_offs = 0;
2180             goto read_header;
2181             }
2182     }
2183
2184     //XXX FIXME factorize, this looks very similar to the EOI code
2185
2186     *picture= s->picture;
2187     *data_size = sizeof(AVFrame);
2188
2189     if(!s->lossless){
2190         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2191         picture->qstride= 0;
2192         picture->qscale_table= s->qscale_table;
2193         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2194         if(avctx->debug & FF_DEBUG_QP)
2195             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2196         picture->quality*= FF_QP2LAMBDA;
2197     }
2198
2199     return buf_ptr - buf;
2200 }
2201
2202 #include "sp5x.h"
2203
2204 static int sp5x_decode_frame(AVCodecContext *avctx,
2205                               void *data, int *data_size,
2206                               uint8_t *buf, int buf_size)
2207 {
2208 #if 0
2209     MJpegDecodeContext *s = avctx->priv_data;
2210 #endif
2211     const int qscale = 5;
2212     uint8_t *buf_ptr, *buf_end, *recoded;
2213     int i = 0, j = 0;
2214
2215     if (!avctx->width || !avctx->height)
2216         return -1;
2217
2218     buf_ptr = buf;
2219     buf_end = buf + buf_size;
2220
2221 #if 1
2222     recoded = av_mallocz(buf_size + 1024);
2223     if (!recoded)
2224         return -1;
2225
2226     /* SOI */
2227     recoded[j++] = 0xFF;
2228     recoded[j++] = 0xD8;
2229
2230     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2231     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2232     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2233     j += sizeof(sp5x_data_dqt);
2234
2235     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2236     j += sizeof(sp5x_data_dht);
2237
2238     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2239     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2240     recoded[j+6] = avctx->coded_height & 0xFF;
2241     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2242     recoded[j+8] = avctx->coded_width & 0xFF;
2243     j += sizeof(sp5x_data_sof);
2244
2245     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2246     j += sizeof(sp5x_data_sos);
2247
2248     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2249     {
2250         recoded[j++] = buf[i];
2251         if (buf[i] == 0xff)
2252             recoded[j++] = 0;
2253     }
2254
2255     /* EOI */
2256     recoded[j++] = 0xFF;
2257     recoded[j++] = 0xD9;
2258
2259     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2260
2261     av_free(recoded);
2262
2263 #else
2264     /* SOF */
2265     s->bits = 8;
2266     s->width  = avctx->coded_width;
2267     s->height = avctx->coded_height;
2268     s->nb_components = 3;
2269     s->component_id[0] = 0;
2270     s->h_count[0] = 2;
2271     s->v_count[0] = 2;
2272     s->quant_index[0] = 0;
2273     s->component_id[1] = 1;
2274     s->h_count[1] = 1;
2275     s->v_count[1] = 1;
2276     s->quant_index[1] = 1;
2277     s->component_id[2] = 2;
2278     s->h_count[2] = 1;
2279     s->v_count[2] = 1;
2280     s->quant_index[2] = 1;
2281     s->h_max = 2;
2282     s->v_max = 2;
2283
2284     s->qscale_table = av_mallocz((s->width+15)/16);
2285     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2286     s->interlaced = 0;
2287
2288     s->picture.reference = 0;
2289     if (avctx->get_buffer(avctx, &s->picture) < 0)
2290     {
2291         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2292         return -1;
2293     }
2294
2295     s->picture.pict_type = I_TYPE;
2296     s->picture.key_frame = 1;
2297
2298     for (i = 0; i < 3; i++)
2299         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2300
2301     /* DQT */
2302     for (i = 0; i < 64; i++)
2303     {
2304         j = s->scantable.permutated[i];
2305         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2306     }
2307     s->qscale[0] = FFMAX(
2308         s->quant_matrixes[0][s->scantable.permutated[1]],
2309         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2310
2311     for (i = 0; i < 64; i++)
2312     {
2313         j = s->scantable.permutated[i];
2314         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2315     }
2316     s->qscale[1] = FFMAX(
2317         s->quant_matrixes[1][s->scantable.permutated[1]],
2318         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2319
2320     /* DHT */
2321
2322     /* SOS */
2323     s->comp_index[0] = 0;
2324     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2325     s->h_scount[0] = s->h_count[0];
2326     s->v_scount[0] = s->v_count[0];
2327     s->dc_index[0] = 0;
2328     s->ac_index[0] = 0;
2329
2330     s->comp_index[1] = 1;
2331     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2332     s->h_scount[1] = s->h_count[1];
2333     s->v_scount[1] = s->v_count[1];
2334     s->dc_index[1] = 1;
2335     s->ac_index[1] = 1;
2336
2337     s->comp_index[2] = 2;
2338     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2339     s->h_scount[2] = s->h_count[2];
2340     s->v_scount[2] = s->v_count[2];
2341     s->dc_index[2] = 1;
2342     s->ac_index[2] = 1;
2343
2344     for (i = 0; i < 3; i++)
2345         s->last_dc[i] = 1024;
2346
2347     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2348     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2349
2350     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2351
2352     return mjpeg_decode_scan(s);
2353 #endif
2354
2355     return i;
2356 }
2357
2358 static int mjpeg_decode_end(AVCodecContext *avctx)
2359 {
2360     MJpegDecodeContext *s = avctx->priv_data;
2361     int i, j;
2362
2363     av_free(s->buffer);
2364     av_free(s->qscale_table);
2365
2366     for(i=0;i<2;i++) {
2367         for(j=0;j<4;j++)
2368             free_vlc(&s->vlcs[i][j]);
2369     }
2370     return 0;
2371 }
2372
2373 AVCodec mjpeg_decoder = {
2374     "mjpeg",
2375     CODEC_TYPE_VIDEO,
2376     CODEC_ID_MJPEG,
2377     sizeof(MJpegDecodeContext),
2378     mjpeg_decode_init,
2379     NULL,
2380     mjpeg_decode_end,
2381     mjpeg_decode_frame,
2382     CODEC_CAP_DR1,
2383     NULL
2384 };
2385
2386 AVCodec mjpegb_decoder = {
2387     "mjpegb",
2388     CODEC_TYPE_VIDEO,
2389     CODEC_ID_MJPEGB,
2390     sizeof(MJpegDecodeContext),
2391     mjpeg_decode_init,
2392     NULL,
2393     mjpeg_decode_end,
2394     mjpegb_decode_frame,
2395     CODEC_CAP_DR1,
2396     NULL
2397 };
2398
2399 AVCodec sp5x_decoder = {
2400     "sp5x",
2401     CODEC_TYPE_VIDEO,
2402     CODEC_ID_SP5X,
2403     sizeof(MJpegDecodeContext),
2404     mjpeg_decode_init,
2405     NULL,
2406     mjpeg_decode_end,
2407     sp5x_decode_frame,
2408     CODEC_CAP_DR1,
2409     NULL
2410 };
2411
2412 #ifdef CONFIG_ENCODERS
2413 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2414     "ljpeg",
2415     CODEC_TYPE_VIDEO,
2416     CODEC_ID_LJPEG,
2417     sizeof(MpegEncContext),
2418     MPV_encode_init,
2419     encode_picture_lossless,
2420     MPV_encode_end,
2421 };
2422 #endif
2423
2424 AVCodecParser mjpeg_parser = {
2425     { CODEC_ID_MJPEG },
2426     sizeof(ParseContext),
2427     NULL,
2428     jpeg_parse,
2429     ff_parse_close,
2430 };
2431