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 #ifdef CONFIG_ENCODERS
 247 int mjpeg_init(MpegEncContext *s)
 248 {
 249     MJpegContext *m;
 250
 251     m = av_malloc(sizeof(MJpegContext));
 252     if (!m)
 253         return -1;
 254
 255     s->min_qcoeff=-1023;
 256     s->max_qcoeff= 1023;
 257
 258     /* build all the huffman tables */
 259     build_huffman_codes(m->huff_size_dc_luminance,
 260                         m->huff_code_dc_luminance,
 261                         bits_dc_luminance,
 262                         val_dc_luminance);
 263     build_huffman_codes(m->huff_size_dc_chrominance,
 264                         m->huff_code_dc_chrominance,
 265                         bits_dc_chrominance,
 266                         val_dc_chrominance);
 267     build_huffman_codes(m->huff_size_ac_luminance,
 268                         m->huff_code_ac_luminance,
 269                         bits_ac_luminance,
 270                         val_ac_luminance);
 271     build_huffman_codes(m->huff_size_ac_chrominance,
 272                         m->huff_code_ac_chrominance,
 273                         bits_ac_chrominance,
 274                         val_ac_chrominance);
 275
 276     s->mjpeg_ctx = m;
 277     return 0;
 278 }
 279
 280 void mjpeg_close(MpegEncContext *s)
 281 {
 282     av_free(s->mjpeg_ctx);
 283 }
 284 #endif //CONFIG_ENCODERS
 285
 286 #define PREDICT(ret, topleft, top, left, predictor)\
 287     switch(predictor){\
 288         case 1: ret= left; break;\
 289         case 2: ret= top; break;\
 290         case 3: ret= topleft; break;\
 291         case 4: ret= left   +   top - topleft; break;\
 292         case 5: ret= left   + ((top - topleft)>>1); break;\
 293         case 6: ret= top + ((left   - topleft)>>1); break;\
 294         default:\
 295         case 7: ret= (left + top)>>1; break;\
 296     }
 297
 298 #ifdef CONFIG_ENCODERS
 299 static inline void put_marker(PutBitContext *p, int code)
 300 {
 301     put_bits(p, 8, 0xff);
 302     put_bits(p, 8, code);
 303 }
 304
 305 /* table_class: 0 = DC coef, 1 = AC coefs */
 306 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 307                              const uint8_t *bits_table, const uint8_t *value_table)
 308 {
 309     PutBitContext *p = &s->pb;
 310     int n, i;
 311
 312     put_bits(p, 4, table_class);
 313     put_bits(p, 4, table_id);
 314
 315     n = 0;
 316     for(i=1;i<=16;i++) {
 317         n += bits_table[i];
 318         put_bits(p, 8, bits_table[i]);
 319     }
 320
 321     for(i=0;i<n;i++)
 322         put_bits(p, 8, value_table[i]);
 323
 324     return n + 17;
 325 }
 326
 327 static void jpeg_table_header(MpegEncContext *s)
 328 {
 329     PutBitContext *p = &s->pb;
 330     int i, j, size;
 331     uint8_t *ptr;
 332
 333     /* quant matrixes */
 334     put_marker(p, DQT);
 335 #ifdef TWOMATRIXES
 336     put_bits(p, 16, 2 + 2 * (1 + 64));
 337 #else
 338     put_bits(p, 16, 2 + 1 * (1 + 64));
 339 #endif
 340     put_bits(p, 4, 0); /* 8 bit precision */
 341     put_bits(p, 4, 0); /* table 0 */
 342     for(i=0;i<64;i++) {
 343         j = s->intra_scantable.permutated[i];
 344         put_bits(p, 8, s->intra_matrix[j]);
 345     }
 346 #ifdef TWOMATRIXES
 347     put_bits(p, 4, 0); /* 8 bit precision */
 348     put_bits(p, 4, 1); /* table 1 */
 349     for(i=0;i<64;i++) {
 350         j = s->intra_scantable.permutated[i];
 351         put_bits(p, 8, s->chroma_intra_matrix[j]);
 352     }
 353 #endif
 354
 355     /* huffman table */
 356     put_marker(p, DHT);
 357     flush_put_bits(p);
 358     ptr = pbBufPtr(p);
 359     put_bits(p, 16, 0); /* patched later */
 360     size = 2;
 361     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 362     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 363
 364     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 365     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 366     ptr[0] = size >> 8;
 367     ptr[1] = size;
 368 }
 369
 370 static void jpeg_put_comments(MpegEncContext *s)
 371 {
 372     PutBitContext *p = &s->pb;
 373     int size;
 374     uint8_t *ptr;
 375
 376     if (s->aspect_ratio_info /* && !lossless */)
 377     {
 378     /* JFIF header */
 379     put_marker(p, APP0);
 380     put_bits(p, 16, 16);
 381     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
 382     put_bits(p, 16, 0x0201); /* v 1.02 */
 383     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
 384     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
 385     put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
 386     put_bits(p, 8, 0); /* thumbnail width */
 387     put_bits(p, 8, 0); /* thumbnail height */
 388     }
 389
 390     /* comment */
 391     if(!(s->flags & CODEC_FLAG_BITEXACT)){
 392         put_marker(p, COM);
 393         flush_put_bits(p);
 394         ptr = pbBufPtr(p);
 395         put_bits(p, 16, 0); /* patched later */
 396         put_string(p, LIBAVCODEC_IDENT);
 397         size = strlen(LIBAVCODEC_IDENT)+3;
 398         ptr[0] = size >> 8;
 399         ptr[1] = size;
 400     }
 401 }
 402
 403 void mjpeg_picture_header(MpegEncContext *s)
 404 {
 405     const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
 406
 407     put_marker(&s->pb, SOI);
 408
 409     if (!s->mjpeg_data_only_frames)
 410     {
 411     jpeg_put_comments(s);
 412
 413     if (s->mjpeg_write_tables) jpeg_table_header(s);
 414
 415     put_marker(&s->pb, lossless ? SOF3 : SOF0);
 416
 417     put_bits(&s->pb, 16, 17);
 418     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
 419         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
 420     else
 421         put_bits(&s->pb, 8, 8); /* 8 bits/component */
 422     put_bits(&s->pb, 16, s->height);
 423     put_bits(&s->pb, 16, s->width);
 424     put_bits(&s->pb, 8, 3); /* 3 components */
 425
 426     /* Y component */
 427     put_bits(&s->pb, 8, 1); /* component number */
 428     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
 429     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
 430     put_bits(&s->pb, 8, 0); /* select matrix */
 431
 432     /* Cb component */
 433     put_bits(&s->pb, 8, 2); /* component number */
 434     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
 435     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 436 #ifdef TWOMATRIXES
 437     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 438 #else
 439     put_bits(&s->pb, 8, 0); /* select matrix */
 440 #endif
 441
 442     /* Cr component */
 443     put_bits(&s->pb, 8, 3); /* component number */
 444     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
 445     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 446 #ifdef TWOMATRIXES
 447     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 448 #else
 449     put_bits(&s->pb, 8, 0); /* select matrix */
 450 #endif
 451     }
 452
 453     /* scan header */
 454     put_marker(&s->pb, SOS);
 455     put_bits(&s->pb, 16, 12); /* length */
 456     put_bits(&s->pb, 8, 3); /* 3 components */
 457
 458     /* Y component */
 459     put_bits(&s->pb, 8, 1); /* index */
 460     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 461     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 462
 463     /* Cb component */
 464     put_bits(&s->pb, 8, 2); /* index */
 465     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 466     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 467
 468     /* Cr component */
 469     put_bits(&s->pb, 8, 3); /* index */
 470     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 471     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 472
 473     put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
 474     put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
 475     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 476 }
 477
 478 static void escape_FF(MpegEncContext *s, int start)
 479 {
 480     int size= get_bit_count(&s->pb) - start*8;
 481     int i, ff_count;
 482     uint8_t *buf= s->pb.buf + start;
 483     int align= (-(size_t)(buf))&3;
 484
 485     assert((size&7) == 0);
 486     size >>= 3;
 487
 488     ff_count=0;
 489     for(i=0; i<size && i<align; i++){
 490         if(buf[i]==0xFF) ff_count++;
 491     }
 492     for(; i<size-15; i+=16){
 493         int acc, v;
 494
 495         v= *(uint32_t*)(&buf[i]);
 496         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 497         v= *(uint32_t*)(&buf[i+4]);
 498         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 499         v= *(uint32_t*)(&buf[i+8]);
 500         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 501         v= *(uint32_t*)(&buf[i+12]);
 502         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 503
 504         acc>>=4;
 505         acc+= (acc>>16);
 506         acc+= (acc>>8);
 507         ff_count+= acc&0xFF;
 508     }
 509     for(; i<size; i++){
 510         if(buf[i]==0xFF) ff_count++;
 511     }
 512
 513     if(ff_count==0) return;
 514
 515     /* skip put bits */
 516     for(i=0; i<ff_count-3; i+=4)
 517         put_bits(&s->pb, 32, 0);
 518     put_bits(&s->pb, (ff_count-i)*8, 0);
 519     flush_put_bits(&s->pb);
 520
 521     for(i=size-1; ff_count; i--){
 522         int v= buf[i];
 523
 524         if(v==0xFF){
 525 //printf("%d %d\n", i, ff_count);
 526             buf[i+ff_count]= 0;
 527             ff_count--;
 528         }
 529
 530         buf[i+ff_count]= v;
 531     }
 532 }
 533
 534 void mjpeg_picture_trailer(MpegEncContext *s)
 535 {
 536     int pad= (-get_bit_count(&s->pb))&7;
 537
 538     put_bits(&s->pb, pad,0xFF>>(8-pad));
 539     flush_put_bits(&s->pb);
 540
 541     assert((s->header_bits&7)==0);
 542
 543     escape_FF(s, s->header_bits>>3);
 544
 545     put_marker(&s->pb, EOI);
 546 }
 547
 548 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 549                                    uint8_t *huff_size, uint16_t *huff_code)
 550 {
 551     int mant, nbits;
 552
 553     if (val == 0) {
 554         put_bits(&s->pb, huff_size[0], huff_code[0]);
 555     } else {
 556         mant = val;
 557         if (val < 0) {
 558             val = -val;
 559             mant--;
 560         }
 561
 562         nbits= av_log2_16bit(val) + 1;
 563
 564         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 565
 566         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 567     }
 568 }
 569
 570 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 571 {
 572     int mant, nbits, code, i, j;
 573     int component, dc, run, last_index, val;
 574     MJpegContext *m = s->mjpeg_ctx;
 575     uint8_t *huff_size_ac;
 576     uint16_t *huff_code_ac;
 577
 578     /* DC coef */
 579     component = (n <= 3 ? 0 : n - 4 + 1);
 580     dc = block[0]; /* overflow is impossible */
 581     val = dc - s->last_dc[component];
 582     if (n < 4) {
 583         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 584         huff_size_ac = m->huff_size_ac_luminance;
 585         huff_code_ac = m->huff_code_ac_luminance;
 586     } else {
 587         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 588         huff_size_ac = m->huff_size_ac_chrominance;
 589         huff_code_ac = m->huff_code_ac_chrominance;
 590     }
 591     s->last_dc[component] = dc;
 592
 593     /* AC coefs */
 594
 595     run = 0;
 596     last_index = s->block_last_index[n];
 597     for(i=1;i<=last_index;i++) {
 598         j = s->intra_scantable.permutated[i];
 599         val = block[j];
 600         if (val == 0) {
 601             run++;
 602         } else {
 603             while (run >= 16) {
 604                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 605                 run -= 16;
 606             }
 607             mant = val;
 608             if (val < 0) {
 609                 val = -val;
 610                 mant--;
 611             }
 612
 613             nbits= av_log2(val) + 1;
 614             code = (run << 4) | nbits;
 615
 616             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 617
 618             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 619             run = 0;
 620         }
 621     }
 622
 623     /* output EOB only if not already 64 values */
 624     if (last_index < 63 || run != 0)
 625         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 626 }
 627
 628 void mjpeg_encode_mb(MpegEncContext *s,
 629                      DCTELEM block[6][64])
 630 {
 631     int i;
 632     for(i=0;i<6;i++) {
 633         encode_block(s, block[i], i);
 634     }
 635 }
 636
 637 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 638     MpegEncContext * const s = avctx->priv_data;
 639     MJpegContext * const m = s->mjpeg_ctx;
 640     AVFrame *pict = data;
 641     const int width= s->width;
 642     const int height= s->height;
 643     AVFrame * const p= (AVFrame*)&s->current_picture;
 644     const int predictor= avctx->prediction_method+1;
 645
 646     init_put_bits(&s->pb, buf, buf_size);
 647
 648     *p = *pict;
 649     p->pict_type= FF_I_TYPE;
 650     p->key_frame= 1;
 651
 652     mjpeg_picture_header(s);
 653
 654     s->header_bits= get_bit_count(&s->pb);
 655
 656     if(avctx->pix_fmt == PIX_FMT_RGBA32){
 657         int x, y, i;
 658         const int linesize= p->linesize[0];
 659         uint16_t buffer[2048][4];
 660         int left[3], top[3], topleft[3];
 661
 662         for(i=0; i<3; i++){
 663             buffer[0][i]= 1 << (9 - 1);
 664         }
 665
 666         for(y = 0; y < height; y++) {
 667             const int modified_predictor= y ? predictor : 1;
 668             uint8_t *ptr = p->data[0] + (linesize * y);
 669
 670             for(i=0; i<3; i++){
 671                 top[i]= left[i]= topleft[i]= buffer[0][i];
 672             }
 673             for(x = 0; x < width; x++) {
 674                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
 675                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
 676                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
 677
 678                 for(i=0;i<3;i++) {
 679                     int pred, diff;
 680
 681                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
 682
 683                     topleft[i]= top[i];
 684                     top[i]= buffer[x+1][i];
 685
 686                     left[i]= buffer[x][i];
 687
 688                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
 689
 690                     if(i==0)
 691                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 692                     else
 693                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 694                 }
 695             }
 696         }
 697     }else{
 698         int mb_x, mb_y, i;
 699         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
 700         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
 701
 702         for(mb_y = 0; mb_y < mb_height; mb_y++) {
 703             for(mb_x = 0; mb_x < mb_width; mb_x++) {
 704                 if(mb_x==0 || mb_y==0){
 705                     for(i=0;i<3;i++) {
 706                         uint8_t *ptr;
 707                         int x, y, h, v, linesize;
 708                         h = s->mjpeg_hsample[i];
 709                         v = s->mjpeg_vsample[i];
 710                         linesize= p->linesize[i];
 711
 712                         for(y=0; y<v; y++){
 713                             for(x=0; x<h; x++){
 714                                 int pred;
 715
 716                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 717                                 if(y==0 && mb_y==0){
 718                                     if(x==0 && mb_x==0){
 719                                         pred= 128;
 720                                     }else{
 721                                         pred= ptr[-1];
 722                                     }
 723                                 }else{
 724                                     if(x==0 && mb_x==0){
 725                                         pred= ptr[-linesize];
 726                                     }else{
 727                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 728                                     }
 729                                 }
 730
 731                                 if(i==0)
 732                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 733                                 else
 734                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 735                             }
 736                         }
 737                     }
 738                 }else{
 739                     for(i=0;i<3;i++) {
 740                         uint8_t *ptr;
 741                         int x, y, h, v, linesize;
 742                         h = s->mjpeg_hsample[i];
 743                         v = s->mjpeg_vsample[i];
 744                         linesize= p->linesize[i];
 745
 746                         for(y=0; y<v; y++){
 747                             for(x=0; x<h; x++){
 748                                 int pred;
 749
 750                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 751 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
 752                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 753
 754                                 if(i==0)
 755                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 756                                 else
 757                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 758                             }
 759                         }
 760                     }
 761                 }
 762             }
 763         }
 764     }
 765
 766     emms_c();
 767
 768     mjpeg_picture_trailer(s);
 769     s->picture_number++;
 770
 771     flush_put_bits(&s->pb);
 772     return pbBufPtr(&s->pb) - s->pb.buf;
 773 //    return (get_bit_count(&f->pb)+7)/8;
 774 }
 775
 776 #endif //CONFIG_ENCODERS
 777
 778 /******************************************/
 779 /* decoding */
 780
 781 #define MAX_COMPONENTS 4
 782
 783 typedef struct MJpegDecodeContext {
 784     AVCodecContext *avctx;
 785     GetBitContext gb;
 786     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 787
 788     int start_code; /* current start code */
 789     int buffer_size;
 790     uint8_t *buffer;
 791
 792     int16_t quant_matrixes[4][64];
 793     VLC vlcs[2][4];
 794     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
 795
 796     int org_height;  /* size given at codec init */
 797     int first_picture;    /* true if decoding first picture */
 798     int interlaced;     /* true if interlaced */
 799     int bottom_field;   /* true if bottom field */
 800     int lossless;
 801     int rgb;
 802     int rct;            /* standard rct */
 803     int pegasus_rct;    /* pegasus reversible colorspace transform */
 804     int bits;           /* bits per component */
 805
 806     int width, height;
 807     int mb_width, mb_height;
 808     int nb_components;
 809     int component_id[MAX_COMPONENTS];
 810     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 811     int v_count[MAX_COMPONENTS];
 812     int comp_index[MAX_COMPONENTS];
 813     int dc_index[MAX_COMPONENTS];
 814     int ac_index[MAX_COMPONENTS];
 815     int nb_blocks[MAX_COMPONENTS];
 816     int h_scount[MAX_COMPONENTS];
 817     int v_scount[MAX_COMPONENTS];
 818     int h_max, v_max; /* maximum h and v counts */
 819     int quant_index[4];   /* quant table index for each component */
 820     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 821     AVFrame picture; /* picture structure */
 822     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
 823     uint8_t *qscale_table;
 824     DCTELEM block[64] __align8;
 825     ScanTable scantable;
 826     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 827
 828     int restart_interval;
 829     int restart_count;
 830
 831     int buggy_avid;
 832     int interlace_polarity;
 833 } MJpegDecodeContext;
 834
 835 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 836
 837 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
 838                       int nb_codes)
 839 {
 840     uint8_t huff_size[256];
 841     uint16_t huff_code[256];
 842
 843     memset(huff_size, 0, sizeof(huff_size));
 844     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 845
 846     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 847 }
 848
 849 static int mjpeg_decode_init(AVCodecContext *avctx)
 850 {
 851     MJpegDecodeContext *s = avctx->priv_data;
 852     MpegEncContext s2;
 853
 854     s->avctx = avctx;
 855
 856     /* ugly way to get the idct & scantable FIXME */
 857     memset(&s2, 0, sizeof(MpegEncContext));
 858     s2.avctx= avctx;
 859 //    s2->out_format = FMT_MJPEG;
 860     s2.width = 8;
 861     s2.height = 8;
 862     if (MPV_common_init(&s2) < 0)
 863        return -1;
 864     s->scantable= s2.intra_scantable;
 865     s->idct_put= s2.dsp.idct_put;
 866     MPV_common_end(&s2);
 867
 868     s->mpeg_enc_ctx_allocated = 0;
 869     s->buffer_size = 102400; /* smaller buffer should be enough,
 870                                 but photojpg files could ahive bigger sizes */
 871     s->buffer = av_malloc(s->buffer_size);
 872     if (!s->buffer)
 873         return -1;
 874     s->start_code = -1;
 875     s->first_picture = 1;
 876     s->org_height = avctx->height;
 877
 878     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 879     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 880     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 881     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 882
 883     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 884     {
 885         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
 886         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 887         mjpeg_decode_dht(s);
 888         /* should check for error - but dunno */
 889     }
 890
 891     return 0;
 892 }
 893
 894 /* quantize tables */
 895 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 896 {
 897     int len, index, i, j;
 898
 899     len = get_bits(&s->gb, 16) - 2;
 900
 901     while (len >= 65) {
 902         /* only 8 bit precision handled */
 903         if (get_bits(&s->gb, 4) != 0)
 904         {
 905             dprintf("dqt: 16bit precision\n");
 906             return -1;
 907         }
 908         index = get_bits(&s->gb, 4);
 909         if (index >= 4)
 910             return -1;
 911         dprintf("index=%d\n", index);
 912         /* read quant table */
 913         for(i=0;i<64;i++) {
 914             j = s->scantable.permutated[i];
 915             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 916         }
 917
 918         //XXX FIXME finetune, and perhaps add dc too
 919         s->qscale[index]= FFMAX(
 920             s->quant_matrixes[index][s->scantable.permutated[1]],
 921             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
 922         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
 923         len -= 65;
 924     }
 925
 926     return 0;
 927 }
 928
 929 /* decode huffman tables and build VLC decoders */
 930 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 931 {
 932     int len, index, i, class, n, v, code_max;
 933     uint8_t bits_table[17];
 934     uint8_t val_table[256];
 935
 936     len = get_bits(&s->gb, 16) - 2;
 937
 938     while (len > 0) {
 939         if (len < 17)
 940             return -1;
 941         class = get_bits(&s->gb, 4);
 942         if (class >= 2)
 943             return -1;
 944         index = get_bits(&s->gb, 4);
 945         if (index >= 4)
 946             return -1;
 947         n = 0;
 948         for(i=1;i<=16;i++) {
 949             bits_table[i] = get_bits(&s->gb, 8);
 950             n += bits_table[i];
 951         }
 952         len -= 17;
 953         if (len < n || n > 256)
 954             return -1;
 955
 956         code_max = 0;
 957         for(i=0;i<n;i++) {
 958             v = get_bits(&s->gb, 8);
 959             if (v > code_max)
 960                 code_max = v;
 961             val_table[i] = v;
 962         }
 963         len -= n;
 964
 965         /* build VLC and flush previous vlc if present */
 966         free_vlc(&s->vlcs[class][index]);
 967         dprintf("class=%d index=%d nb_codes=%d\n",
 968                class, index, code_max + 1);
 969         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
 970             return -1;
 971         }
 972     }
 973     return 0;
 974 }
 975
 976 static int mjpeg_decode_sof(MJpegDecodeContext *s)
 977 {
 978     int len, nb_components, i, width, height;
 979
 980     /* XXX: verify len field validity */
 981     len = get_bits(&s->gb, 16);
 982     s->bits= get_bits(&s->gb, 8);
 983
 984     if(s->pegasus_rct) s->bits=9;
 985     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
 986
 987     if (s->bits != 8 && !s->lossless){
 988         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
 989         return -1;
 990     }
 991     height = get_bits(&s->gb, 16);
 992     width = get_bits(&s->gb, 16);
 993     dprintf("sof0: picture: %dx%d\n", width, height);
 994
 995     nb_components = get_bits(&s->gb, 8);
 996     if (nb_components <= 0 ||
 997         nb_components > MAX_COMPONENTS)
 998         return -1;
 999     s->nb_components = nb_components;
1000     s->h_max = 1;
1001     s->v_max = 1;
1002     for(i=0;i<nb_components;i++) {
1003         /* component id */
1004         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1005         s->h_count[i] = get_bits(&s->gb, 4);
1006         s->v_count[i] = get_bits(&s->gb, 4);
1007         /* compute hmax and vmax (only used in interleaved case) */
1008         if (s->h_count[i] > s->h_max)
1009             s->h_max = s->h_count[i];
1010         if (s->v_count[i] > s->v_max)
1011             s->v_max = s->v_count[i];
1012         s->quant_index[i] = get_bits(&s->gb, 8);
1013         if (s->quant_index[i] >= 4)
1014             return -1;
1015         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1016             s->v_count[i], s->component_id[i], s->quant_index[i]);
1017     }
1018
1019     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1020
1021     /* if different size, realloc/alloc picture */
1022     /* XXX: also check h_count and v_count */
1023     if (width != s->width || height != s->height) {
1024         av_freep(&s->qscale_table);
1025
1026         s->width = width;
1027         s->height = height;
1028         s->avctx->width = s->width;
1029         s->avctx->height = s->height;
1030
1031         /* test interlaced mode */
1032         if (s->first_picture &&
1033             s->org_height != 0 &&
1034             s->height < ((s->org_height * 3) / 4)) {
1035             s->interlaced = 1;
1036 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1037             s->bottom_field = 0;
1038             s->avctx->height *= 2;
1039         }
1040
1041         s->qscale_table= av_mallocz((s->width+15)/16);
1042
1043         s->first_picture = 0;
1044     }
1045
1046     if(s->interlaced && s->bottom_field)
1047         return 0;
1048
1049     /* XXX: not complete test ! */
1050     switch((s->h_count[0] << 4) | s->v_count[0]) {
1051     case 0x11:
1052         if(s->rgb){
1053             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1054         }else if(s->nb_components==3)
1055             s->avctx->pix_fmt = PIX_FMT_YUV444P;
1056         else
1057             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1058         break;
1059     case 0x21:
1060         s->avctx->pix_fmt = PIX_FMT_YUV422P;
1061         break;
1062     default:
1063     case 0x22:
1064         s->avctx->pix_fmt = PIX_FMT_YUV420P;
1065         break;
1066     }
1067
1068     if(s->picture.data[0])
1069         s->avctx->release_buffer(s->avctx, &s->picture);
1070
1071     s->picture.reference= 0;
1072     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1073         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1074         return -1;
1075     }
1076     s->picture.pict_type= I_TYPE;
1077     s->picture.key_frame= 1;
1078
1079     for(i=0; i<3; i++){
1080         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1081     }
1082
1083 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1084
1085     if (len != (8+(3*nb_components)))
1086     {
1087         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1088     }
1089
1090     return 0;
1091 }
1092
1093 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1094 {
1095     int code;
1096     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1097     if (code < 0)
1098     {
1099         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1100                 &s->vlcs[0][dc_index]);
1101         return 0xffff;
1102     }
1103
1104     if(code)
1105         return get_xbits(&s->gb, code);
1106     else
1107         return 0;
1108 }
1109
1110 /* decode block and dequantize */
1111 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1112                         int component, int dc_index, int ac_index, int quant_index)
1113 {
1114     int code, i, j, level, val;
1115     VLC *ac_vlc;
1116     int16_t *quant_matrix;
1117
1118     /* DC coef */
1119     val = mjpeg_decode_dc(s, dc_index);
1120     if (val == 0xffff) {
1121         dprintf("error dc\n");
1122         return -1;
1123     }
1124     quant_matrix = s->quant_matrixes[quant_index];
1125     val = val * quant_matrix[0] + s->last_dc[component];
1126     s->last_dc[component] = val;
1127     block[0] = val;
1128     /* AC coefs */
1129     ac_vlc = &s->vlcs[1][ac_index];
1130     i = 1;
1131     for(;;) {
1132         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1133
1134         if (code < 0) {
1135             dprintf("error ac\n");
1136             return -1;
1137         }
1138         /* EOB */
1139         if (code == 0)
1140             break;
1141         if (code == 0xf0) {
1142             i += 16;
1143         } else {
1144             level = get_xbits(&s->gb, code & 0xf);
1145             i += code >> 4;
1146             if (i >= 64) {
1147                 dprintf("error count: %d\n", i);
1148                 return -1;
1149             }
1150             j = s->scantable.permutated[i];
1151             block[j] = level * quant_matrix[j];
1152             i++;
1153             if (i >= 64)
1154                 break;
1155         }
1156     }
1157     return 0;
1158 }
1159
1160 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1161     int i, mb_x, mb_y;
1162     uint16_t buffer[2048][4];
1163     int left[3], top[3], topleft[3];
1164     const int linesize= s->linesize[0];
1165     const int mask= (1<<s->bits)-1;
1166
1167     for(i=0; i<3; i++){
1168         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1169     }
1170     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1171         const int modified_predictor= mb_y ? predictor : 1;
1172         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1173
1174         if (s->interlaced && s->bottom_field)
1175             ptr += linesize >> 1;
1176
1177         for(i=0; i<3; i++){
1178             top[i]= left[i]= topleft[i]= buffer[0][i];
1179         }
1180         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1181             if (s->restart_interval && !s->restart_count)
1182                 s->restart_count = s->restart_interval;
1183
1184             for(i=0;i<3;i++) {
1185                 int pred;
1186
1187                 topleft[i]= top[i];
1188                 top[i]= buffer[mb_x][i];
1189
1190                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1191
1192                 left[i]=
1193                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1194             }
1195
1196             if (s->restart_interval && !--s->restart_count) {
1197                 align_get_bits(&s->gb);
1198                 skip_bits(&s->gb, 16); /* skip RSTn */
1199             }
1200         }
1201
1202         if(s->rct){
1203             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1204                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1205                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1206                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1207             }
1208         }else if(s->pegasus_rct){
1209             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1210                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1211                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1212                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1213             }
1214         }else{
1215             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1216                 ptr[4*mb_x+0] = buffer[mb_x][0];
1217                 ptr[4*mb_x+1] = buffer[mb_x][1];
1218                 ptr[4*mb_x+2] = buffer[mb_x][2];
1219             }
1220         }
1221     }
1222     return 0;
1223 }
1224
1225 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1226     int i, mb_x, mb_y;
1227     const int nb_components=3;
1228
1229     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1230         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1231             if (s->restart_interval && !s->restart_count)
1232                 s->restart_count = s->restart_interval;
1233
1234             if(mb_x==0 || mb_y==0 || s->interlaced){
1235                 for(i=0;i<nb_components;i++) {
1236                     uint8_t *ptr;
1237                     int n, h, v, x, y, c, j, linesize;
1238                     n = s->nb_blocks[i];
1239                     c = s->comp_index[i];
1240                     h = s->h_scount[i];
1241                     v = s->v_scount[i];
1242                     x = 0;
1243                     y = 0;
1244                     linesize= s->linesize[c];
1245
1246                     for(j=0; j<n; j++) {
1247                         int pred;
1248
1249                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1250                         if(y==0 && mb_y==0){
1251                             if(x==0 && mb_x==0){
1252                                 pred= 128 << point_transform;
1253                             }else{
1254                                 pred= ptr[-1];
1255                             }
1256                         }else{
1257                             if(x==0 && mb_x==0){
1258                                 pred= ptr[-linesize];
1259                             }else{
1260                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1261                             }
1262                         }
1263
1264                         if (s->interlaced && s->bottom_field)
1265                             ptr += linesize >> 1;
1266                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1267
1268                         if (++x == h) {
1269                             x = 0;
1270                             y++;
1271                         }
1272                     }
1273                 }
1274             }else{
1275                 for(i=0;i<nb_components;i++) {
1276                     uint8_t *ptr;
1277                     int n, h, v, x, y, c, j, linesize;
1278                     n = s->nb_blocks[i];
1279                     c = s->comp_index[i];
1280                     h = s->h_scount[i];
1281                     v = s->v_scount[i];
1282                     x = 0;
1283                     y = 0;
1284                     linesize= s->linesize[c];
1285
1286                     for(j=0; j<n; j++) {
1287                         int pred;
1288
1289                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1290                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1291                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1292                         if (++x == h) {
1293                             x = 0;
1294                             y++;
1295                         }
1296                     }
1297                 }
1298             }
1299             if (s->restart_interval && !--s->restart_count) {
1300                 align_get_bits(&s->gb);
1301                 skip_bits(&s->gb, 16); /* skip RSTn */
1302             }
1303         }
1304     }
1305     return 0;
1306 }
1307
1308 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1309     int i, mb_x, mb_y;
1310     const int nb_components=3;
1311
1312     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1313         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1314             if (s->restart_interval && !s->restart_count)
1315                 s->restart_count = s->restart_interval;
1316
1317             for(i=0;i<nb_components;i++) {
1318                 uint8_t *ptr;
1319                 int n, h, v, x, y, c, j;
1320                 n = s->nb_blocks[i];
1321                 c = s->comp_index[i];
1322                 h = s->h_scount[i];
1323                 v = s->v_scount[i];
1324                 x = 0;
1325                 y = 0;
1326                 for(j=0;j<n;j++) {
1327                     memset(s->block, 0, sizeof(s->block));
1328                     if (decode_block(s, s->block, i,
1329                                      s->dc_index[i], s->ac_index[i],
1330                                      s->quant_index[c]) < 0) {
1331                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1332                         return -1;
1333                     }
1334 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1335                     ptr = s->picture.data[c] +
1336                         (s->linesize[c] * (v * mb_y + y) * 8) +
1337                         (h * mb_x + x) * 8;
1338                     if (s->interlaced && s->bottom_field)
1339                         ptr += s->linesize[c] >> 1;
1340 //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);
1341                     s->idct_put(ptr, s->linesize[c], s->block);
1342                     if (++x == h) {
1343                         x = 0;
1344                         y++;
1345                     }
1346                 }
1347             }
1348             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1349             if (s->restart_interval && (s->restart_interval < 1350) &&
1350                 !--s->restart_count) {
1351                 align_get_bits(&s->gb);
1352                 skip_bits(&s->gb, 16); /* skip RSTn */
1353                 for (i=0; i<nb_components; i++) /* reset dc */
1354                     s->last_dc[i] = 1024;
1355             }
1356         }
1357     }
1358     return 0;
1359 }
1360
1361 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1362 {
1363     int len, nb_components, i, h, v, predictor, point_transform;
1364     int vmax, hmax, index, id;
1365     const int block_size= s->lossless ? 1 : 8;
1366
1367     /* XXX: verify len field validity */
1368     len = get_bits(&s->gb, 16);
1369     nb_components = get_bits(&s->gb, 8);
1370     if (len != 6+2*nb_components)
1371     {
1372         dprintf("decode_sos: invalid len (%d)\n", len);
1373         return -1;
1374     }
1375     /* XXX: only interleaved scan accepted */
1376     if (nb_components != s->nb_components)
1377     {
1378         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1379         return -1;
1380     }
1381     vmax = 0;
1382     hmax = 0;
1383     for(i=0;i<nb_components;i++) {
1384         id = get_bits(&s->gb, 8) - 1;
1385         dprintf("component: %d\n", id);
1386         /* find component index */
1387         for(index=0;index<s->nb_components;index++)
1388             if (id == s->component_id[index])
1389                 break;
1390         if (index == s->nb_components)
1391         {
1392             dprintf("decode_sos: index(%d) out of components\n", index);
1393             return -1;
1394         }
1395
1396         s->comp_index[i] = index;
1397
1398         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1399         s->h_scount[i] = s->h_count[index];
1400         s->v_scount[i] = s->v_count[index];
1401
1402         s->dc_index[i] = get_bits(&s->gb, 4);
1403         s->ac_index[i] = get_bits(&s->gb, 4);
1404
1405         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1406             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1407             goto out_of_range;
1408 #if 0 //buggy
1409         switch(s->start_code)
1410         {
1411             case SOF0:
1412                 if (dc_index[i] > 1 || ac_index[i] > 1)
1413                     goto out_of_range;
1414                 break;
1415             case SOF1:
1416             case SOF2:
1417                 if (dc_index[i] > 3 || ac_index[i] > 3)
1418                     goto out_of_range;
1419                 break;
1420             case SOF3:
1421                 if (dc_index[i] > 3 || ac_index[i] != 0)
1422                     goto out_of_range;
1423                 break;
1424         }
1425 #endif
1426     }
1427
1428     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1429     skip_bits(&s->gb, 8); /* Se */
1430     skip_bits(&s->gb, 4); /* Ah */
1431     point_transform= get_bits(&s->gb, 4); /* Al */
1432
1433     for(i=0;i<nb_components;i++)
1434         s->last_dc[i] = 1024;
1435
1436     if (nb_components > 1) {
1437         /* interleaved stream */
1438         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1439         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1440     } else {
1441         h = s->h_max / s->h_scount[s->comp_index[0]];
1442         v = s->v_max / s->v_scount[s->comp_index[0]];
1443         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1444         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1445         s->nb_blocks[0] = 1;
1446         s->h_scount[0] = 1;
1447         s->v_scount[0] = 1;
1448     }
1449
1450     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1451         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1452
1453     if(s->lossless){
1454             if(s->rgb){
1455                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1456                     return -1;
1457             }else{
1458                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1459                     return -1;
1460             }
1461     }else{
1462         if(mjpeg_decode_scan(s) < 0)
1463             return -1;
1464     }
1465     emms_c();
1466     return 0;
1467  out_of_range:
1468     dprintf("decode_sos: ac/dc index out of range\n");
1469     return -1;
1470 }
1471
1472 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1473 {
1474     if (get_bits(&s->gb, 16) != 4)
1475         return -1;
1476     s->restart_interval = get_bits(&s->gb, 16);
1477     dprintf("restart interval: %d\n", s->restart_interval);
1478
1479     return 0;
1480 }
1481
1482 static int mjpeg_decode_app(MJpegDecodeContext *s)
1483 {
1484     int len, id;
1485
1486     /* XXX: verify len field validity */
1487     len = get_bits(&s->gb, 16);
1488     if (len < 5)
1489         return -1;
1490
1491     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1492     id = be2me_32(id);
1493     len -= 6;
1494
1495     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1496         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1497     }
1498
1499     /* buggy AVID, it puts EOI only at every 10th frame */
1500     /* also this fourcc is used by non-avid files too, it holds some
1501        informations, but it's always present in AVID creates files */
1502     if (id == ff_get_fourcc("AVI1"))
1503     {
1504         /* structure:
1505             4bytes      AVI1
1506             1bytes      polarity
1507             1bytes      always zero
1508             4bytes      field_size
1509             4bytes      field_size_less_padding
1510         */
1511         s->buggy_avid = 1;
1512 //      if (s->first_picture)
1513 //          printf("mjpeg: workarounding buggy AVID\n");
1514         s->interlace_polarity = get_bits(&s->gb, 8);
1515 #if 0
1516         skip_bits(&s->gb, 8);
1517         skip_bits(&s->gb, 32);
1518         skip_bits(&s->gb, 32);
1519         len -= 10;
1520 #endif
1521 //      if (s->interlace_polarity)
1522 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1523         goto out;
1524     }
1525
1526 //    len -= 2;
1527
1528     if (id == ff_get_fourcc("JFIF"))
1529     {
1530         int t_w, t_h;
1531         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1532         av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x)\n",
1533             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1534         skip_bits(&s->gb, 8);
1535
1536         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1537         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1538
1539         t_w = get_bits(&s->gb, 8);
1540         t_h = get_bits(&s->gb, 8);
1541         if (t_w && t_h)
1542         {
1543             /* skip thumbnail */
1544             if (len-10-(t_w*t_h*3) > 0)
1545                 len -= t_w*t_h*3;
1546         }
1547         len -= 10;
1548         goto out;
1549     }
1550
1551     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1552     {
1553         av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1554         skip_bits(&s->gb, 16); /* version */
1555         skip_bits(&s->gb, 16); /* flags0 */
1556         skip_bits(&s->gb, 16); /* flags1 */
1557         skip_bits(&s->gb, 8); /* transform */
1558         len -= 7;
1559         goto out;
1560     }
1561
1562     if (id == ff_get_fourcc("LJIF")){
1563         av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1564         skip_bits(&s->gb, 16); /* version ? */
1565         skip_bits(&s->gb, 16); /* unknwon always 0? */
1566         skip_bits(&s->gb, 16); /* unknwon always 0? */
1567         skip_bits(&s->gb, 16); /* unknwon always 0? */
1568         switch( get_bits(&s->gb, 8)){
1569         case 1:
1570             s->rgb= 1;
1571             s->pegasus_rct=0;
1572             break;
1573         case 2:
1574             s->rgb= 1;
1575             s->pegasus_rct=1;
1576             break;
1577         default:
1578             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1579         }
1580         len -= 9;
1581         goto out;
1582     }
1583
1584     /* Apple MJPEG-A */
1585     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1586     {
1587         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1588         id = be2me_32(id);
1589         len -= 4;
1590         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1591         {
1592 #if 0
1593             skip_bits(&s->gb, 32); /* field size */
1594             skip_bits(&s->gb, 32); /* pad field size */
1595             skip_bits(&s->gb, 32); /* next off */
1596             skip_bits(&s->gb, 32); /* quant off */
1597             skip_bits(&s->gb, 32); /* huff off */
1598             skip_bits(&s->gb, 32); /* image off */
1599             skip_bits(&s->gb, 32); /* scan off */
1600             skip_bits(&s->gb, 32); /* data off */
1601 #endif
1602             if (s->first_picture)
1603                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1604         }
1605     }
1606
1607 out:
1608     /* slow but needed for extreme adobe jpegs */
1609     if (len < 0)
1610         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1611     while(--len > 0)
1612         skip_bits(&s->gb, 8);
1613
1614     return 0;
1615 }
1616
1617 static int mjpeg_decode_com(MJpegDecodeContext *s)
1618 {
1619     /* XXX: verify len field validity */
1620     int len = get_bits(&s->gb, 16);
1621     if (len >= 2 && len < 32768) {
1622         /* XXX: any better upper bound */
1623         uint8_t *cbuf = av_malloc(len - 1);
1624         if (cbuf) {
1625             int i;
1626             for (i = 0; i < len - 2; i++)
1627                 cbuf[i] = get_bits(&s->gb, 8);
1628             if (i > 0 && cbuf[i-1] == '\n')
1629                 cbuf[i-1] = 0;
1630             else
1631                 cbuf[i] = 0;
1632
1633             av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1634
1635             /* buggy avid, it puts EOI only at every 10th frame */
1636             if (!strcmp(cbuf, "AVID"))
1637             {
1638                 s->buggy_avid = 1;
1639                 //      if (s->first_picture)
1640                 //          printf("mjpeg: workarounding buggy AVID\n");
1641             }
1642
1643             av_free(cbuf);
1644         }
1645     }
1646
1647     return 0;
1648 }
1649
1650 #if 0
1651 static int valid_marker_list[] =
1652 {
1653         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1654 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1655 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1656 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1657 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1658 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1659 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1660 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1661 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1662 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1663 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1664 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1665 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1666 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1667 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1668 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1669 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1670 }
1671 #endif
1672
1673 /* return the 8 bit start code value and update the search
1674    state. Return -1 if no start code found */
1675 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1676 {
1677     uint8_t *buf_ptr;
1678     unsigned int v, v2;
1679     int val;
1680 #ifdef DEBUG
1681     int skipped=0;
1682 #endif
1683
1684     buf_ptr = *pbuf_ptr;
1685     while (buf_ptr < buf_end) {
1686         v = *buf_ptr++;
1687         v2 = *buf_ptr;
1688         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1689             val = *buf_ptr++;
1690             goto found;
1691         }
1692 #ifdef DEBUG
1693         skipped++;
1694 #endif
1695     }
1696     val = -1;
1697 found:
1698 #ifdef DEBUG
1699     dprintf("find_marker skipped %d bytes\n", skipped);
1700 #endif
1701     *pbuf_ptr = buf_ptr;
1702     return val;
1703 }
1704
1705 static int mjpeg_decode_frame(AVCodecContext *avctx,
1706                               void *data, int *data_size,
1707                               uint8_t *buf, int buf_size)
1708 {
1709     MJpegDecodeContext *s = avctx->priv_data;
1710     uint8_t *buf_end, *buf_ptr;
1711     int start_code;
1712     AVFrame *picture = data;
1713
1714     *data_size = 0;
1715
1716     /* no supplementary picture */
1717     if (buf_size == 0)
1718         return 0;
1719
1720     buf_ptr = buf;
1721     buf_end = buf + buf_size;
1722     while (buf_ptr < buf_end) {
1723         /* find start next marker */
1724         start_code = find_marker(&buf_ptr, buf_end);
1725         {
1726             /* EOF */
1727             if (start_code < 0) {
1728                 goto the_end;
1729             } else {
1730                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1731
1732                 if ((buf_end - buf_ptr) > s->buffer_size)
1733                 {
1734                     av_free(s->buffer);
1735                     s->buffer_size = buf_end-buf_ptr;
1736                     s->buffer = av_malloc(s->buffer_size);
1737                     dprintf("buffer too small, expanding to %d bytes\n",
1738                         s->buffer_size);
1739                 }
1740
1741                 /* unescape buffer of SOS */
1742                 if (start_code == SOS)
1743                 {
1744                     uint8_t *src = buf_ptr;
1745                     uint8_t *dst = s->buffer;
1746
1747                     while (src<buf_end)
1748                     {
1749                         uint8_t x = *(src++);
1750
1751                         *(dst++) = x;
1752                         if (x == 0xff)
1753                         {
1754                             while(*src == 0xff) src++;
1755
1756                             x = *(src++);
1757                             if (x >= 0xd0 && x <= 0xd7)
1758                                 *(dst++) = x;
1759                             else if (x)
1760                                 break;
1761                         }
1762                     }
1763                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1764
1765                     dprintf("escaping removed %d bytes\n",
1766                         (buf_end - buf_ptr) - (dst - s->buffer));
1767                 }
1768                 else
1769                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1770
1771                 s->start_code = start_code;
1772                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1773                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1774                 }
1775
1776                 /* process markers */
1777                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1778                     dprintf("restart marker: %d\n", start_code&0x0f);
1779                 } else if (s->first_picture) {
1780                     /* APP fields */
1781                     if (start_code >= 0xe0 && start_code <= 0xef)
1782                         mjpeg_decode_app(s);
1783                     /* Comment */
1784                     else if (start_code == COM)
1785                         mjpeg_decode_com(s);
1786                 }
1787
1788                 switch(start_code) {
1789                 case SOI:
1790                     s->restart_interval = 0;
1791                     /* nothing to do on SOI */
1792                     break;
1793                 case DQT:
1794                     mjpeg_decode_dqt(s);
1795                     break;
1796                 case DHT:
1797                     if(mjpeg_decode_dht(s) < 0){
1798                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1799                         return -1;
1800                     }
1801                     break;
1802                 case SOF0:
1803                     s->lossless=0;
1804                     if (mjpeg_decode_sof(s) < 0)
1805                         return -1;
1806                     break;
1807                 case SOF3:
1808                     s->lossless=1;
1809                     if (mjpeg_decode_sof(s) < 0)
1810                         return -1;
1811                     break;
1812                 case EOI:
1813                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1814                         break;
1815 eoi_parser:
1816                     {
1817                         if (s->interlaced) {
1818                             s->bottom_field ^= 1;
1819                             /* if not bottom field, do not output image yet */
1820                             if (s->bottom_field)
1821                                 goto not_the_end;
1822                         }
1823                         *picture = s->picture;
1824                         *data_size = sizeof(AVFrame);
1825
1826                         if(!s->lossless){
1827                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1828                             picture->qstride= 0;
1829                             picture->qscale_table= s->qscale_table;
1830                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1831                             if(avctx->debug & FF_DEBUG_QP)
1832                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1833                             picture->quality*= FF_QP2LAMBDA;
1834                         }
1835
1836                         goto the_end;
1837                     }
1838                     break;
1839                 case SOS:
1840                     mjpeg_decode_sos(s);
1841                     /* buggy avid puts EOI every 10-20th frame */
1842                     /* if restart period is over process EOI */
1843                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1844                         goto eoi_parser;
1845                     break;
1846                 case DRI:
1847                     mjpeg_decode_dri(s);
1848                     break;
1849                 case SOF1:
1850                 case SOF2:
1851                 case SOF5:
1852                 case SOF6:
1853                 case SOF7:
1854                 case SOF9:
1855                 case SOF10:
1856                 case SOF11:
1857                 case SOF13:
1858                 case SOF14:
1859                 case SOF15:
1860                 case JPG:
1861                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1862                     break;
1863 //              default:
1864 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1865 //                  break;
1866                 }
1867
1868 not_the_end:
1869                 /* eof process start code */
1870                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1871                 dprintf("marker parser used %d bytes (%d bits)\n",
1872                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1873             }
1874         }
1875     }
1876 the_end:
1877     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1878 //    return buf_end - buf_ptr;
1879     return buf_ptr - buf;
1880 }
1881
1882 static int mjpegb_decode_frame(AVCodecContext *avctx,
1883                               void *data, int *data_size,
1884                               uint8_t *buf, int buf_size)
1885 {
1886     MJpegDecodeContext *s = avctx->priv_data;
1887     uint8_t *buf_end, *buf_ptr;
1888     AVFrame *picture = data;
1889     GetBitContext hgb; /* for the header */
1890     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1891     uint32_t field_size;
1892
1893     *data_size = 0;
1894
1895     /* no supplementary picture */
1896     if (buf_size == 0)
1897         return 0;
1898
1899     buf_ptr = buf;
1900     buf_end = buf + buf_size;
1901
1902 read_header:
1903     /* reset on every SOI */
1904     s->restart_interval = 0;
1905
1906     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1907
1908     skip_bits(&hgb, 32); /* reserved zeros */
1909
1910     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1911     {
1912         dprintf("not mjpeg-b (bad fourcc)\n");
1913         return 0;
1914     }
1915
1916     field_size = get_bits(&hgb, 32); /* field size */
1917     dprintf("field size: 0x%x\n", field_size);
1918     skip_bits(&hgb, 32); /* padded field size */
1919     second_field_offs = get_bits(&hgb, 32);
1920     dprintf("second field offs: 0x%x\n", second_field_offs);
1921     if (second_field_offs)
1922         s->interlaced = 1;
1923
1924     dqt_offs = get_bits(&hgb, 32);
1925     dprintf("dqt offs: 0x%x\n", dqt_offs);
1926     if (dqt_offs)
1927     {
1928         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1929         s->start_code = DQT;
1930         mjpeg_decode_dqt(s);
1931     }
1932
1933     dht_offs = get_bits(&hgb, 32);
1934     dprintf("dht offs: 0x%x\n", dht_offs);
1935     if (dht_offs)
1936     {
1937         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1938         s->start_code = DHT;
1939         mjpeg_decode_dht(s);
1940     }
1941
1942     sof_offs = get_bits(&hgb, 32);
1943     dprintf("sof offs: 0x%x\n", sof_offs);
1944     if (sof_offs)
1945     {
1946         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1947         s->start_code = SOF0;
1948         if (mjpeg_decode_sof(s) < 0)
1949             return -1;
1950     }
1951
1952     sos_offs = get_bits(&hgb, 32);
1953     dprintf("sos offs: 0x%x\n", sos_offs);
1954     if (sos_offs)
1955     {
1956 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1957         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1958         s->start_code = SOS;
1959         mjpeg_decode_sos(s);
1960     }
1961
1962     skip_bits(&hgb, 32); /* start of data offset */
1963
1964     if (s->interlaced) {
1965         s->bottom_field ^= 1;
1966         /* if not bottom field, do not output image yet */
1967         if (s->bottom_field && second_field_offs)
1968         {
1969             buf_ptr = buf + second_field_offs;
1970             second_field_offs = 0;
1971             goto read_header;
1972         }
1973     }
1974
1975     //XXX FIXME factorize, this looks very similar to the EOI code
1976
1977     *picture= s->picture;
1978     *data_size = sizeof(AVFrame);
1979
1980     if(!s->lossless){
1981         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1982         picture->qstride= 0;
1983         picture->qscale_table= s->qscale_table;
1984         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1985         if(avctx->debug & FF_DEBUG_QP)
1986             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1987         picture->quality*= FF_QP2LAMBDA;
1988     }
1989
1990     return buf_ptr - buf;
1991 }
1992
1993 #include "sp5x.h"
1994
1995 static int sp5x_decode_frame(AVCodecContext *avctx,
1996                               void *data, int *data_size,
1997                               uint8_t *buf, int buf_size)
1998 {
1999 #if 0
2000     MJpegDecodeContext *s = avctx->priv_data;
2001 #endif
2002     const int qscale = 5;
2003     uint8_t *buf_ptr, *buf_end, *recoded;
2004     int i = 0, j = 0;
2005
2006     *data_size = 0;
2007
2008     /* no supplementary picture */
2009     if (buf_size == 0)
2010         return 0;
2011
2012     if (!avctx->width || !avctx->height)
2013         return -1;
2014
2015     buf_ptr = buf;
2016     buf_end = buf + buf_size;
2017
2018 #if 1
2019     recoded = av_mallocz(buf_size + 1024);
2020     if (!recoded)
2021         return -1;
2022
2023     /* SOI */
2024     recoded[j++] = 0xFF;
2025     recoded[j++] = 0xD8;
2026
2027     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2028     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2029     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2030     j += sizeof(sp5x_data_dqt);
2031
2032     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2033     j += sizeof(sp5x_data_dht);
2034
2035     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2036     recoded[j+5] = (avctx->height >> 8) & 0xFF;
2037     recoded[j+6] = avctx->height & 0xFF;
2038     recoded[j+7] = (avctx->width >> 8) & 0xFF;
2039     recoded[j+8] = avctx->width & 0xFF;
2040     j += sizeof(sp5x_data_sof);
2041
2042     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2043     j += sizeof(sp5x_data_sos);
2044
2045     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2046     {
2047         recoded[j++] = buf[i];
2048         if (buf[i] == 0xff)
2049             recoded[j++] = 0;
2050     }
2051
2052     /* EOI */
2053     recoded[j++] = 0xFF;
2054     recoded[j++] = 0xD9;
2055
2056     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2057
2058     av_free(recoded);
2059
2060 #else
2061     /* SOF */
2062     s->bits = 8;
2063     s->width = avctx->width;
2064     s->height = avctx->height;
2065     s->nb_components = 3;
2066     s->component_id[0] = 0;
2067     s->h_count[0] = 2;
2068     s->v_count[0] = 2;
2069     s->quant_index[0] = 0;
2070     s->component_id[1] = 1;
2071     s->h_count[1] = 1;
2072     s->v_count[1] = 1;
2073     s->quant_index[1] = 1;
2074     s->component_id[2] = 2;
2075     s->h_count[2] = 1;
2076     s->v_count[2] = 1;
2077     s->quant_index[2] = 1;
2078     s->h_max = 2;
2079     s->v_max = 2;
2080
2081     s->qscale_table = av_mallocz((s->width+15)/16);
2082     avctx->pix_fmt = PIX_FMT_YUV420P;
2083     s->interlaced = 0;
2084
2085     s->picture.reference = 0;
2086     if (avctx->get_buffer(avctx, &s->picture) < 0)
2087     {
2088         fprintf(stderr, "get_buffer() failed\n");
2089         return -1;
2090     }
2091
2092     s->picture.pict_type = I_TYPE;
2093     s->picture.key_frame = 1;
2094
2095     for (i = 0; i < 3; i++)
2096         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2097
2098     /* DQT */
2099     for (i = 0; i < 64; i++)
2100     {
2101         j = s->scantable.permutated[i];
2102         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2103     }
2104     s->qscale[0] = FFMAX(
2105         s->quant_matrixes[0][s->scantable.permutated[1]],
2106         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2107
2108     for (i = 0; i < 64; i++)
2109     {
2110         j = s->scantable.permutated[i];
2111         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2112     }
2113     s->qscale[1] = FFMAX(
2114         s->quant_matrixes[1][s->scantable.permutated[1]],
2115         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2116
2117     /* DHT */
2118
2119     /* SOS */
2120     s->comp_index[0] = 0;
2121     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2122     s->h_scount[0] = s->h_count[0];
2123     s->v_scount[0] = s->v_count[0];
2124     s->dc_index[0] = 0;
2125     s->ac_index[0] = 0;
2126
2127     s->comp_index[1] = 1;
2128     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2129     s->h_scount[1] = s->h_count[1];
2130     s->v_scount[1] = s->v_count[1];
2131     s->dc_index[1] = 1;
2132     s->ac_index[1] = 1;
2133
2134     s->comp_index[2] = 2;
2135     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2136     s->h_scount[2] = s->h_count[2];
2137     s->v_scount[2] = s->v_count[2];
2138     s->dc_index[2] = 1;
2139     s->ac_index[2] = 1;
2140
2141     for (i = 0; i < 3; i++)
2142         s->last_dc[i] = 1024;
2143
2144     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2145     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2146
2147     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2148
2149     return mjpeg_decode_scan(s);
2150 #endif
2151
2152     return i;
2153 }
2154
2155 static int mjpeg_decode_end(AVCodecContext *avctx)
2156 {
2157     MJpegDecodeContext *s = avctx->priv_data;
2158     int i, j;
2159
2160     av_free(s->buffer);
2161     av_free(s->qscale_table);
2162     avcodec_default_free_buffers(avctx);
2163
2164     for(i=0;i<2;i++) {
2165         for(j=0;j<4;j++)
2166             free_vlc(&s->vlcs[i][j]);
2167     }
2168     return 0;
2169 }
2170
2171 AVCodec mjpeg_decoder = {
2172     "mjpeg",
2173     CODEC_TYPE_VIDEO,
2174     CODEC_ID_MJPEG,
2175     sizeof(MJpegDecodeContext),
2176     mjpeg_decode_init,
2177     NULL,
2178     mjpeg_decode_end,
2179     mjpeg_decode_frame,
2180     CODEC_CAP_DR1,
2181     NULL
2182 };
2183
2184 AVCodec mjpegb_decoder = {
2185     "mjpegb",
2186     CODEC_TYPE_VIDEO,
2187     CODEC_ID_MJPEGB,
2188     sizeof(MJpegDecodeContext),
2189     mjpeg_decode_init,
2190     NULL,
2191     mjpeg_decode_end,
2192     mjpegb_decode_frame,
2193     CODEC_CAP_DR1,
2194     NULL
2195 };
2196
2197 AVCodec sp5x_decoder = {
2198     "sp5x",
2199     CODEC_TYPE_VIDEO,
2200     CODEC_ID_SP5X,
2201     sizeof(MJpegDecodeContext),
2202     mjpeg_decode_init,
2203     NULL,
2204     mjpeg_decode_end,
2205     sp5x_decode_frame,
2206     CODEC_CAP_DR1,
2207     NULL
2208 };
2209
2210 #ifdef CONFIG_ENCODERS
2211 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2212     "ljpeg",
2213     CODEC_TYPE_VIDEO,
2214     CODEC_ID_LJPEG,
2215     sizeof(MpegEncContext),
2216     MPV_encode_init,
2217     encode_picture_lossless,
2218     MPV_encode_end,
2219 };
2220 #endif