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

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