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