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

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