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 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include "avcodec.h"
  22 #include "dsputil.h"
  23 #include "mpegvideo.h"
  24
  25 typedef struct MJpegContext {
  26     UINT8 huff_size_dc_luminance[12];
  27     UINT16 huff_code_dc_luminance[12];
  28     UINT8 huff_size_dc_chrominance[12];
  29     UINT16 huff_code_dc_chrominance[12];
  30
  31     UINT8 huff_size_ac_luminance[256];
  32     UINT16 huff_code_ac_luminance[256];
  33     UINT8 huff_size_ac_chrominance[256];
  34     UINT16 huff_code_ac_chrominance[256];
  35 } MJpegContext;
  36
  37 #define SOF0 0xc0
  38 #define SOI 0xd8
  39 #define EOI 0xd9
  40 #define DQT 0xdb
  41 #define DHT 0xc4
  42 #define SOS 0xda
  43
  44 #if 0
  45 /* These are the sample quantization tables given in JPEG spec section K.1.
  46  * The spec says that the values given produce "good" quality, and
  47  * when divided by 2, "very good" quality.
  48  */
  49 static const unsigned char std_luminance_quant_tbl[64] = {
  50     16,  11,  10,  16,  24,  40,  51,  61,
  51     12,  12,  14,  19,  26,  58,  60,  55,
  52     14,  13,  16,  24,  40,  57,  69,  56,
  53     14,  17,  22,  29,  51,  87,  80,  62,
  54     18,  22,  37,  56,  68, 109, 103,  77,
  55     24,  35,  55,  64,  81, 104, 113,  92,
  56     49,  64,  78,  87, 103, 121, 120, 101,
  57     72,  92,  95,  98, 112, 100, 103,  99
  58 };
  59 static const unsigned char std_chrominance_quant_tbl[64] = {
  60     17,  18,  24,  47,  99,  99,  99,  99,
  61     18,  21,  26,  66,  99,  99,  99,  99,
  62     24,  26,  56,  99,  99,  99,  99,  99,
  63     47,  66,  99,  99,  99,  99,  99,  99,
  64     99,  99,  99,  99,  99,  99,  99,  99,
  65     99,  99,  99,  99,  99,  99,  99,  99,
  66     99,  99,  99,  99,  99,  99,  99,  99,
  67     99,  99,  99,  99,  99,  99,  99,  99
  68 };
  69 #endif
  70
  71 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
  72 /* IMPORTANT: these are only valid for 8-bit data precision! */
  73 static const UINT8 bits_dc_luminance[17] =
  74 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
  75 static const UINT8 val_dc_luminance[] =
  76 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  77
  78 static const UINT8 bits_dc_chrominance[17] =
  79 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
  80 static const UINT8 val_dc_chrominance[] =
  81 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  82
  83 static const UINT8 bits_ac_luminance[17] =
  84 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
  85 static const UINT8 val_ac_luminance[] =
  86 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
  87   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
  88   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
  89   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
  90   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
  91   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
  92   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
  93   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
  94   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
  95   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
  96   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
  97   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
  98   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
  99   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 100   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 101   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 102   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 103   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 104   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 105   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 106   0xf9, 0xfa
 107 };
 108
 109 static const UINT8 bits_ac_chrominance[17] =
 110 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 111
 112 static const UINT8 val_ac_chrominance[] =
 113 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 114   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 115   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 116   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 117   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 118   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 119   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 120   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 121   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 122   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 123   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 124   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 125   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 126   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 127   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 128   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 129   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 130   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 131   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 132   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 133   0xf9, 0xfa
 134 };
 135
 136
 137 /* isn't this function nicer than the one in the libjpeg ? */
 138 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
 139                                 const UINT8 *bits_table, const UINT8 *val_table)
 140 {
 141     int i, j, k,nb, code, sym;
 142
 143     code = 0;
 144     k = 0;
 145     for(i=1;i<=16;i++) {
 146         nb = bits_table[i];
 147         for(j=0;j<nb;j++) {
 148             sym = val_table[k++];
 149             huff_size[sym] = i;
 150             huff_code[sym] = code;
 151             code++;
 152         }
 153         code <<= 1;
 154     }
 155 }
 156
 157 int mjpeg_init(MpegEncContext *s)
 158 {
 159     MJpegContext *m;
 160
 161     m = malloc(sizeof(MJpegContext));
 162     if (!m)
 163         return -1;
 164
 165     /* build all the huffman tables */
 166     build_huffman_codes(m->huff_size_dc_luminance,
 167                         m->huff_code_dc_luminance,
 168                         bits_dc_luminance,
 169                         val_dc_luminance);
 170     build_huffman_codes(m->huff_size_dc_chrominance,
 171                         m->huff_code_dc_chrominance,
 172                         bits_dc_chrominance,
 173                         val_dc_chrominance);
 174     build_huffman_codes(m->huff_size_ac_luminance,
 175                         m->huff_code_ac_luminance,
 176                         bits_ac_luminance,
 177                         val_ac_luminance);
 178     build_huffman_codes(m->huff_size_ac_chrominance,
 179                         m->huff_code_ac_chrominance,
 180                         bits_ac_chrominance,
 181                         val_ac_chrominance);
 182
 183     s->mjpeg_ctx = m;
 184     return 0;
 185 }
 186
 187 void mjpeg_close(MpegEncContext *s)
 188 {
 189     free(s->mjpeg_ctx);
 190 }
 191
 192 static inline void put_marker(PutBitContext *p, int code)
 193 {
 194     put_bits(p, 8, 0xff);
 195     put_bits(p, 8, code);
 196 }
 197
 198 /* table_class: 0 = DC coef, 1 = AC coefs */
 199 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 200                              const UINT8 *bits_table, const UINT8 *value_table)
 201 {
 202     PutBitContext *p = &s->pb;
 203     int n, i;
 204
 205     put_bits(p, 4, table_class);
 206     put_bits(p, 4, table_id);
 207
 208     n = 0;
 209     for(i=1;i<=16;i++) {
 210         n += bits_table[i];
 211         put_bits(p, 8, bits_table[i]);
 212     }
 213
 214     for(i=0;i<n;i++)
 215         put_bits(p, 8, value_table[i]);
 216
 217     return n + 17;
 218 }
 219
 220 static void jpeg_table_header(MpegEncContext *s)
 221 {
 222     PutBitContext *p = &s->pb;
 223     int i, size;
 224     UINT8 *ptr;
 225
 226     /* quant matrixes */
 227     put_marker(p, DQT);
 228     put_bits(p, 16, 2 + 1 * (1 + 64));
 229     put_bits(p, 4, 0); /* 8 bit precision */
 230     put_bits(p, 4, 0); /* table 0 */
 231     for(i=0;i<64;i++) {
 232         put_bits(p, 8, s->intra_matrix[i]);
 233     }
 234 #if 0
 235     put_bits(p, 4, 0); /* 8 bit precision */
 236     put_bits(p, 4, 1); /* table 1 */
 237     for(i=0;i<64;i++) {
 238         put_bits(p, 8, s->chroma_intra_matrix[i]);
 239     }
 240 #endif
 241
 242     /* huffman table */
 243     put_marker(p, DHT);
 244     flush_put_bits(p);
 245     ptr = p->buf_ptr;
 246     put_bits(p, 16, 0); /* patched later */
 247     size = 2;
 248     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 249     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 250
 251     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 252     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 253     ptr[0] = size >> 8;
 254     ptr[1] = size;
 255 }
 256
 257 void mjpeg_picture_header(MpegEncContext *s)
 258 {
 259     put_marker(&s->pb, SOI);
 260
 261     jpeg_table_header(s);
 262
 263     put_marker(&s->pb, SOF0);
 264
 265     put_bits(&s->pb, 16, 17);
 266     put_bits(&s->pb, 8, 8); /* 8 bits/component */
 267     put_bits(&s->pb, 16, s->height);
 268     put_bits(&s->pb, 16, s->width);
 269     put_bits(&s->pb, 8, 3); /* 3 components */
 270
 271     /* Y component */
 272     put_bits(&s->pb, 8, 1); /* component number */
 273     put_bits(&s->pb, 4, 2); /* H factor */
 274     put_bits(&s->pb, 4, 2); /* V factor */
 275     put_bits(&s->pb, 8, 0); /* select matrix */
 276
 277     /* Cb component */
 278     put_bits(&s->pb, 8, 2); /* component number */
 279     put_bits(&s->pb, 4, 1); /* H factor */
 280     put_bits(&s->pb, 4, 1); /* V factor */
 281     put_bits(&s->pb, 8, 0); /* select matrix */
 282
 283     /* Cr component */
 284     put_bits(&s->pb, 8, 3); /* component number */
 285     put_bits(&s->pb, 4, 1); /* H factor */
 286     put_bits(&s->pb, 4, 1); /* V factor */
 287     put_bits(&s->pb, 8, 0); /* select matrix */
 288
 289     /* scan header */
 290     put_marker(&s->pb, SOS);
 291     put_bits(&s->pb, 16, 12); /* length */
 292     put_bits(&s->pb, 8, 3); /* 3 components */
 293
 294     /* Y component */
 295     put_bits(&s->pb, 8, 1); /* index */
 296     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 297     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 298
 299     /* Cb component */
 300     put_bits(&s->pb, 8, 2); /* index */
 301     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 302     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 303
 304     /* Cr component */
 305     put_bits(&s->pb, 8, 3); /* index */
 306     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 307     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 308
 309     put_bits(&s->pb, 8, 0); /* Ss (not used) */
 310     put_bits(&s->pb, 8, 63); /* Se (not used) */
 311     put_bits(&s->pb, 8, 0); /* (not used) */
 312 }
 313
 314 void mjpeg_picture_trailer(MpegEncContext *s)
 315 {
 316     jflush_put_bits(&s->pb);
 317     put_marker(&s->pb, EOI);
 318 }
 319
 320 static inline void encode_dc(MpegEncContext *s, int val,
 321                              UINT8 *huff_size, UINT16 *huff_code)
 322 {
 323     int mant, nbits;
 324
 325     if (val == 0) {
 326         jput_bits(&s->pb, huff_size[0], huff_code[0]);
 327     } else {
 328         mant = val;
 329         if (val < 0) {
 330             val = -val;
 331             mant--;
 332         }
 333
 334         /* compute the log (XXX: optimize) */
 335         nbits = 0;
 336         while (val != 0) {
 337             val = val >> 1;
 338             nbits++;
 339         }
 340
 341         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 342
 343         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 344     }
 345 }
 346
 347 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 348 {
 349     int mant, nbits, code, i, j;
 350     int component, dc, run, last_index, val;
 351     MJpegContext *m = s->mjpeg_ctx;
 352     UINT8 *huff_size_ac;
 353     UINT16 *huff_code_ac;
 354
 355     /* DC coef */
 356     component = (n <= 3 ? 0 : n - 4 + 1);
 357     dc = block[0]; /* overflow is impossible */
 358     val = dc - s->last_dc[component];
 359     if (n < 4) {
 360         encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 361         huff_size_ac = m->huff_size_ac_luminance;
 362         huff_code_ac = m->huff_code_ac_luminance;
 363     } else {
 364         encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 365         huff_size_ac = m->huff_size_ac_chrominance;
 366         huff_code_ac = m->huff_code_ac_chrominance;
 367     }
 368     s->last_dc[component] = dc;
 369
 370     /* AC coefs */
 371
 372     run = 0;
 373     last_index = s->block_last_index[n];
 374     for(i=1;i<=last_index;i++) {
 375         j = zigzag_direct[i];
 376         val = block[j];
 377         if (val == 0) {
 378             run++;
 379         } else {
 380             while (run >= 16) {
 381                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 382                 run -= 16;
 383             }
 384             mant = val;
 385             if (val < 0) {
 386                 val = -val;
 387                 mant--;
 388             }
 389
 390             /* compute the log (XXX: optimize) */
 391             nbits = 0;
 392             while (val != 0) {
 393                 val = val >> 1;
 394                 nbits++;
 395             }
 396             code = (run << 4) | nbits;
 397
 398             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 399
 400             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 401             run = 0;
 402         }
 403     }
 404
 405     /* output EOB only if not already 64 values */
 406     if (last_index < 63 || run != 0)
 407         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 408 }
 409
 410 void mjpeg_encode_mb(MpegEncContext *s,
 411                      DCTELEM block[6][64])
 412 {
 413     int i;
 414     for(i=0;i<6;i++) {
 415         encode_block(s, block[i], i);
 416     }
 417 }
 418
 419 /******************************************/
 420 /* decoding */
 421
 422 //#define DEBUG
 423
 424 #ifdef DEBUG
 425 #define dprintf(fmt,args...) printf(fmt, ## args)
 426 #else
 427 #define dprintf(fmt,args...)
 428 #endif
 429
 430 /* compressed picture size */
 431 #define PICTURE_BUFFER_SIZE 100000
 432
 433 #define MAX_COMPONENTS 4
 434
 435 typedef struct MJpegDecodeContext {
 436     GetBitContext gb;
 437     UINT32 header_state;
 438     int start_code; /* current start code */
 439     UINT8 *buf_ptr;
 440     int buffer_size;
 441     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 442     INT16 quant_matrixes[4][64];
 443     VLC vlcs[2][4];
 444     int width, height;
 445     int nb_components;
 446     int component_id[MAX_COMPONENTS];
 447     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 448     int v_count[MAX_COMPONENTS];
 449     int h_max, v_max; /* maximum h and v counts */
 450     int quant_index[4];   /* quant table index for each component */
 451     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 452     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
 453     int linesize[MAX_COMPONENTS];
 454     DCTELEM block[64] __align8;
 455     UINT8 buffer[PICTURE_BUFFER_SIZE];
 456 } MJpegDecodeContext;
 457
 458 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
 459                       int nb_codes)
 460 {
 461     UINT8 huff_size[256];
 462     UINT16 huff_code[256];
 463
 464     memset(huff_size, 0, sizeof(huff_size));
 465     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 466
 467     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 468 }
 469
 470 static int mjpeg_decode_init(AVCodecContext *avctx)
 471 {
 472     MJpegDecodeContext *s = avctx->priv_data;
 473
 474     s->header_state = 0;
 475     s->mpeg_enc_ctx_allocated = 0;
 476     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
 477                                                  account FF 00 case */
 478     s->start_code = -1;
 479     s->buf_ptr = s->buffer;
 480
 481     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 482     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 483     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 484     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 485     return 0;
 486 }
 487
 488 /* quantize tables */
 489 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
 490                             UINT8 *buf, int buf_size)
 491 {
 492     int len, index, i;
 493     init_get_bits(&s->gb, buf, buf_size);
 494
 495     len = get_bits(&s->gb, 16);
 496     len -= 2;
 497
 498     while (len >= 65) {
 499         /* only 8 bit precision handled */
 500         if (get_bits(&s->gb, 4) != 0)
 501             return -1;
 502         index = get_bits(&s->gb, 4);
 503         if (index >= 4)
 504             return -1;
 505         dprintf("index=%d\n", index);
 506         /* read quant table */
 507         for(i=0;i<64;i++)
 508             s->quant_matrixes[index][i] = get_bits(&s->gb, 8);
 509         len -= 65;
 510     }
 511     return 0;
 512 }
 513
 514 /* decode huffman tables and build VLC decoders */
 515 static int mjpeg_decode_dht(MJpegDecodeContext *s,
 516                             UINT8 *buf, int buf_size)
 517 {
 518     int len, index, i, class, n, v, code_max;
 519     UINT8 bits_table[17];
 520     UINT8 val_table[256];
 521
 522     init_get_bits(&s->gb, buf, buf_size);
 523
 524     len = get_bits(&s->gb, 16);
 525     len -= 2;
 526
 527     while (len > 0) {
 528         if (len < 17)
 529             return -1;
 530         class = get_bits(&s->gb, 4);
 531         if (class >= 2)
 532             return -1;
 533         index = get_bits(&s->gb, 4);
 534         if (index >= 4)
 535             return -1;
 536         n = 0;
 537         for(i=1;i<=16;i++) {
 538             bits_table[i] = get_bits(&s->gb, 8);
 539             n += bits_table[i];
 540         }
 541         len -= 17;
 542         if (len < n || n > 256)
 543             return -1;
 544
 545         code_max = 0;
 546         for(i=0;i<n;i++) {
 547             v = get_bits(&s->gb, 8);
 548             if (v > code_max)
 549                 code_max = v;
 550             val_table[i] = v;
 551         }
 552         len -= n;
 553
 554         /* build VLC and flush previous vlc if present */
 555         free_vlc(&s->vlcs[class][index]);
 556         dprintf("class=%d index=%d nb_codes=%d\n",
 557                class, index, code_max + 1);
 558         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 559     }
 560     return 0;
 561 }
 562
 563 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
 564                              UINT8 *buf, int buf_size)
 565 {
 566     int len, nb_components, i, width, height;
 567
 568     init_get_bits(&s->gb, buf, buf_size);
 569
 570     /* XXX: verify len field validity */
 571     len = get_bits(&s->gb, 16);
 572     /* only 8 bits/component accepted */
 573     if (get_bits(&s->gb, 8) != 8)
 574         return -1;
 575     height = get_bits(&s->gb, 16);
 576     width = get_bits(&s->gb, 16);
 577
 578     nb_components = get_bits(&s->gb, 8);
 579     if (nb_components <= 0 ||
 580         nb_components > MAX_COMPONENTS)
 581         return -1;
 582     s->nb_components = nb_components;
 583     s->h_max = 1;
 584     s->v_max = 1;
 585     for(i=0;i<nb_components;i++) {
 586         /* component id */
 587         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 588         s->h_count[i] = get_bits(&s->gb, 4);
 589         s->v_count[i] = get_bits(&s->gb, 4);
 590         /* compute hmax and vmax (only used in interleaved case) */
 591         if (s->h_count[i] > s->h_max)
 592             s->h_max = s->h_count[i];
 593         if (s->v_count[i] > s->v_max)
 594             s->v_max = s->v_count[i];
 595         s->quant_index[i] = get_bits(&s->gb, 8);
 596         if (s->quant_index[i] >= 4)
 597             return -1;
 598         dprintf("component %d %d:%d\n", i, s->h_count[i], s->v_count[i]);
 599     }
 600
 601     /* if different size, realloc/alloc picture */
 602     /* XXX: also check h_count and v_count */
 603     if (width != s->width || height != s->height) {
 604         for(i=0;i<MAX_COMPONENTS;i++) {
 605             free(s->current_picture[i]);
 606             s->current_picture[i] = NULL;
 607         }
 608         s->width = width;
 609         s->height = height;
 610         for(i=0;i<nb_components;i++) {
 611             int w, h, hh, vv;
 612             hh = s->h_max / s->h_count[i];
 613             vv = s->v_max / s->v_count[i];
 614             w = (s->width + 8 * hh - 1) / (8 * hh);
 615             h = (s->height + 8 * vv - 1) / (8 * vv);
 616             w = w * 8;
 617             h = h * 8;
 618             s->linesize[i] = w;
 619             /* memory test is done in mjpeg_decode_sos() */
 620             s->current_picture[i] = av_mallocz(w * h);
 621         }
 622     }
 623
 624     return 0;
 625 }
 626
 627 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
 628 {
 629     VLC *dc_vlc;
 630     int code, diff;
 631
 632     dc_vlc = &s->vlcs[0][dc_index];
 633     code = get_vlc(&s->gb, dc_vlc);
 634     if (code < 0)
 635         return 0xffff;
 636     if (code == 0) {
 637         diff = 0;
 638     } else {
 639         diff = get_bits(&s->gb, code);
 640         if ((diff & (1 << (code - 1))) == 0)
 641             diff = (-1 << code) | (diff + 1);
 642     }
 643     return diff;
 644 }
 645
 646 /* decode block and dequantize */
 647 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 648                         int component, int dc_index, int ac_index, int quant_index)
 649 {
 650     int nbits, code, i, j, level;
 651     int run, val;
 652     VLC *ac_vlc;
 653     INT16 *quant_matrix;
 654
 655     quant_matrix = s->quant_matrixes[quant_index];
 656     /* DC coef */
 657     val = decode_dc(s, dc_index);
 658     if (val == 0xffff) {
 659         dprintf("error dc\n");
 660         return -1;
 661     }
 662     val = val * quant_matrix[0] + s->last_dc[component];
 663     s->last_dc[component] = val;
 664     block[0] = val;
 665     /* AC coefs */
 666     ac_vlc = &s->vlcs[1][ac_index];
 667     i = 1;
 668     for(;;) {
 669         code = get_vlc(&s->gb, ac_vlc);
 670         if (code < 0) {
 671             dprintf("error ac\n");
 672             return -1;
 673         }
 674         /* EOB */
 675         if (code == 0)
 676             break;
 677         if (code == 0xf0) {
 678             i += 16;
 679         } else {
 680             run = code >> 4;
 681             nbits = code & 0xf;
 682             level = get_bits(&s->gb, nbits);
 683             if ((level & (1 << (nbits - 1))) == 0)
 684                 level = (-1 << nbits) | (level + 1);
 685             i += run;
 686             if (i >= 64) {
 687                 dprintf("error count: %d\n", i);
 688                 return -1;
 689             }
 690             j = zigzag_direct[i];
 691             block[j] = level * quant_matrix[j];
 692             i++;
 693             if (i >= 64)
 694                 break;
 695         }
 696     }
 697     return 0;
 698 }
 699
 700 static int mjpeg_decode_sos(MJpegDecodeContext *s,
 701                             UINT8 *buf, int buf_size)
 702 {
 703     int len, nb_components, i, j, n, h, v;
 704     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 705     int comp_index[4];
 706     int dc_index[4];
 707     int ac_index[4];
 708     int nb_blocks[4];
 709     int h_count[4];
 710     int v_count[4];
 711
 712     init_get_bits(&s->gb, buf, buf_size);
 713     /* XXX: verify len field validity */
 714     len = get_bits(&s->gb, 16);
 715     nb_components = get_bits(&s->gb, 8);
 716     /* XXX: only interleaved scan accepted */
 717     if (nb_components != 3)
 718         return -1;
 719     vmax = 0;
 720     hmax = 0;
 721     for(i=0;i<nb_components;i++) {
 722         id = get_bits(&s->gb, 8) - 1;
 723         /* find component index */
 724         for(index=0;index<s->nb_components;index++)
 725             if (id == s->component_id[index])
 726                 break;
 727         if (index == s->nb_components)
 728             return -1;
 729
 730         comp_index[i] = index;
 731         nb_blocks[i] = s->h_count[index] * s->v_count[index];
 732         h_count[i] = s->h_count[index];
 733         v_count[i] = s->v_count[index];
 734
 735         dc_index[i] = get_bits(&s->gb, 4);
 736         if (dc_index[i] >= 4)
 737             return -1;
 738         ac_index[i] = get_bits(&s->gb, 4);
 739         if (ac_index[i] >= 4)
 740             return -1;
 741     }
 742     get_bits(&s->gb, 8); /* Ss */
 743     get_bits(&s->gb, 8); /* Se */
 744     get_bits(&s->gb, 8); /* not used */
 745
 746     for(i=0;i<nb_components;i++)
 747         s->last_dc[i] = 1024;
 748
 749     if (nb_components > 1) {
 750         /* interleaved stream */
 751         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
 752         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
 753     } else {
 754         h = s->h_max / s->h_count[comp_index[0]];
 755         v = s->v_max / s->v_count[comp_index[0]];
 756         mb_width = (s->width + h * 8 - 1) / (h * 8);
 757         mb_height = (s->height + v * 8 - 1) / (v * 8);
 758         nb_blocks[0] = 1;
 759         h_count[0] = 1;
 760         v_count[0] = 1;
 761     }
 762
 763     for(mb_y = 0; mb_y < mb_height; mb_y++) {
 764         for(mb_x = 0; mb_x < mb_width; mb_x++) {
 765             for(i=0;i<nb_components;i++) {
 766                 UINT8 *ptr;
 767                 int x, y, c;
 768                 n = nb_blocks[i];
 769                 c = comp_index[i];
 770                 h = h_count[i];
 771                 v = v_count[i];
 772                 x = 0;
 773                 y = 0;
 774                 for(j=0;j<n;j++) {
 775                     memset(s->block, 0, sizeof(s->block));
 776                     if (decode_block(s, s->block, i,
 777                                      dc_index[i], ac_index[i],
 778                                      s->quant_index[c]) < 0) {
 779                         dprintf("error %d %d\n", mb_y, mb_x);
 780                         return -1;
 781                     }
 782                     ff_idct (s->block);
 783                     ptr = s->current_picture[c] +
 784                         (s->linesize[c] * (v * mb_y + y) * 8) +
 785                         (h * mb_x + x) * 8;
 786                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
 787                     if (++x == h) {
 788                         x = 0;
 789                         y++;
 790                     }
 791                 }
 792             }
 793         }
 794     }
 795     return 0;
 796 }
 797
 798 /* return the 8 bit start code value and update the search
 799    state. Return -1 if no start code found */
 800 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end,
 801                        UINT32 *header_state)
 802 {
 803     UINT8 *buf_ptr;
 804     unsigned int state, v;
 805     int val;
 806
 807     state = *header_state;
 808     buf_ptr = *pbuf_ptr;
 809     if (state) {
 810         /* get marker */
 811     found:
 812         if (buf_ptr < buf_end) {
 813             val = *buf_ptr++;
 814             state = 0;
 815         } else {
 816             val = -1;
 817         }
 818     } else {
 819         while (buf_ptr < buf_end) {
 820             v = *buf_ptr++;
 821             if (v == 0xff) {
 822                 state = 1;
 823                 goto found;
 824             }
 825         }
 826         val = -1;
 827     }
 828     *pbuf_ptr = buf_ptr;
 829     *header_state = state;
 830     return val;
 831 }
 832
 833 static int mjpeg_decode_frame(AVCodecContext *avctx,
 834                               void *data, int *data_size,
 835                               UINT8 *buf, int buf_size)
 836 {
 837     MJpegDecodeContext *s = avctx->priv_data;
 838     UINT8 *buf_end, *buf_ptr, *buf_start;
 839     int len, code, start_code, input_size, i;
 840     AVPicture *picture = data;
 841
 842     /* no supplementary picture */
 843     if (buf_size == 0) {
 844         *data_size = 0;
 845         return 0;
 846     }
 847
 848     buf_ptr = buf;
 849     buf_end = buf + buf_size;
 850     while (buf_ptr < buf_end) {
 851         buf_start = buf_ptr;
 852         /* find start next marker */
 853         code = find_marker(&buf_ptr, buf_end, &s->header_state);
 854         /* copy to buffer */
 855         len = buf_ptr - buf_start;
 856         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
 857             /* data too big : flush */
 858             s->buf_ptr = s->buffer;
 859             if (code > 0)
 860                 s->start_code = code;
 861         } else {
 862             memcpy(s->buf_ptr, buf_start, len);
 863             s->buf_ptr += len;
 864             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
 865             if (code == 0) {
 866                 s->buf_ptr--;
 867             } else if (code > 0) {
 868                 /* prepare data for next start code */
 869                 input_size = s->buf_ptr - s->buffer;
 870                 start_code = s->start_code;
 871                 s->buf_ptr = s->buffer;
 872                 s->start_code = code;
 873                 switch(start_code) {
 874                 case SOI:
 875                     /* nothing to do on SOI */
 876                     break;
 877                 case DQT:
 878                     mjpeg_decode_dqt(s, s->buffer, input_size);
 879                     break;
 880                 case DHT:
 881                     mjpeg_decode_dht(s, s->buffer, input_size);
 882                     break;
 883                 case SOF0:
 884                     mjpeg_decode_sof0(s, s->buffer, input_size);
 885                     break;
 886                 case SOS:
 887                     mjpeg_decode_sos(s, s->buffer, input_size);
 888                     if (s->start_code == EOI) {
 889                         for(i=0;i<3;i++) {
 890                             picture->data[i] = s->current_picture[i];
 891                             picture->linesize[i] = s->linesize[i];
 892                         }
 893                         *data_size = sizeof(AVPicture);
 894                         avctx->height = s->height;
 895                         avctx->width = s->width;
 896                         /* XXX: not complete test ! */
 897                         switch((s->h_count[0] << 4) | s->v_count[0]) {
 898                         case 0x11:
 899                             avctx->pix_fmt = PIX_FMT_YUV444P;
 900                             break;
 901                         case 0x21:
 902                             avctx->pix_fmt = PIX_FMT_YUV422P;
 903                             break;
 904                         default:
 905                         case 0x22:
 906                             avctx->pix_fmt = PIX_FMT_YUV420P;
 907                             break;
 908                         }
 909                         goto the_end;
 910                     }
 911                     break;
 912                 }
 913             }
 914         }
 915     }
 916  the_end:
 917     return buf_ptr - buf;
 918 }
 919
 920 static int mjpeg_decode_end(AVCodecContext *avctx)
 921 {
 922     MJpegDecodeContext *s = avctx->priv_data;
 923     int i, j;
 924
 925     for(i=0;i<MAX_COMPONENTS;i++)
 926         free(s->current_picture[i]);
 927     for(i=0;i<2;i++) {
 928         for(j=0;j<4;j++)
 929             free_vlc(&s->vlcs[i][j]);
 930     }
 931     return 0;
 932 }
 933
 934 AVCodec mjpeg_decoder = {
 935     "mjpeg",
 936     CODEC_TYPE_VIDEO,
 937     CODEC_ID_MJPEG,
 938     sizeof(MJpegDecodeContext),
 939     mjpeg_decode_init,
 940     NULL,
 941     mjpeg_decode_end,
 942     mjpeg_decode_frame,
 943 };