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