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

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