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