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 and various fixes (AVID workaround) by
  20  *                                    Alex Beregszaszi <alex@naxine.org>
  21  */
  22 //#define DEBUG
  23 #include "avcodec.h"
  24 #include "dsputil.h"
  25 #include "mpegvideo.h"
  26
  27 #ifdef USE_FASTMEMCPY
  28 #include "fastmemcpy.h"
  29 #endif
  30
  31 /* use two quantizer table (one for luminance and one for chrominance) */
  32 /* not yet working */
  33 #undef TWOMATRIXES
  34
  35 typedef struct MJpegContext {
  36     UINT8 huff_size_dc_luminance[12];
  37     UINT16 huff_code_dc_luminance[12];
  38     UINT8 huff_size_dc_chrominance[12];
  39     UINT16 huff_code_dc_chrominance[12];
  40
  41     UINT8 huff_size_ac_luminance[256];
  42     UINT16 huff_code_ac_luminance[256];
  43     UINT8 huff_size_ac_chrominance[256];
  44     UINT16 huff_code_ac_chrominance[256];
  45 } MJpegContext;
  46
  47 /* JPEG marker codes */
  48 typedef enum {
  49     /* start of frame */
  50     SOF0  = 0xc0,       /* baseline */
  51     SOF1  = 0xc1,       /* extended sequential, huffman */
  52     SOF2  = 0xc2,       /* progressive, huffman */
  53     SOF3  = 0xc3,       /* lossless, huffman */
  54
  55     SOF5  = 0xc5,       /* differential sequential, huffman */
  56     SOF6  = 0xc6,       /* differential progressive, huffman */
  57     SOF7  = 0xc7,       /* differential lossless, huffman */
  58     JPG   = 0xc8,       /* reserved for JPEG extension */
  59     SOF9  = 0xc9,       /* extended sequential, arithmetic */
  60     SOF10 = 0xca,       /* progressive, arithmetic */
  61     SOF11 = 0xcb,       /* lossless, arithmetic */
  62
  63     SOF13 = 0xcd,       /* differential sequential, arithmetic */
  64     SOF14 = 0xce,       /* differential progressive, arithmetic */
  65     SOF15 = 0xcf,       /* differential lossless, arithmetic */
  66
  67     DHT   = 0xc4,       /* define huffman tables */
  68
  69     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
  70
  71     /* restart with modulo 8 count "m" */
  72     RST0  = 0xd0,
  73     RST1  = 0xd1,
  74     RST2  = 0xd2,
  75     RST3  = 0xd3,
  76     RST4  = 0xd4,
  77     RST5  = 0xd5,
  78     RST6  = 0xd6,
  79     RST7  = 0xd7,
  80
  81     SOI   = 0xd8,       /* start of image */
  82     EOI   = 0xd9,       /* end of image */
  83     SOS   = 0xda,       /* start of scan */
  84     DQT   = 0xdb,       /* define quantization tables */
  85     DNL   = 0xdc,       /* define number of lines */
  86     DRI   = 0xdd,       /* define restart interval */
  87     DHP   = 0xde,       /* define hierarchical progression */
  88     EXP   = 0xdf,       /* expand reference components */
  89
  90     APP0  = 0xe0,
  91     APP1  = 0xe1,
  92     APP2  = 0xe2,
  93     APP3  = 0xe3,
  94     APP4  = 0xe4,
  95     APP5  = 0xe5,
  96     APP6  = 0xe6,
  97     APP7  = 0xe7,
  98     APP8  = 0xe8,
  99     APP9  = 0xe9,
 100     APP10 = 0xea,
 101     APP11 = 0xeb,
 102     APP12 = 0xec,
 103     APP13 = 0xed,
 104     APP14 = 0xee,
 105     APP15 = 0xef,
 106
 107     JPG0  = 0xf0,
 108     JPG1  = 0xf1,
 109     JPG2  = 0xf2,
 110     JPG3  = 0xf3,
 111     JPG4  = 0xf4,
 112     JPG5  = 0xf5,
 113     JPG6  = 0xf6,
 114     JPG7  = 0xf7,
 115     JPG8  = 0xf8,
 116     JPG9  = 0xf9,
 117     JPG10 = 0xfa,
 118     JPG11 = 0xfb,
 119     JPG12 = 0xfc,
 120     JPG13 = 0xfd,
 121
 122     COM   = 0xfe,       /* comment */
 123
 124     TEM   = 0x01,       /* temporary private use for arithmetic coding */
 125
 126     /* 0x02 -> 0xbf reserved */
 127 } JPEG_MARKER;
 128
 129 #if 0
 130 /* These are the sample quantization tables given in JPEG spec section K.1.
 131  * The spec says that the values given produce "good" quality, and
 132  * when divided by 2, "very good" quality.
 133  */
 134 static const unsigned char std_luminance_quant_tbl[64] = {
 135     16,  11,  10,  16,  24,  40,  51,  61,
 136     12,  12,  14,  19,  26,  58,  60,  55,
 137     14,  13,  16,  24,  40,  57,  69,  56,
 138     14,  17,  22,  29,  51,  87,  80,  62,
 139     18,  22,  37,  56,  68, 109, 103,  77,
 140     24,  35,  55,  64,  81, 104, 113,  92,
 141     49,  64,  78,  87, 103, 121, 120, 101,
 142     72,  92,  95,  98, 112, 100, 103,  99
 143 };
 144 static const unsigned char std_chrominance_quant_tbl[64] = {
 145     17,  18,  24,  47,  99,  99,  99,  99,
 146     18,  21,  26,  66,  99,  99,  99,  99,
 147     24,  26,  56,  99,  99,  99,  99,  99,
 148     47,  66,  99,  99,  99,  99,  99,  99,
 149     99,  99,  99,  99,  99,  99,  99,  99,
 150     99,  99,  99,  99,  99,  99,  99,  99,
 151     99,  99,  99,  99,  99,  99,  99,  99,
 152     99,  99,  99,  99,  99,  99,  99,  99
 153 };
 154 #endif
 155
 156 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
 157 /* IMPORTANT: these are only valid for 8-bit data precision! */
 158 static const UINT8 bits_dc_luminance[17] =
 159 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
 160 static const UINT8 val_dc_luminance[] =
 161 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 162
 163 static const UINT8 bits_dc_chrominance[17] =
 164 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
 165 static const UINT8 val_dc_chrominance[] =
 166 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
 167
 168 static const UINT8 bits_ac_luminance[17] =
 169 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 170 static const UINT8 val_ac_luminance[] =
 171 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 172   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 173   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 174   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 175   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 176   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 177   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 178   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 179   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 180   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 181   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 182   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 183   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 184   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 185   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 186   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 187   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 188   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 189   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 190   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 191   0xf9, 0xfa
 192 };
 193
 194 static const UINT8 bits_ac_chrominance[17] =
 195 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 196
 197 static const UINT8 val_ac_chrominance[] =
 198 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 199   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 200   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 201   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 202   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 203   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 204   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 205   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 206   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 207   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 208   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 209   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 210   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 211   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 212   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 213   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 214   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 215   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 216   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 217   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 218   0xf9, 0xfa
 219 };
 220
 221 /* isn't this function nicer than the one in the libjpeg ? */
 222 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
 223                                 const UINT8 *bits_table, const UINT8 *val_table)
 224 {
 225     int i, j, k,nb, code, sym;
 226
 227     code = 0;
 228     k = 0;
 229     for(i=1;i<=16;i++) {
 230         nb = bits_table[i];
 231         for(j=0;j<nb;j++) {
 232             sym = val_table[k++];
 233             huff_size[sym] = i;
 234             huff_code[sym] = code;
 235             code++;
 236         }
 237         code <<= 1;
 238     }
 239 }
 240
 241 int mjpeg_init(MpegEncContext *s)
 242 {
 243     MJpegContext *m;
 244
 245     m = av_malloc(sizeof(MJpegContext));
 246     if (!m)
 247         return -1;
 248
 249     s->min_qcoeff=-1023;
 250     s->max_qcoeff= 1023;
 251     s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
 252
 253     /* build all the huffman tables */
 254     build_huffman_codes(m->huff_size_dc_luminance,
 255                         m->huff_code_dc_luminance,
 256                         bits_dc_luminance,
 257                         val_dc_luminance);
 258     build_huffman_codes(m->huff_size_dc_chrominance,
 259                         m->huff_code_dc_chrominance,
 260                         bits_dc_chrominance,
 261                         val_dc_chrominance);
 262     build_huffman_codes(m->huff_size_ac_luminance,
 263                         m->huff_code_ac_luminance,
 264                         bits_ac_luminance,
 265                         val_ac_luminance);
 266     build_huffman_codes(m->huff_size_ac_chrominance,
 267                         m->huff_code_ac_chrominance,
 268                         bits_ac_chrominance,
 269                         val_ac_chrominance);
 270
 271     s->mjpeg_ctx = m;
 272     return 0;
 273 }
 274
 275 void mjpeg_close(MpegEncContext *s)
 276 {
 277     av_free(s->mjpeg_ctx);
 278 }
 279
 280 static inline void put_marker(PutBitContext *p, int code)
 281 {
 282     put_bits(p, 8, 0xff);
 283     put_bits(p, 8, code);
 284 }
 285
 286 /* table_class: 0 = DC coef, 1 = AC coefs */
 287 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 288                              const UINT8 *bits_table, const UINT8 *value_table)
 289 {
 290     PutBitContext *p = &s->pb;
 291     int n, i;
 292
 293     put_bits(p, 4, table_class);
 294     put_bits(p, 4, table_id);
 295
 296     n = 0;
 297     for(i=1;i<=16;i++) {
 298         n += bits_table[i];
 299         put_bits(p, 8, bits_table[i]);
 300     }
 301
 302     for(i=0;i<n;i++)
 303         put_bits(p, 8, value_table[i]);
 304
 305     return n + 17;
 306 }
 307
 308 static void jpeg_table_header(MpegEncContext *s)
 309 {
 310     PutBitContext *p = &s->pb;
 311     int i, j, size;
 312     UINT8 *ptr;
 313
 314     /* quant matrixes */
 315     put_marker(p, DQT);
 316 #ifdef TWOMATRIXES
 317     put_bits(p, 16, 2 + 2 * (1 + 64));
 318 #else
 319     put_bits(p, 16, 2 + 1 * (1 + 64));
 320 #endif
 321     put_bits(p, 4, 0); /* 8 bit precision */
 322     put_bits(p, 4, 0); /* table 0 */
 323     for(i=0;i<64;i++) {
 324         j = zigzag_direct[i];
 325         put_bits(p, 8, s->intra_matrix[j]);
 326     }
 327 #ifdef TWOMATRIXES
 328     put_bits(p, 4, 0); /* 8 bit precision */
 329     put_bits(p, 4, 1); /* table 1 */
 330     for(i=0;i<64;i++) {
 331         j = zigzag_direct[i];
 332         put_bits(p, 8, s->chroma_intra_matrix[j]);
 333     }
 334 #endif
 335
 336     /* huffman table */
 337     put_marker(p, DHT);
 338     flush_put_bits(p);
 339     ptr = pbBufPtr(p);
 340     put_bits(p, 16, 0); /* patched later */
 341     size = 2;
 342     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 343     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 344
 345     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 346     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 347     ptr[0] = size >> 8;
 348     ptr[1] = size;
 349 }
 350
 351 static void jpeg_put_comments(MpegEncContext *s)
 352 {
 353     PutBitContext *p = &s->pb;
 354     int size;
 355     UINT8 *ptr;
 356
 357 #if 0
 358     /* JFIF header */
 359     put_marker(p, APP0);
 360     put_bits(p, 16, 16);
 361     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
 362     put_bits(p, 16, 0x101);
 363     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
 364     put_bits(p, 16, 1); /* aspect: 1:1 */
 365     put_bits(p, 16, 1);
 366     put_bits(p, 8, 0); /* thumbnail width */
 367     put_bits(p, 8, 0); /* thumbnail height */
 368 #endif
 369
 370     /* comment */
 371     put_marker(p, COM);
 372     flush_put_bits(p);
 373     ptr = pbBufPtr(p);
 374     put_bits(p, 16, 0); /* patched later */
 375 #define VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR
 376     put_string(p, VERSION);
 377     size = strlen(VERSION)+3;
 378 #undef VERSION
 379     ptr[0] = size >> 8;
 380     ptr[1] = size;
 381 }
 382
 383 void mjpeg_picture_header(MpegEncContext *s)
 384 {
 385     put_marker(&s->pb, SOI);
 386
 387     if (!s->mjpeg_data_only_frames)
 388     {
 389     jpeg_put_comments(s);
 390
 391     if (s->mjpeg_write_tables) jpeg_table_header(s);
 392
 393     put_marker(&s->pb, SOF0);
 394
 395     put_bits(&s->pb, 16, 17);
 396     put_bits(&s->pb, 8, 8); /* 8 bits/component */
 397     put_bits(&s->pb, 16, s->height);
 398     put_bits(&s->pb, 16, s->width);
 399     put_bits(&s->pb, 8, 3); /* 3 components */
 400
 401     /* Y component */
 402     put_bits(&s->pb, 8, 1); /* component number */
 403     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
 404     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
 405     put_bits(&s->pb, 8, 0); /* select matrix */
 406
 407     /* Cb component */
 408     put_bits(&s->pb, 8, 2); /* component number */
 409     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
 410     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 411 #ifdef TWOMATRIXES
 412     put_bits(&s->pb, 8, 1); /* select matrix */
 413 #else
 414     put_bits(&s->pb, 8, 0); /* select matrix */
 415 #endif
 416
 417     /* Cr component */
 418     put_bits(&s->pb, 8, 3); /* component number */
 419     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
 420     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 421 #ifdef TWOMATRIXES
 422     put_bits(&s->pb, 8, 1); /* select matrix */
 423 #else
 424     put_bits(&s->pb, 8, 0); /* select matrix */
 425 #endif
 426     }
 427
 428     /* scan header */
 429     put_marker(&s->pb, SOS);
 430     put_bits(&s->pb, 16, 12); /* length */
 431     put_bits(&s->pb, 8, 3); /* 3 components */
 432
 433     /* Y component */
 434     put_bits(&s->pb, 8, 1); /* index */
 435     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 436     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 437
 438     /* Cb component */
 439     put_bits(&s->pb, 8, 2); /* index */
 440     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 441     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 442
 443     /* Cr component */
 444     put_bits(&s->pb, 8, 3); /* index */
 445     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 446     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 447
 448     put_bits(&s->pb, 8, 0); /* Ss (not used) */
 449     put_bits(&s->pb, 8, 63); /* Se (not used) */
 450     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 451 }
 452
 453 void mjpeg_picture_trailer(MpegEncContext *s)
 454 {
 455     jflush_put_bits(&s->pb);
 456     put_marker(&s->pb, EOI);
 457 }
 458
 459 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 460                                    UINT8 *huff_size, UINT16 *huff_code)
 461 {
 462     int mant, nbits;
 463
 464     if (val == 0) {
 465         jput_bits(&s->pb, huff_size[0], huff_code[0]);
 466     } else {
 467         mant = val;
 468         if (val < 0) {
 469             val = -val;
 470             mant--;
 471         }
 472
 473         /* compute the log (XXX: optimize) */
 474         nbits = 0;
 475         while (val != 0) {
 476             val = val >> 1;
 477             nbits++;
 478         }
 479
 480         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 481
 482         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 483     }
 484 }
 485
 486 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 487 {
 488     int mant, nbits, code, i, j;
 489     int component, dc, run, last_index, val;
 490     MJpegContext *m = s->mjpeg_ctx;
 491     UINT8 *huff_size_ac;
 492     UINT16 *huff_code_ac;
 493
 494     /* DC coef */
 495     component = (n <= 3 ? 0 : n - 4 + 1);
 496     dc = block[0]; /* overflow is impossible */
 497     val = dc - s->last_dc[component];
 498     if (n < 4) {
 499         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 500         huff_size_ac = m->huff_size_ac_luminance;
 501         huff_code_ac = m->huff_code_ac_luminance;
 502     } else {
 503         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 504         huff_size_ac = m->huff_size_ac_chrominance;
 505         huff_code_ac = m->huff_code_ac_chrominance;
 506     }
 507     s->last_dc[component] = dc;
 508
 509     /* AC coefs */
 510
 511     run = 0;
 512     last_index = s->block_last_index[n];
 513     for(i=1;i<=last_index;i++) {
 514         j = zigzag_direct[i];
 515         val = block[j];
 516         if (val == 0) {
 517             run++;
 518         } else {
 519             while (run >= 16) {
 520                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 521                 run -= 16;
 522             }
 523             mant = val;
 524             if (val < 0) {
 525                 val = -val;
 526                 mant--;
 527             }
 528
 529             /* compute the log (XXX: optimize) */
 530             nbits = 0;
 531             while (val != 0) {
 532                 val = val >> 1;
 533                 nbits++;
 534             }
 535             code = (run << 4) | nbits;
 536
 537             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 538
 539             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 540             run = 0;
 541         }
 542     }
 543
 544     /* output EOB only if not already 64 values */
 545     if (last_index < 63 || run != 0)
 546         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 547 }
 548
 549 void mjpeg_encode_mb(MpegEncContext *s,
 550                      DCTELEM block[6][64])
 551 {
 552     int i;
 553     for(i=0;i<6;i++) {
 554         encode_block(s, block[i], i);
 555     }
 556 }
 557
 558 /******************************************/
 559 /* decoding */
 560
 561 /* compressed picture size */
 562 #define PICTURE_BUFFER_SIZE 100000
 563
 564 #define MAX_COMPONENTS 4
 565
 566 typedef struct MJpegDecodeContext {
 567     AVCodecContext *avctx;
 568     GetBitContext gb;
 569     UINT32 header_state;
 570     int start_code; /* current start code */
 571     UINT8 *buf_ptr;
 572     int buffer_size;
 573     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 574     INT16 quant_matrixes[4][64];
 575     VLC vlcs[2][4];
 576
 577     int org_width, org_height;  /* size given at codec init */
 578     int first_picture;    /* true if decoding first picture */
 579     int interlaced;     /* true if interlaced */
 580     int bottom_field;   /* true if bottom field */
 581
 582     int width, height;
 583     int nb_components;
 584     int component_id[MAX_COMPONENTS];
 585     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 586     int v_count[MAX_COMPONENTS];
 587     int h_max, v_max; /* maximum h and v counts */
 588     int quant_index[4];   /* quant table index for each component */
 589     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 590     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
 591     int linesize[MAX_COMPONENTS];
 592     DCTELEM block[64] __align8;
 593     UINT8 buffer[PICTURE_BUFFER_SIZE];
 594
 595     int buggy_avid;
 596     int restart_interval;
 597     int restart_count;
 598     int interleaved_rows;
 599 } MJpegDecodeContext;
 600
 601 #define SKIP_REMAINING(gb, len) { \
 602     dprintf("reamining %d bytes in marker\n", len); \
 603     if (len) while (--len) \
 604         skip_bits(gb, 8); \
 605 }
 606
 607 static int mjpeg_decode_dht(MJpegDecodeContext *s, UINT8 *buf, int buf_size);
 608
 609 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
 610                       int nb_codes)
 611 {
 612     UINT8 huff_size[256];
 613     UINT16 huff_code[256];
 614
 615     memset(huff_size, 0, sizeof(huff_size));
 616     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 617
 618     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 619 }
 620
 621 static int mjpeg_decode_init(AVCodecContext *avctx)
 622 {
 623     MJpegDecodeContext *s = avctx->priv_data;
 624
 625     s->avctx = avctx;
 626
 627     s->header_state = 0;
 628     s->mpeg_enc_ctx_allocated = 0;
 629     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
 630                                                  account FF 00 case */
 631     s->start_code = -1;
 632     s->buf_ptr = s->buffer;
 633     s->first_picture = 1;
 634     s->org_width = avctx->width;
 635     s->org_height = avctx->height;
 636
 637     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 638     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 639     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 640     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 641
 642     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 643     {
 644         printf("mjpeg: using external huffman table\n");
 645         mjpeg_decode_dht(s, avctx->extradata, avctx->extradata_size);
 646         /* should check for error - but dunno */
 647     }
 648     return 0;
 649 }
 650
 651 /* quantize tables */
 652 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
 653                             UINT8 *buf, int buf_size)
 654 {
 655     int len, index, i, j;
 656     init_get_bits(&s->gb, buf, buf_size);
 657
 658     len = get_bits(&s->gb, 16) - 2;
 659
 660     while (len >= 65) {
 661         /* only 8 bit precision handled */
 662         if (get_bits(&s->gb, 4) != 0)
 663         {
 664             dprintf("dqt: 16bit precision\n");
 665             return -1;
 666         }
 667         index = get_bits(&s->gb, 4);
 668         if (index >= 4)
 669             return -1;
 670         dprintf("index=%d\n", index);
 671         /* read quant table */
 672         for(i=0;i<64;i++) {
 673             j = zigzag_direct[i];
 674             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 675         }
 676         len -= 65;
 677     }
 678
 679     SKIP_REMAINING(&s->gb, len);
 680
 681     return 0;
 682 }
 683
 684 /* decode huffman tables and build VLC decoders */
 685 static int mjpeg_decode_dht(MJpegDecodeContext *s,
 686                             UINT8 *buf, int buf_size)
 687 {
 688     int len, index, i, class, n, v, code_max;
 689     UINT8 bits_table[17];
 690     UINT8 val_table[256];
 691
 692     init_get_bits(&s->gb, buf, buf_size);
 693
 694     len = get_bits(&s->gb, 16);
 695     len -= 2;
 696
 697     while (len > 0) {
 698         if (len < 17)
 699             return -1;
 700         class = get_bits(&s->gb, 4);
 701         if (class >= 2)
 702             return -1;
 703         index = get_bits(&s->gb, 4);
 704         if (index >= 4)
 705             return -1;
 706         n = 0;
 707         for(i=1;i<=16;i++) {
 708             bits_table[i] = get_bits(&s->gb, 8);
 709             n += bits_table[i];
 710         }
 711         len -= 17;
 712         if (len < n || n > 256)
 713             return -1;
 714
 715         code_max = 0;
 716         for(i=0;i<n;i++) {
 717             v = get_bits(&s->gb, 8);
 718             if (v > code_max)
 719                 code_max = v;
 720             val_table[i] = v;
 721         }
 722         len -= n;
 723
 724         /* build VLC and flush previous vlc if present */
 725         free_vlc(&s->vlcs[class][index]);
 726         dprintf("class=%d index=%d nb_codes=%d\n",
 727                class, index, code_max + 1);
 728         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 729     }
 730     return 0;
 731 }
 732
 733 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
 734                              UINT8 *buf, int buf_size)
 735 {
 736     int len, nb_components, i, width, height;
 737
 738     init_get_bits(&s->gb, buf, buf_size);
 739
 740     /* XXX: verify len field validity */
 741     len = get_bits(&s->gb, 16);
 742     /* only 8 bits/component accepted */
 743     if (get_bits(&s->gb, 8) != 8)
 744         return -1;
 745     height = get_bits(&s->gb, 16);
 746     width = get_bits(&s->gb, 16);
 747     dprintf("sof0: picture: %dx%d\n", width, height);
 748
 749     nb_components = get_bits(&s->gb, 8);
 750     if (nb_components <= 0 ||
 751         nb_components > MAX_COMPONENTS)
 752         return -1;
 753     s->nb_components = nb_components;
 754     s->h_max = 1;
 755     s->v_max = 1;
 756     for(i=0;i<nb_components;i++) {
 757         /* component id */
 758         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 759         s->h_count[i] = get_bits(&s->gb, 4);
 760         s->v_count[i] = get_bits(&s->gb, 4);
 761         /* compute hmax and vmax (only used in interleaved case) */
 762         if (s->h_count[i] > s->h_max)
 763             s->h_max = s->h_count[i];
 764         if (s->v_count[i] > s->v_max)
 765             s->v_max = s->v_count[i];
 766         s->quant_index[i] = get_bits(&s->gb, 8);
 767         if (s->quant_index[i] >= 4)
 768             return -1;
 769         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
 770             s->v_count[i], s->component_id[i], s->quant_index[i]);
 771     }
 772
 773     /* if different size, realloc/alloc picture */
 774     /* XXX: also check h_count and v_count */
 775     if (width != s->width || height != s->height) {
 776         for(i=0;i<MAX_COMPONENTS;i++)
 777             av_freep(&s->current_picture[i]);
 778         s->width = width;
 779         s->height = height;
 780         /* test interlaced mode */
 781         if (s->first_picture &&
 782             s->org_height != 0 &&
 783             s->height < ((s->org_height * 3) / 4)) {
 784             s->interlaced = 1;
 785             s->bottom_field = 0;
 786         }
 787
 788         for(i=0;i<nb_components;i++) {
 789             int w, h;
 790             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
 791             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
 792             w = w * 8 * s->h_count[i];
 793             h = h * 8 * s->v_count[i];
 794             if (s->interlaced)
 795                 w *= 2;
 796             s->linesize[i] = w;
 797             /* memory test is done in mjpeg_decode_sos() */
 798             s->current_picture[i] = av_mallocz(w * h);
 799         }
 800         s->first_picture = 0;
 801     }
 802
 803     if (len != (8+(3*nb_components)))
 804     {
 805         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
 806     }
 807
 808     return 0;
 809 }
 810
 811 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
 812 {
 813     int code, diff;
 814
 815     code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
 816     if (code < 0)
 817     {
 818         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
 819                 &s->vlcs[0][dc_index]);
 820         return 0xffff;
 821     }
 822     if (code == 0) {
 823         diff = 0;
 824     } else {
 825         diff = get_bits(&s->gb, code);
 826         if ((diff & (1 << (code - 1))) == 0)
 827             diff = (-1 << code) | (diff + 1);
 828     }
 829     return diff;
 830 }
 831
 832 /* decode block and dequantize */
 833 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 834                         int component, int dc_index, int ac_index, int quant_index)
 835 {
 836     int nbits, code, i, j, level;
 837     int run, val;
 838     VLC *ac_vlc;
 839     INT16 *quant_matrix;
 840
 841     /* DC coef */
 842     val = mjpeg_decode_dc(s, dc_index);
 843     if (val == 0xffff) {
 844         dprintf("error dc\n");
 845         return -1;
 846     }
 847     quant_matrix = s->quant_matrixes[quant_index];
 848     val = val * quant_matrix[0] + s->last_dc[component];
 849     s->last_dc[component] = val;
 850     block[0] = val;
 851     /* AC coefs */
 852     ac_vlc = &s->vlcs[1][ac_index];
 853     i = 1;
 854     for(;;) {
 855         code = get_vlc(&s->gb, ac_vlc);
 856         if (code < 0) {
 857             dprintf("error ac\n");
 858             return -1;
 859         }
 860         /* EOB */
 861         if (code == 0)
 862             break;
 863         if (code == 0xf0) {
 864             i += 16;
 865         } else {
 866             run = code >> 4;
 867             nbits = code & 0xf;
 868             level = get_bits(&s->gb, nbits);
 869             if ((level & (1 << (nbits - 1))) == 0)
 870                 level = (-1 << nbits) | (level + 1);
 871             i += run;
 872             if (i >= 64) {
 873                 dprintf("error count: %d\n", i);
 874                 return -1;
 875             }
 876             j = zigzag_direct[i];
 877             block[j] = level * quant_matrix[j];
 878             i++;
 879             if (i >= 64)
 880                 break;
 881         }
 882     }
 883     return 0;
 884 }
 885
 886 static int mjpeg_decode_sos(MJpegDecodeContext *s,
 887                             UINT8 *buf, int buf_size)
 888 {
 889     int len, nb_components, i, j, n, h, v, ret;
 890     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 891     int comp_index[4];
 892     int dc_index[4];
 893     int ac_index[4];
 894     int nb_blocks[4];
 895     int h_count[4];
 896     int v_count[4];
 897
 898     init_get_bits(&s->gb, buf, buf_size);
 899     /* XXX: verify len field validity */
 900     len = get_bits(&s->gb, 16);
 901     nb_components = get_bits(&s->gb, 8);
 902     /* XXX: only interleaved scan accepted */
 903     if (nb_components != 3)
 904     {
 905         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
 906         return -1;
 907     }
 908     vmax = 0;
 909     hmax = 0;
 910     for(i=0;i<nb_components;i++) {
 911         id = get_bits(&s->gb, 8) - 1;
 912         dprintf("component: %d\n", id);
 913         /* find component index */
 914         for(index=0;index<s->nb_components;index++)
 915             if (id == s->component_id[index])
 916                 break;
 917         if (index == s->nb_components)
 918         {
 919             dprintf("decode_sos: index(%d) out of components\n", index);
 920             return -1;
 921         }
 922
 923         comp_index[i] = index;
 924         nb_blocks[i] = s->h_count[index] * s->v_count[index];
 925         h_count[i] = s->h_count[index];
 926         v_count[i] = s->v_count[index];
 927
 928         dc_index[i] = get_bits(&s->gb, 4);
 929         ac_index[i] = get_bits(&s->gb, 4);
 930
 931         if (dc_index[i] < 0 || ac_index[i] < 0 ||
 932             dc_index[i] >= 4 || ac_index[i] >= 4)
 933             goto out_of_range;
 934         switch(s->start_code)
 935         {
 936             case SOF0:
 937                 if (dc_index[i] > 1 || ac_index[i] > 1)
 938                     goto out_of_range;
 939                 break;
 940             case SOF1:
 941             case SOF2:
 942                 if (dc_index[i] > 3 || ac_index[i] > 3)
 943                     goto out_of_range;
 944                 break;
 945             case SOF3:
 946                 if (dc_index[i] > 3 || ac_index[i] != 0)
 947                     goto out_of_range;
 948                 break;
 949         }
 950     }
 951     skip_bits(&s->gb, 8); /* Ss */
 952     skip_bits(&s->gb, 8); /* Se */
 953     skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
 954
 955     for(i=0;i<nb_components;i++)
 956         s->last_dc[i] = 1024;
 957
 958     if (nb_components > 1) {
 959         /* interleaved stream */
 960         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
 961         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
 962     } else {
 963         h = s->h_max / s->h_count[comp_index[0]];
 964         v = s->v_max / s->v_count[comp_index[0]];
 965         mb_width = (s->width + h * 8 - 1) / (h * 8);
 966         mb_height = (s->height + v * 8 - 1) / (v * 8);
 967         nb_blocks[0] = 1;
 968         h_count[0] = 1;
 969         v_count[0] = 1;
 970     }
 971
 972     for(mb_y = 0; mb_y < mb_height; mb_y++) {
 973         for(mb_x = 0; mb_x < mb_width; mb_x++) {
 974             for(i=0;i<nb_components;i++) {
 975                 UINT8 *ptr;
 976                 int x, y, c;
 977                 n = nb_blocks[i];
 978                 c = comp_index[i];
 979                 h = h_count[i];
 980                 v = v_count[i];
 981                 x = 0;
 982                 y = 0;
 983                 if (s->restart_interval && !s->restart_count)
 984                     s->restart_count = s->restart_interval;
 985                 for(j=0;j<n;j++) {
 986                     memset(s->block, 0, sizeof(s->block));
 987                     if (decode_block(s, s->block, i,
 988                                      dc_index[i], ac_index[i],
 989                                      s->quant_index[c]) < 0) {
 990                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
 991                         ret = -1;
 992                         goto the_end;
 993                     }
 994 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
 995                     ptr = s->current_picture[c] +
 996                         (s->linesize[c] * (v * mb_y + y) * 8) +
 997                         (h * mb_x + x) * 8;
 998                     if (s->interlaced && s->bottom_field)
 999                         ptr += s->linesize[c] >> 1;
1000                     ff_idct_put(ptr, s->linesize[c], s->block);
1001                     if (++x == h) {
1002                         x = 0;
1003                         y++;
1004                     }
1005                 }
1006             }
1007         }
1008     }
1009     ret = 0;
1010  the_end:
1011     emms_c();
1012     return ret;
1013  out_of_range:
1014     dprintf("decode_sos: ac/dc index out of range\n");
1015     return -1;
1016 }
1017
1018 static int mjpeg_decode_dri(MJpegDecodeContext *s,
1019                              UINT8 *buf, int buf_size)
1020 {
1021     init_get_bits(&s->gb, buf, buf_size);
1022
1023     if (get_bits(&s->gb, 16) != 4)
1024         return -1;
1025     s->restart_interval = get_bits(&s->gb, 16);
1026     dprintf("restart interval: %d\n", s->restart_interval);
1027
1028     return 0;
1029 }
1030
1031 #define FOURCC(a,b,c,d) ((a << 24) | (b << 16) | (c << 8) | d)
1032 static int mjpeg_decode_app(MJpegDecodeContext *s,
1033                              UINT8 *buf, int buf_size, int start_code)
1034 {
1035     int len, id;
1036
1037     init_get_bits(&s->gb, buf, buf_size);
1038
1039     /* XXX: verify len field validity */
1040     len = get_bits(&s->gb, 16);
1041     if (len < 5)
1042         return -1;
1043
1044     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1045     len -= 6;
1046
1047     /* buggy AVID, it puts EOI only at every 10th frame */
1048     /* also this fourcc is used by non-avid files too, it means
1049        interleaving, but it's always present in AVID files */
1050     if (id == FOURCC('A','V','I','1'))
1051     {
1052         /* structure:
1053             4bytes      AVI1
1054             1bytes      polarity
1055             1bytes      always zero
1056             4bytes      field_size
1057             4bytes      field_size_less_padding
1058         */
1059         s->buggy_avid = 1;
1060         if (s->first_picture)
1061             printf("mjpeg: workarounding buggy AVID\n");
1062         s->interleaved_rows = get_bits(&s->gb, 8);
1063 #if 0
1064         skip_bits(&s->gb, 8);
1065         skip_bits(&s->gb, 32);
1066         skip_bits(&s->gb, 32);
1067         len -= 10;
1068 #endif
1069         if (s->interleaved_rows)
1070             printf("mjpeg: interleaved rows: %d\n", s->interleaved_rows);
1071         goto out;
1072     }
1073
1074     len -= 2;
1075
1076     if (id == FOURCC('J','F','I','F'))
1077     {
1078         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1079         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1080             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1081         goto out;
1082     }
1083
1084     /* Apple MJPEG-A */
1085     if ((start_code == APP1) && (len > (0x28 - 8)))
1086     {
1087         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1088         len -= 4;
1089         if (id == FOURCC('m','j','p','g')) /* Apple MJPEG-A */
1090         {
1091 #if 0
1092             skip_bits(&s->gb, 32); /* field size */
1093             skip_bits(&s->gb, 32); /* pad field size */
1094             skip_bits(&s->gb, 32); /* next off */
1095             skip_bits(&s->gb, 32); /* quant off */
1096             skip_bits(&s->gb, 32); /* huff off */
1097             skip_bits(&s->gb, 32); /* image off */
1098             skip_bits(&s->gb, 32); /* scan off */
1099             skip_bits(&s->gb, 32); /* data off */
1100 #endif
1101             if (s->first_picture)
1102                 printf("mjpeg: Apple MJPEG-A header found\n");
1103         }
1104     }
1105
1106 out:
1107     /* should check for further values.. */
1108     SKIP_REMAINING(&s->gb, len);
1109
1110     return 0;
1111 }
1112 #undef FOURCC
1113
1114 static int mjpeg_decode_com(MJpegDecodeContext *s,
1115                              UINT8 *buf, int buf_size)
1116 {
1117     int len, i;
1118     UINT8 *cbuf;
1119
1120     init_get_bits(&s->gb, buf, buf_size);
1121
1122     /* XXX: verify len field validity */
1123     len = get_bits(&s->gb, 16)-2;
1124     cbuf = av_malloc(len+1);
1125
1126     for (i = 0; i < len; i++)
1127         cbuf[i] = get_bits(&s->gb, 8);
1128     if (cbuf[i-1] == '\n')
1129         cbuf[i-1] = 0;
1130     else
1131         cbuf[i] = 0;
1132
1133     printf("mjpeg comment: '%s'\n", cbuf);
1134
1135     /* buggy avid, it puts EOI only at every 10th frame */
1136     if (!strcmp(cbuf, "AVID"))
1137     {
1138         s->buggy_avid = 1;
1139         if (s->first_picture)
1140             printf("mjpeg: workarounding buggy AVID\n");
1141     }
1142
1143     av_free(cbuf);
1144
1145     return 0;
1146 }
1147
1148 /* return the 8 bit start code value and update the search
1149    state. Return -1 if no start code found */
1150 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end,
1151                        UINT32 *header_state)
1152 {
1153     UINT8 *buf_ptr;
1154     unsigned int state, v;
1155     int val;
1156
1157     state = *header_state;
1158     buf_ptr = *pbuf_ptr;
1159     if (state) {
1160         /* get marker */
1161     found:
1162         if (buf_ptr < buf_end) {
1163             val = *buf_ptr++;
1164             state = 0;
1165         } else {
1166             val = -1;
1167         }
1168     } else {
1169         while (buf_ptr < buf_end) {
1170             v = *buf_ptr++;
1171             if (v == 0xff) {
1172                 state = 1;
1173                 goto found;
1174             }
1175         }
1176         val = -1;
1177     }
1178     *pbuf_ptr = buf_ptr;
1179     *header_state = state;
1180     return val;
1181 }
1182
1183 static int mjpeg_decode_frame(AVCodecContext *avctx,
1184                               void *data, int *data_size,
1185                               UINT8 *buf, int buf_size)
1186 {
1187     MJpegDecodeContext *s = avctx->priv_data;
1188     UINT8 *buf_end, *buf_ptr, *buf_start;
1189     int len, code, input_size, i;
1190     AVPicture *picture = data;
1191     unsigned int start_code;
1192
1193     *data_size = 0;
1194
1195     /* no supplementary picture */
1196     if (buf_size == 0)
1197         return 0;
1198
1199     buf_ptr = buf;
1200     buf_end = buf + buf_size;
1201     while (buf_ptr < buf_end) {
1202         buf_start = buf_ptr;
1203         /* find start next marker */
1204         code = find_marker(&buf_ptr, buf_end, &s->header_state);
1205         /* copy to buffer */
1206         len = buf_ptr - buf_start;
1207         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1208             /* data too big : flush */
1209             s->buf_ptr = s->buffer;
1210             if (code > 0)
1211                 s->start_code = code;
1212         } else {
1213             memcpy(s->buf_ptr, buf_start, len);
1214             s->buf_ptr += len;
1215             if (code < 0) {
1216                 /* nothing to do: wait next marker */
1217             } else if (code == 0 || code == 0xff) {
1218                 /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
1219                 /* valid marker code is between 00 and ff - alex */
1220                 s->buf_ptr--;
1221             } else {
1222                 /* prepare data for next start code */
1223                 input_size = s->buf_ptr - s->buffer;
1224                 start_code = s->start_code;
1225                 s->buf_ptr = s->buffer;
1226                 s->start_code = code;
1227                 dprintf("marker=%x\n", start_code);
1228                 switch(start_code) {
1229                 case SOI:
1230                     s->restart_interval = 0;
1231                     /* nothing to do on SOI */
1232                     break;
1233                 case DQT:
1234                     mjpeg_decode_dqt(s, s->buffer, input_size);
1235                     break;
1236                 case DHT:
1237                     mjpeg_decode_dht(s, s->buffer, input_size);
1238                     break;
1239                 case SOF0:
1240                     mjpeg_decode_sof0(s, s->buffer, input_size);
1241                     break;
1242                 case SOS:
1243                     mjpeg_decode_sos(s, s->buffer, input_size);
1244                     if (s->start_code == EOI || s->buggy_avid || s->restart_interval) {
1245                         int l;
1246                         if (s->interlaced) {
1247                             s->bottom_field ^= 1;
1248                             /* if not bottom field, do not output image yet */
1249                             if (s->bottom_field)
1250                                 goto the_end;
1251                         }
1252                         for(i=0;i<3;i++) {
1253                             picture->data[i] = s->current_picture[i];
1254                             l = s->linesize[i];
1255                             if (s->interlaced)
1256                                 l >>= 1;
1257                             picture->linesize[i] = l;
1258                         }
1259                         *data_size = sizeof(AVPicture);
1260                         avctx->height = s->height;
1261                         if (s->interlaced)
1262                             avctx->height *= 2;
1263                         avctx->width = s->width;
1264                         /* XXX: not complete test ! */
1265                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1266                         case 0x11:
1267                             avctx->pix_fmt = PIX_FMT_YUV444P;
1268                             break;
1269                         case 0x21:
1270                             avctx->pix_fmt = PIX_FMT_YUV422P;
1271                             break;
1272                         default:
1273                         case 0x22:
1274                             avctx->pix_fmt = PIX_FMT_YUV420P;
1275                             break;
1276                         }
1277                         /* dummy quality */
1278                         /* XXX: infer it with matrix */
1279                         avctx->quality = 3;
1280                         goto the_end;
1281                     }
1282                     break;
1283                 case DRI:
1284                     mjpeg_decode_dri(s, s->buffer, input_size);
1285                     break;
1286                 case SOF1:
1287                 case SOF2:
1288                 case SOF3:
1289                 case SOF5:
1290                 case SOF6:
1291                 case SOF7:
1292                 case SOF9:
1293                 case SOF10:
1294                 case SOF11:
1295                 case SOF13:
1296                 case SOF14:
1297                 case SOF15:
1298                 case JPG:
1299                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1300                     return -1;
1301                 }
1302 #if 1
1303                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1304                     dprintf("restart marker: %d\n", start_code&0x0f);
1305                 } else if (s->first_picture) {
1306                     /* APP fields */
1307                     if (start_code >= 0xe0 && start_code <= 0xef)
1308                         mjpeg_decode_app(s, s->buffer, input_size, start_code);
1309                     /* Comment */
1310                     else if (start_code == COM)
1311                         mjpeg_decode_com(s, s->buffer, input_size);
1312                 }
1313 #endif
1314             }
1315         }
1316     }
1317  the_end:
1318     return buf_ptr - buf;
1319 }
1320
1321 static int mjpeg_decode_end(AVCodecContext *avctx)
1322 {
1323     MJpegDecodeContext *s = avctx->priv_data;
1324     int i, j;
1325
1326     for(i=0;i<MAX_COMPONENTS;i++)
1327         av_free(s->current_picture[i]);
1328     for(i=0;i<2;i++) {
1329         for(j=0;j<4;j++)
1330             free_vlc(&s->vlcs[i][j]);
1331     }
1332     return 0;
1333 }
1334
1335 AVCodec mjpeg_decoder = {
1336     "mjpeg",
1337     CODEC_TYPE_VIDEO,
1338     CODEC_ID_MJPEG,
1339     sizeof(MJpegDecodeContext),
1340     mjpeg_decode_init,
1341     NULL,
1342     mjpeg_decode_end,
1343     mjpeg_decode_frame,
1344     0,
1345     NULL
1346 };