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

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