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

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