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