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