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 int mjpeg_decode_init(AVCodecContext *avctx)
 459 {
 460     MJpegDecodeContext *s = avctx->priv_data;
 461
 462     s->header_state = 0;
 463     s->mpeg_enc_ctx_allocated = 0;
 464     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
 465                                                  account FF 00 case */
 466     s->start_code = -1;
 467     s->buf_ptr = s->buffer;
 468     return 0;
 469 }
 470
 471 /* quantize tables */
 472 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
 473                             UINT8 *buf, int buf_size)
 474 {
 475     int len, index, i;
 476     init_get_bits(&s->gb, buf, buf_size);
 477
 478     len = get_bits(&s->gb, 16);
 479     len -= 2;
 480
 481     while (len >= 65) {
 482         /* only 8 bit precision handled */
 483         if (get_bits(&s->gb, 4) != 0)
 484             return -1;
 485         index = get_bits(&s->gb, 4);
 486         if (index >= 4)
 487             return -1;
 488         dprintf("index=%d\n", index);
 489         /* read quant table */
 490         for(i=0;i<64;i++)
 491             s->quant_matrixes[index][i] = get_bits(&s->gb, 8);
 492         len -= 65;
 493     }
 494     return 0;
 495 }
 496
 497 /* decode huffman tables and build VLC decoders */
 498 static int mjpeg_decode_dht(MJpegDecodeContext *s,
 499                             UINT8 *buf, int buf_size)
 500 {
 501     int len, index, i, class, n, v, code_max;
 502     UINT8 bits_table[17];
 503     UINT8 val_table[256];
 504     UINT8 huff_size[256];
 505     UINT16 huff_code[256];
 506
 507     init_get_bits(&s->gb, buf, buf_size);
 508
 509     len = get_bits(&s->gb, 16);
 510     len -= 2;
 511
 512     while (len > 0) {
 513         if (len < 17)
 514             return -1;
 515         class = get_bits(&s->gb, 4);
 516         if (class >= 2)
 517             return -1;
 518         index = get_bits(&s->gb, 4);
 519         if (index >= 4)
 520             return -1;
 521         n = 0;
 522         for(i=1;i<=16;i++) {
 523             bits_table[i] = get_bits(&s->gb, 8);
 524             n += bits_table[i];
 525         }
 526         len -= 17;
 527         if (len < n || n > 256)
 528             return -1;
 529
 530         code_max = 0;
 531         for(i=0;i<n;i++) {
 532             v = get_bits(&s->gb, 8);
 533             if (v > code_max)
 534                 code_max = v;
 535             val_table[i] = v;
 536         }
 537         len -= n;
 538
 539         /* now build size/code table */
 540         memset(huff_size, 0, sizeof(huff_size));
 541         build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 542
 543         /* build VLC and flush previous vlc if present */
 544         free_vlc(&s->vlcs[class][index]);
 545         dprintf("class=%d index=%d nb_codes=%d\n",
 546                class, index, code_max + 1);
 547         init_vlc(&s->vlcs[class][index], 9, code_max + 1,
 548                  huff_size, 1, 1,
 549                  huff_code, 2, 2);
 550     }
 551     return 0;
 552 }
 553
 554 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
 555                              UINT8 *buf, int buf_size)
 556 {
 557     int len, nb_components, i, width, height;
 558
 559     init_get_bits(&s->gb, buf, buf_size);
 560
 561     /* XXX: verify len field validity */
 562     len = get_bits(&s->gb, 16);
 563     /* only 8 bits/component accepted */
 564     if (get_bits(&s->gb, 8) != 8)
 565         return -1;
 566     height = get_bits(&s->gb, 16);
 567     width = get_bits(&s->gb, 16);
 568
 569     nb_components = get_bits(&s->gb, 8);
 570     if (nb_components <= 0 ||
 571         nb_components > MAX_COMPONENTS)
 572         return -1;
 573     s->nb_components = nb_components;
 574     s->h_max = 1;
 575     s->v_max = 1;
 576     for(i=0;i<nb_components;i++) {
 577         /* component id */
 578         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 579         s->h_count[i] = get_bits(&s->gb, 4);
 580         s->v_count[i] = get_bits(&s->gb, 4);
 581         /* compute hmax and vmax (only used in interleaved case) */
 582         if (s->h_count[i] > s->h_max)
 583             s->h_max = s->h_count[i];
 584         if (s->v_count[i] > s->v_max)
 585             s->v_max = s->v_count[i];
 586 #if 1
 587         /* XXX: only 420 is accepted */
 588         if ((i == 0 && (s->h_count[i] != 2 || s->v_count[i] != 2)) ||
 589             (i != 0 && (s->h_count[i] != 1 || s->v_count[i] != 1)))
 590             return -1;
 591 #endif
 592         s->quant_index[i] = get_bits(&s->gb, 8);
 593         if (s->quant_index[i] >= 4)
 594             return -1;
 595         dprintf("component %d %d:%d\n", i, s->h_count[i], s->v_count[i]);
 596     }
 597
 598     /* if different size, realloc/alloc picture */
 599     /* XXX: also check h_count and v_count */
 600     if (width != s->width || height != s->height) {
 601         for(i=0;i<MAX_COMPONENTS;i++) {
 602             free(s->current_picture[i]);
 603             s->current_picture[i] = NULL;
 604         }
 605         s->width = width;
 606         s->height = height;
 607         for(i=0;i<nb_components;i++) {
 608             int w, h, hh, vv;
 609             hh = s->h_max / s->h_count[i];
 610             vv = s->v_max / s->v_count[i];
 611             w = (s->width + 8 * hh - 1) / (8 * hh);
 612             h = (s->height + 8 * vv - 1) / (8 * vv);
 613             w = w * 8;
 614             h = h * 8;
 615             s->linesize[i] = w;
 616             /* memory test is done in mjpeg_decode_sos() */
 617             s->current_picture[i] = av_mallocz(w * h);
 618         }
 619     }
 620
 621     return 0;
 622 }
 623
 624 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
 625 {
 626     VLC *dc_vlc;
 627     int code, diff;
 628
 629     dc_vlc = &s->vlcs[0][dc_index];
 630     code = get_vlc(&s->gb, dc_vlc);
 631     if (code < 0)
 632         return 0xffff;
 633     if (code == 0) {
 634         diff = 0;
 635     } else {
 636         diff = get_bits(&s->gb, code);
 637         if ((diff & (1 << (code - 1))) == 0)
 638             diff = (-1 << code) | (diff + 1);
 639     }
 640     return diff;
 641 }
 642
 643 /* decode block and dequantize */
 644 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
 645                         int component, int dc_index, int ac_index, int quant_index)
 646 {
 647     int nbits, code, i, j, level;
 648     int run, val;
 649     VLC *ac_vlc;
 650     INT16 *quant_matrix;
 651
 652     quant_matrix = s->quant_matrixes[quant_index];
 653     /* DC coef */
 654     val = decode_dc(s, dc_index);
 655     if (val == 0xffff) {
 656         dprintf("error dc\n");
 657         return -1;
 658     }
 659     val = val * quant_matrix[0] + s->last_dc[component];
 660     s->last_dc[component] = val;
 661     block[0] = val;
 662
 663     /* AC coefs */
 664     ac_vlc = &s->vlcs[1][ac_index];
 665     i = 1;
 666     for(;;) {
 667         code = get_vlc(&s->gb, ac_vlc);
 668         if (code < 0) {
 669             dprintf("error ac\n");
 670             return -1;
 671         }
 672         /* EOB */
 673         if (code == 0)
 674             break;
 675         if (code == 0xf0) {
 676             i += 16;
 677         } else {
 678             run = code >> 4;
 679             nbits = code & 0xf;
 680             level = get_bits(&s->gb, nbits);
 681             if ((level & (1 << (nbits - 1))) == 0)
 682                 level = (-1 << nbits) | (level + 1);
 683             i += run;
 684             if (i >= 64) {
 685                 dprintf("error count: %d\n", i);
 686                 return -1;
 687             }
 688             j = zigzag_direct[i];
 689             block[j] = level * quant_matrix[j];
 690             i++;
 691         }
 692     }
 693     return 0;
 694 }
 695
 696 static int mjpeg_decode_sos(MJpegDecodeContext *s,
 697                             UINT8 *buf, int buf_size)
 698 {
 699     int len, nb_components, i, j, n, h, v;
 700     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
 701     int comp_index[4];
 702     int dc_index[4];
 703     int ac_index[4];
 704     int nb_blocks[4];
 705     int h_count[4];
 706     int v_count[4];
 707
 708     init_get_bits(&s->gb, buf, buf_size);
 709     /* XXX: verify len field validity */
 710     len = get_bits(&s->gb, 16);
 711     nb_components = get_bits(&s->gb, 8);
 712     /* XXX: only interleaved scan accepted */
 713     if (nb_components != 3)
 714         return -1;
 715     vmax = 0;
 716     hmax = 0;
 717     for(i=0;i<nb_components;i++) {
 718         id = get_bits(&s->gb, 8) - 1;
 719         /* find component index */
 720         for(index=0;index<s->nb_components;index++)
 721             if (id == s->component_id[index])
 722                 break;
 723         if (index == s->nb_components)
 724             return -1;
 725
 726         comp_index[i] = index;
 727         nb_blocks[i] = s->h_count[index] * s->v_count[index];
 728         h_count[i] = s->h_count[index];
 729         v_count[i] = s->v_count[index];
 730
 731         dc_index[i] = get_bits(&s->gb, 4);
 732         if (dc_index[i] >= 4)
 733             return -1;
 734         ac_index[i] = get_bits(&s->gb, 4);
 735         if (ac_index[i] >= 4)
 736             return -1;
 737     }
 738     get_bits(&s->gb, 8); /* Ss */
 739     get_bits(&s->gb, 8); /* Se */
 740     get_bits(&s->gb, 8); /* not used */
 741
 742     for(i=0;i<nb_components;i++)
 743         s->last_dc[i] = 1024;
 744
 745     if (nb_components > 1) {
 746         /* interleaved stream */
 747         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
 748         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
 749     } else {
 750         h = s->h_max / s->h_count[comp_index[0]];
 751         v = s->v_max / s->v_count[comp_index[0]];
 752         mb_width = (s->width + h * 8 - 1) / (h * 8);
 753         mb_height = (s->height + v * 8 - 1) / (v * 8);
 754         nb_blocks[0] = 1;
 755         h_count[0] = 1;
 756         v_count[0] = 1;
 757     }
 758
 759     for(mb_y = 0; mb_y < mb_height; mb_y++) {
 760         for(mb_x = 0; mb_x < mb_width; mb_x++) {
 761             for(i=0;i<nb_components;i++) {
 762                 UINT8 *ptr;
 763                 int x, y, c;
 764                 n = nb_blocks[i];
 765                 c = comp_index[i];
 766                 h = h_count[i];
 767                 v = v_count[i];
 768                 x = 0;
 769                 y = 0;
 770                 for(j=0;j<n;j++) {
 771                     memset(s->block, 0, sizeof(s->block));
 772                     if (decode_block(s, s->block, i,
 773                                      dc_index[i], ac_index[i],
 774                                      s->quant_index[c]) < 0) {
 775                         dprintf("error %d %d\n", mb_y, mb_x);
 776                         return -1;
 777                     }
 778                     ff_idct (s->block);
 779                     ptr = s->current_picture[c] +
 780                         (s->linesize[c] * (v * mb_y + y) * 8) +
 781                         (h * mb_x + x) * 8;
 782                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
 783                     if (++x == h) {
 784                         x = 0;
 785                         y++;
 786                     }
 787                 }
 788             }
 789         }
 790     }
 791     return 0;
 792 }
 793
 794 /* return the 8 bit start code value and update the search
 795    state. Return -1 if no start code found */
 796 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end,
 797                        UINT32 *header_state)
 798 {
 799     UINT8 *buf_ptr;
 800     unsigned int state, v;
 801     int val;
 802
 803     state = *header_state;
 804     buf_ptr = *pbuf_ptr;
 805     if (state) {
 806         /* get marker */
 807     found:
 808         if (buf_ptr < buf_end) {
 809             val = *buf_ptr++;
 810             state = 0;
 811         } else {
 812             val = -1;
 813         }
 814     } else {
 815         while (buf_ptr < buf_end) {
 816             v = *buf_ptr++;
 817             if (v == 0xff) {
 818                 state = 1;
 819                 goto found;
 820             }
 821         }
 822         val = -1;
 823     }
 824     *pbuf_ptr = buf_ptr;
 825     *header_state = state;
 826     return val;
 827 }
 828
 829 static int mjpeg_decode_frame(AVCodecContext *avctx,
 830                               void *data, int *data_size,
 831                               UINT8 *buf, int buf_size)
 832 {
 833     MJpegDecodeContext *s = avctx->priv_data;
 834     UINT8 *buf_end, *buf_ptr, *buf_start;
 835     int len, code, start_code, input_size, i;
 836     AVPicture *picture = data;
 837
 838     /* no supplementary picture */
 839     if (buf_size == 0) {
 840         *data_size = 0;
 841         return 0;
 842     }
 843
 844     buf_ptr = buf;
 845     buf_end = buf + buf_size;
 846     while (buf_ptr < buf_end) {
 847         buf_start = buf_ptr;
 848         /* find start next marker */
 849         code = find_marker(&buf_ptr, buf_end, &s->header_state);
 850         /* copy to buffer */
 851         len = buf_ptr - buf_start;
 852         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
 853             /* data too big : flush */
 854             s->buf_ptr = s->buffer;
 855             if (code > 0)
 856                 s->start_code = code;
 857         } else {
 858             memcpy(s->buf_ptr, buf_start, len);
 859             s->buf_ptr += len;
 860             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
 861             if (code == 0) {
 862                 s->buf_ptr--;
 863             } else if (code > 0) {
 864                 /* prepare data for next start code */
 865                 input_size = s->buf_ptr - s->buffer;
 866                 start_code = s->start_code;
 867                 s->buf_ptr = s->buffer;
 868                 s->start_code = code;
 869                 switch(start_code) {
 870                 case SOI:
 871                     /* nothing to do on SOI */
 872                     break;
 873                 case DQT:
 874                     mjpeg_decode_dqt(s, s->buffer, input_size);
 875                     break;
 876                 case DHT:
 877                     mjpeg_decode_dht(s, s->buffer, input_size);
 878                     break;
 879                 case SOF0:
 880                     mjpeg_decode_sof0(s, s->buffer, input_size);
 881                     break;
 882                 case SOS:
 883                     mjpeg_decode_sos(s, s->buffer, input_size);
 884                     if (s->start_code == EOI) {
 885                         /* XXX: YUV420 hardcoded */
 886                         for(i=0;i<3;i++) {
 887                             picture->data[i] = s->current_picture[i];
 888                             picture->linesize[i] = s->linesize[i];
 889                         }
 890                         *data_size = sizeof(AVPicture);
 891                         avctx->height = s->height;
 892                         avctx->width = s->width;
 893                         avctx->pix_fmt = PIX_FMT_YUV420P;
 894                         goto the_end;
 895                     }
 896                     break;
 897                 }
 898             }
 899         }
 900     }
 901  the_end:
 902     return buf_ptr - buf;
 903 }
 904
 905 static int mjpeg_decode_end(AVCodecContext *avctx)
 906 {
 907     MJpegDecodeContext *s = avctx->priv_data;
 908     int i, j;
 909
 910     for(i=0;i<MAX_COMPONENTS;i++)
 911         free(s->current_picture[i]);
 912     for(i=0;i<2;i++) {
 913         for(j=0;j<4;j++)
 914             free_vlc(&s->vlcs[i][j]);
 915     }
 916     return 0;
 917 }
 918
 919 AVCodec mjpeg_decoder = {
 920     "mjpeg",
 921     CODEC_TYPE_VIDEO,
 922     CODEC_ID_MJPEG,
 923     sizeof(MJpegDecodeContext),
 924     mjpeg_decode_init,
 925     NULL,
 926     mjpeg_decode_end,
 927     mjpeg_decode_frame,
 928 };