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