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, j, 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         j = zigzag_direct[i];
 233         put_bits(p, 8, s->intra_matrix[j]);
 234     }
 235 #if 0
 236     put_bits(p, 4, 0); /* 8 bit precision */
 237     put_bits(p, 4, 1); /* table 1 */
 238     for(i=0;i<64;i++) {
 239         j = zigzag_direct[i];
 240         put_bits(p, 8, s->chroma_intra_matrix[j]);
 241     }
 242 #endif
 243
 244     /* huffman table */
 245     put_marker(p, DHT);
 246     flush_put_bits(p);
 247     ptr = p->buf_ptr;
 248     put_bits(p, 16, 0); /* patched later */
 249     size = 2;
 250     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 251     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 252
 253     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 254     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 255     ptr[0] = size >> 8;
 256     ptr[1] = size;
 257 }
 258
 259 void mjpeg_picture_header(MpegEncContext *s)
 260 {
 261     put_marker(&s->pb, SOI);
 262
 263     jpeg_table_header(s);
 264
 265     put_marker(&s->pb, SOF0);
 266
 267     put_bits(&s->pb, 16, 17);
 268     put_bits(&s->pb, 8, 8); /* 8 bits/component */
 269     put_bits(&s->pb, 16, s->height);
 270     put_bits(&s->pb, 16, s->width);
 271     put_bits(&s->pb, 8, 3); /* 3 components */
 272
 273     /* Y component */
 274     put_bits(&s->pb, 8, 1); /* component number */
 275     put_bits(&s->pb, 4, 2); /* H factor */
 276     put_bits(&s->pb, 4, 2); /* V factor */
 277     put_bits(&s->pb, 8, 0); /* select matrix */
 278
 279     /* Cb component */
 280     put_bits(&s->pb, 8, 2); /* component number */
 281     put_bits(&s->pb, 4, 1); /* H factor */
 282     put_bits(&s->pb, 4, 1); /* V factor */
 283     put_bits(&s->pb, 8, 0); /* select matrix */
 284
 285     /* Cr component */
 286     put_bits(&s->pb, 8, 3); /* component number */
 287     put_bits(&s->pb, 4, 1); /* H factor */
 288     put_bits(&s->pb, 4, 1); /* V factor */
 289     put_bits(&s->pb, 8, 0); /* select matrix */
 290
 291     /* scan header */
 292     put_marker(&s->pb, SOS);
 293     put_bits(&s->pb, 16, 12); /* length */
 294     put_bits(&s->pb, 8, 3); /* 3 components */
 295
 296     /* Y component */
 297     put_bits(&s->pb, 8, 1); /* index */
 298     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 299     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 300
 301     /* Cb component */
 302     put_bits(&s->pb, 8, 2); /* index */
 303     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 304     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 305
 306     /* Cr component */
 307     put_bits(&s->pb, 8, 3); /* index */
 308     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 309     put_bits(&s->pb, 4, 1); /* AC huffman table index */
 310
 311     put_bits(&s->pb, 8, 0); /* Ss (not used) */
 312     put_bits(&s->pb, 8, 63); /* Se (not used) */
 313     put_bits(&s->pb, 8, 0); /* (not used) */
 314 }
 315
 316 void mjpeg_picture_trailer(MpegEncContext *s)
 317 {
 318     jflush_put_bits(&s->pb);
 319     put_marker(&s->pb, EOI);
 320 }
 321
 322 static inline void encode_dc(MpegEncContext *s, int val,
 323                              UINT8 *huff_size, UINT16 *huff_code)
 324 {
 325     int mant, nbits;
 326
 327     if (val == 0) {
 328         jput_bits(&s->pb, huff_size[0], huff_code[0]);
 329     } else {
 330         mant = val;
 331         if (val < 0) {
 332             val = -val;
 333             mant--;
 334         }
 335
 336         /* compute the log (XXX: optimize) */
 337         nbits = 0;
 338         while (val != 0) {
 339             val = val >> 1;
 340             nbits++;
 341         }
 342
 343         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 344
 345         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 346     }
 347 }
 348
 349 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 350 {
 351     int mant, nbits, code, i, j;
 352     int component, dc, run, last_index, val;
 353     MJpegContext *m = s->mjpeg_ctx;
 354     UINT8 *huff_size_ac;
 355     UINT16 *huff_code_ac;
 356
 357     /* DC coef */
 358     component = (n <= 3 ? 0 : n - 4 + 1);
 359     dc = block[0]; /* overflow is impossible */
 360     val = dc - s->last_dc[component];
 361     if (n < 4) {
 362         encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 363         huff_size_ac = m->huff_size_ac_luminance;
 364         huff_code_ac = m->huff_code_ac_luminance;
 365     } else {
 366         encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 367         huff_size_ac = m->huff_size_ac_chrominance;
 368         huff_code_ac = m->huff_code_ac_chrominance;
 369     }
 370     s->last_dc[component] = dc;
 371
 372     /* AC coefs */
 373
 374     run = 0;
 375     last_index = s->block_last_index[n];
 376     for(i=1;i<=last_index;i++) {
 377         j = zigzag_direct[i];
 378         val = block[j];
 379         if (val == 0) {
 380             run++;
 381         } else {
 382             while (run >= 16) {
 383                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 384                 run -= 16;
 385             }
 386             mant = val;
 387             if (val < 0) {
 388                 val = -val;
 389                 mant--;
 390             }
 391
 392             /* compute the log (XXX: optimize) */
 393             nbits = 0;
 394             while (val != 0) {
 395                 val = val >> 1;
 396                 nbits++;
 397             }
 398             code = (run << 4) | nbits;
 399
 400             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 401
 402             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 403             run = 0;
 404         }
 405     }
 406
 407     /* output EOB only if not already 64 values */
 408     if (last_index < 63 || run != 0)
 409         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 410 }
 411
 412 void mjpeg_encode_mb(MpegEncContext *s,
 413                      DCTELEM block[6][64])
 414 {
 415     int i;
 416     for(i=0;i<6;i++) {
 417         encode_block(s, block[i], i);
 418     }
 419 }
 420
 421 /******************************************/
 422 /* decoding */
 423
 424 //#define DEBUG
 425
 426 #ifdef DEBUG
 427 #define dprintf(fmt,args...) printf(fmt, ## args)
 428 #else
 429 #define dprintf(fmt,args...)
 430 #endif
 431
 432 /* compressed picture size */
 433 #define PICTURE_BUFFER_SIZE 100000
 434
 435 #define MAX_COMPONENTS 4
 436
 437 typedef struct MJpegDecodeContext {
 438     GetBitContext gb;
 439     UINT32 header_state;
 440     int start_code; /* current start code */
 441     UINT8 *buf_ptr;
 442     int buffer_size;
 443     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
 444     INT16 quant_matrixes[4][64];
 445     VLC vlcs[2][4];
 446     int width, height;
 447     int nb_components;
 448     int component_id[MAX_COMPONENTS];
 449     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
 450     int v_count[MAX_COMPONENTS];
 451     int h_max, v_max; /* maximum h and v counts */
 452     int quant_index[4];   /* quant table index for each component */
 453     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
 454     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
 455     int linesize[MAX_COMPONENTS];
 456     DCTELEM block[64] __align8;
 457     UINT8 buffer[PICTURE_BUFFER_SIZE];
 458 } MJpegDecodeContext;
 459
 460 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
 461                       int nb_codes)
 462 {
 463     UINT8 huff_size[256];
 464     UINT16 huff_code[256];
 465
 466     memset(huff_size, 0, sizeof(huff_size));
 467     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 468
 469     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
 470 }
 471
 472 static int mjpeg_decode_init(AVCodecContext *avctx)
 473 {
 474     MJpegDecodeContext *s = avctx->priv_data;
 475
 476     s->header_state = 0;
 477     s->mpeg_enc_ctx_allocated = 0;
 478     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
 479                                                  account FF 00 case */
 480     s->start_code = -1;
 481     s->buf_ptr = s->buffer;
 482
 483     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
 484     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
 485     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
 486     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
 487     return 0;
 488 }
 489
 490 /* quantize tables */
 491 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
 492                             UINT8 *buf, int buf_size)
 493 {
 494     int len, index, i, j;
 495     init_get_bits(&s->gb, buf, buf_size);
 496
 497     len = get_bits(&s->gb, 16);
 498     len -= 2;
 499
 500     while (len >= 65) {
 501         /* only 8 bit precision handled */
 502         if (get_bits(&s->gb, 4) != 0)
 503             return -1;
 504         index = get_bits(&s->gb, 4);
 505         if (index >= 4)
 506             return -1;
 507         dprintf("index=%d\n", index);
 508         /* read quant table */
 509         for(i=0;i<64;i++) {
 510             j = zigzag_direct[i];
 511             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 512         }
 513         len -= 65;
 514     }
 515     return 0;
 516 }
 517
 518 /* decode huffman tables and build VLC decoders */
 519 static int mjpeg_decode_dht(MJpegDecodeContext *s,
 520                             UINT8 *buf, int buf_size)
 521 {
 522     int len, index, i, class, n, v, code_max;
 523     UINT8 bits_table[17];
 524     UINT8 val_table[256];
 525
 526     init_get_bits(&s->gb, buf, buf_size);
 527
 528     len = get_bits(&s->gb, 16);
 529     len -= 2;
 530
 531     while (len > 0) {
 532         if (len < 17)
 533             return -1;
 534         class = get_bits(&s->gb, 4);
 535         if (class >= 2)
 536             return -1;
 537         index = get_bits(&s->gb, 4);
 538         if (index >= 4)
 539             return -1;
 540         n = 0;
 541         for(i=1;i<=16;i++) {
 542             bits_table[i] = get_bits(&s->gb, 8);
 543             n += bits_table[i];
 544         }
 545         len -= 17;
 546         if (len < n || n > 256)
 547             return -1;
 548
 549         code_max = 0;
 550         for(i=0;i<n;i++) {
 551             v = get_bits(&s->gb, 8);
 552             if (v > code_max)
 553                 code_max = v;
 554             val_table[i] = v;
 555         }
 556         len -= n;
 557
 558         /* build VLC and flush previous vlc if present */
 559         free_vlc(&s->vlcs[class][index]);
 560         dprintf("class=%d index=%d nb_codes=%d\n",
 561                class, index, code_max + 1);
 562         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
 563     }
 564     return 0;
 565 }
 566
 567 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
 568                              UINT8 *buf, int buf_size)
 569 {
 570     int len, nb_components, i, width, height;
 571
 572     init_get_bits(&s->gb, buf, buf_size);
 573
 574     /* XXX: verify len field validity */
 575     len = get_bits(&s->gb, 16);
 576     /* only 8 bits/component accepted */
 577     if (get_bits(&s->gb, 8) != 8)
 578         return -1;
 579     height = get_bits(&s->gb, 16);
 580     width = get_bits(&s->gb, 16);
 581
 582     nb_components = get_bits(&s->gb, 8);
 583     if (nb_components <= 0 ||
 584         nb_components > MAX_COMPONENTS)
 585         return -1;
 586     s->nb_components = nb_components;
 587     s->h_max = 1;
 588     s->v_max = 1;
 589     for(i=0;i<nb_components;i++) {
 590         /* component id */
 591         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 592         s->h_count[i] = get_bits(&s->gb, 4);
 593         s->v_count[i] = get_bits(&s->gb, 4);
 594         /* compute hmax and vmax (only used in interleaved case) */
 595         if (s->h_count[i] > s->h_max)
 596             s->h_max = s->h_count[i];
 597         if (s->v_count[i] > s->v_max)
 598             s->v_max = s->v_count[i];
 599         s->quant_index[i] = get_bits(&s->gb, 8);
 600         if (s->quant_index[i] >= 4)
 601             return -1;
 602         dprintf("component %d %d:%d\n", i, s->h_count[i], s->v_count[i]);
 603     }
 604
 605     /* if different size, realloc/alloc picture */
 606     /* XXX: also check h_count and v_count */
 607     if (width != s->width || height != s->height) {
 608         for(i=0;i<MAX_COMPONENTS;i++) {
 609             free(s->current_picture[i]);
 610             s->current_picture[i] = NULL;
 611         }
 612         s->width = width;
 613         s->height = height;
 614         for(i=0;i<nb_components;i++) {
 615             int w, h, hh, vv;
 616             hh = s->h_max / s->h_count[i];
 617             vv = s->v_max / s->v_count[i];
 618             w = (s->width + 8 * hh - 1) / (8 * hh);
 619             h = (s->height + 8 * vv - 1) / (8 * vv);
 620             w = w * 8;
 621             h = h * 8;
 622             s->linesize[i] = w;
 623             /* memory test is done in mjpeg_decode_sos() */
 624             s->current_picture[i] = av_mallocz(w * h);
 625         }
 626     }
 627
 628     return 0;
 629 }
 630
 631 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
 632 {
 633     VLC *dc_vlc;
 634     int code, diff;
 635
 636     dc_vlc = &s->vlcs[0][dc_index];
 637     code = get_vlc(&s->gb, dc_vlc);
 638     if (code < 0)
 639         return 0xffff;
 640     if (code == 0) {
 641         diff = 0;
 642     } else {
 643         diff = get_bits(&s->gb, code);
 644         if ((diff & (1 << (code - 1))) == 0)
 645             diff = (-1 << code) | (diff + 1);
 646     }
 647     return diff;
 648 }
 649
 650 /* decode block and dequantize */
 651 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 652                         int component, int dc_index, int ac_index, int quant_index)
 653 {
 654     int nbits, code, i, j, level;
 655     int run, val;
 656     VLC *ac_vlc;
 657     INT16 *quant_matrix;
 658
 659     quant_matrix = s->quant_matrixes[quant_index];
 660     /* DC coef */
 661     val = decode_dc(s, dc_index);
 662     if (val == 0xffff) {
 663         dprintf("error dc\n");
 664         return -1;
 665     }
 666     val = val * quant_matrix[0] + s->last_dc[component];
 667     s->last_dc[component] = val;
 668     block[0] = val;
 669     /* AC coefs */
 670     ac_vlc = &s->vlcs[1][ac_index];
 671     i = 1;
 672     for(;;) {
 673         code = get_vlc(&s->gb, ac_vlc);
 674         if (code < 0) {
 675             dprintf("error ac\n");
 676             return -1;
 677         }
 678         /* EOB */
 679         if (code == 0)
 680             break;
 681         if (code == 0xf0) {
 682             i += 16;
 683         } else {
 684             run = code >> 4;
 685             nbits = code & 0xf;
 686             level = get_bits(&s->gb, nbits);
 687             if ((level & (1 << (nbits - 1))) == 0)
 688                 level = (-1 << nbits) | (level + 1);
 689             i += run;
 690             if (i >= 64) {
 691                 dprintf("error count: %d\n", i);
 692                 return -1;
 693             }
 694             j = zigzag_direct[i];
 695             block[j] = level * quant_matrix[j];
 696             i++;
 697             if (i >= 64)
 698                 break;
 699         }
 700     }
 701     return 0;
 702 }
 703
 704 static int mjpeg_decode_sos(MJpegDecodeContext *s,
 705                             UINT8 *buf, int buf_size)
 706 {
 707     int len, nb_components, i, j, n, h, v, ret;
 708     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 709     int comp_index[4];
 710     int dc_index[4];
 711     int ac_index[4];
 712     int nb_blocks[4];
 713     int h_count[4];
 714     int v_count[4];
 715
 716     init_get_bits(&s->gb, buf, buf_size);
 717     /* XXX: verify len field validity */
 718     len = get_bits(&s->gb, 16);
 719     nb_components = get_bits(&s->gb, 8);
 720     /* XXX: only interleaved scan accepted */
 721     if (nb_components != 3)
 722         return -1;
 723     vmax = 0;
 724     hmax = 0;
 725     for(i=0;i<nb_components;i++) {
 726         id = get_bits(&s->gb, 8) - 1;
 727         /* find component index */
 728         for(index=0;index<s->nb_components;index++)
 729             if (id == s->component_id[index])
 730                 break;
 731         if (index == s->nb_components)
 732             return -1;
 733
 734         comp_index[i] = index;
 735         nb_blocks[i] = s->h_count[index] * s->v_count[index];
 736         h_count[i] = s->h_count[index];
 737         v_count[i] = s->v_count[index];
 738
 739         dc_index[i] = get_bits(&s->gb, 4);
 740         if (dc_index[i] >= 4)
 741             return -1;
 742         ac_index[i] = get_bits(&s->gb, 4);
 743         if (ac_index[i] >= 4)
 744             return -1;
 745     }
 746     get_bits(&s->gb, 8); /* Ss */
 747     get_bits(&s->gb, 8); /* Se */
 748     get_bits(&s->gb, 8); /* not used */
 749
 750     for(i=0;i<nb_components;i++)
 751         s->last_dc[i] = 1024;
 752
 753     if (nb_components > 1) {
 754         /* interleaved stream */
 755         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
 756         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
 757     } else {
 758         h = s->h_max / s->h_count[comp_index[0]];
 759         v = s->v_max / s->v_count[comp_index[0]];
 760         mb_width = (s->width + h * 8 - 1) / (h * 8);
 761         mb_height = (s->height + v * 8 - 1) / (v * 8);
 762         nb_blocks[0] = 1;
 763         h_count[0] = 1;
 764         v_count[0] = 1;
 765     }
 766
 767     for(mb_y = 0; mb_y < mb_height; mb_y++) {
 768         for(mb_x = 0; mb_x < mb_width; mb_x++) {
 769             for(i=0;i<nb_components;i++) {
 770                 UINT8 *ptr;
 771                 int x, y, c;
 772                 n = nb_blocks[i];
 773                 c = comp_index[i];
 774                 h = h_count[i];
 775                 v = v_count[i];
 776                 x = 0;
 777                 y = 0;
 778                 for(j=0;j<n;j++) {
 779                     memset(s->block, 0, sizeof(s->block));
 780                     if (decode_block(s, s->block, i,
 781                                      dc_index[i], ac_index[i],
 782                                      s->quant_index[c]) < 0) {
 783                         dprintf("error %d %d\n", mb_y, mb_x);
 784                         ret = -1;
 785                         goto the_end;
 786                     }
 787                     ff_idct (s->block);
 788                     ptr = s->current_picture[c] +
 789                         (s->linesize[c] * (v * mb_y + y) * 8) +
 790                         (h * mb_x + x) * 8;
 791                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
 792                     if (++x == h) {
 793                         x = 0;
 794                         y++;
 795                     }
 796                 }
 797             }
 798         }
 799     }
 800     ret = 0;
 801  the_end:
 802     emms_c();
 803     return ret;
 804 }
 805
 806 /* return the 8 bit start code value and update the search
 807    state. Return -1 if no start code found */
 808 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end,
 809                        UINT32 *header_state)
 810 {
 811     UINT8 *buf_ptr;
 812     unsigned int state, v;
 813     int val;
 814
 815     state = *header_state;
 816     buf_ptr = *pbuf_ptr;
 817     if (state) {
 818         /* get marker */
 819     found:
 820         if (buf_ptr < buf_end) {
 821             val = *buf_ptr++;
 822             state = 0;
 823         } else {
 824             val = -1;
 825         }
 826     } else {
 827         while (buf_ptr < buf_end) {
 828             v = *buf_ptr++;
 829             if (v == 0xff) {
 830                 state = 1;
 831                 goto found;
 832             }
 833         }
 834         val = -1;
 835     }
 836     *pbuf_ptr = buf_ptr;
 837     *header_state = state;
 838     return val;
 839 }
 840
 841 static int mjpeg_decode_frame(AVCodecContext *avctx,
 842                               void *data, int *data_size,
 843                               UINT8 *buf, int buf_size)
 844 {
 845     MJpegDecodeContext *s = avctx->priv_data;
 846     UINT8 *buf_end, *buf_ptr, *buf_start;
 847     int len, code, start_code, input_size, i;
 848     AVPicture *picture = data;
 849
 850     /* no supplementary picture */
 851     if (buf_size == 0) {
 852         *data_size = 0;
 853         return 0;
 854     }
 855
 856     buf_ptr = buf;
 857     buf_end = buf + buf_size;
 858     while (buf_ptr < buf_end) {
 859         buf_start = buf_ptr;
 860         /* find start next marker */
 861         code = find_marker(&buf_ptr, buf_end, &s->header_state);
 862         /* copy to buffer */
 863         len = buf_ptr - buf_start;
 864         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
 865             /* data too big : flush */
 866             s->buf_ptr = s->buffer;
 867             if (code > 0)
 868                 s->start_code = code;
 869         } else {
 870             memcpy(s->buf_ptr, buf_start, len);
 871             s->buf_ptr += len;
 872             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
 873             if (code == 0) {
 874                 s->buf_ptr--;
 875             } else if (code > 0) {
 876                 /* prepare data for next start code */
 877                 input_size = s->buf_ptr - s->buffer;
 878                 start_code = s->start_code;
 879                 s->buf_ptr = s->buffer;
 880                 s->start_code = code;
 881                 dprintf("marker=%x\n", start_code);
 882                 switch(start_code) {
 883                 case SOI:
 884                     /* nothing to do on SOI */
 885                     break;
 886                 case DQT:
 887                     mjpeg_decode_dqt(s, s->buffer, input_size);
 888                     break;
 889                 case DHT:
 890                     mjpeg_decode_dht(s, s->buffer, input_size);
 891                     break;
 892                 case SOF0:
 893                     mjpeg_decode_sof0(s, s->buffer, input_size);
 894                     break;
 895                 case SOS:
 896                     mjpeg_decode_sos(s, s->buffer, input_size);
 897                     if (s->start_code == EOI) {
 898                         for(i=0;i<3;i++) {
 899                             picture->data[i] = s->current_picture[i];
 900                             picture->linesize[i] = s->linesize[i];
 901                         }
 902                         *data_size = sizeof(AVPicture);
 903                         avctx->height = s->height;
 904                         avctx->width = s->width;
 905                         /* XXX: not complete test ! */
 906                         switch((s->h_count[0] << 4) | s->v_count[0]) {
 907                         case 0x11:
 908                             avctx->pix_fmt = PIX_FMT_YUV444P;
 909                             break;
 910                         case 0x21:
 911                             avctx->pix_fmt = PIX_FMT_YUV422P;
 912                             break;
 913                         default:
 914                         case 0x22:
 915                             avctx->pix_fmt = PIX_FMT_YUV420P;
 916                             break;
 917                         }
 918                         /* dummy quality */
 919                         /* XXX: infer it with matrix */
 920                         avctx->quality = 3;
 921                         goto the_end;
 922                     }
 923                     break;
 924                 }
 925             }
 926         }
 927     }
 928  the_end:
 929     return buf_ptr - buf;
 930 }
 931
 932 static int mjpeg_decode_end(AVCodecContext *avctx)
 933 {
 934     MJpegDecodeContext *s = avctx->priv_data;
 935     int i, j;
 936
 937     for(i=0;i<MAX_COMPONENTS;i++)
 938         free(s->current_picture[i]);
 939     for(i=0;i<2;i++) {
 940         for(j=0;j<4;j++)
 941             free_vlc(&s->vlcs[i][j]);
 942     }
 943     return 0;
 944 }
 945
 946 AVCodec mjpeg_decoder = {
 947     "mjpeg",
 948     CODEC_TYPE_VIDEO,
 949     CODEC_ID_MJPEG,
 950     sizeof(MJpegDecodeContext),
 951     mjpeg_decode_init,
 952     NULL,
 953     mjpeg_decode_end,
 954     mjpeg_decode_frame,
 955 };