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

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