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