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

   1 /*
   2  * MJPEG encoder and decoder
   3  * Copyright (c) 2000, 2001 Fabrice Bellard.
   4  * Copyright (c) 2003 Alex Beregszaszi
   5  * Copyright (c) 2003-2004 Michael Niedermayer
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  * Support for external huffman table, various fixes (AVID workaround),
  24  * aspecting, new decode_frame mechanism and apple mjpeg-b support
  25  *                                  by Alex Beregszaszi
  26  */
  27
  28 /**
  29  * @file mjpeg.c
  30  * MJPEG encoder and decoder.
  31  */
  32
  33 //#define DEBUG
  34 #include <assert.h>
  35
  36 #include "avcodec.h"
  37 #include "dsputil.h"
  38 #include "mpegvideo.h"
  39 #include "bytestream.h"
  40 #include "mjpeg.h"
  41 #include "jpeglsdec.h"
  42
  43 /* use two quantizer tables (one for luminance and one for chrominance) */
  44 /* not yet working */
  45 #undef TWOMATRIXES
  46
  47 typedef struct MJpegContext {
  48     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
  49     uint16_t huff_code_dc_luminance[12];
  50     uint8_t huff_size_dc_chrominance[12];
  51     uint16_t huff_code_dc_chrominance[12];
  52
  53     uint8_t huff_size_ac_luminance[256];
  54     uint16_t huff_code_ac_luminance[256];
  55     uint8_t huff_size_ac_chrominance[256];
  56     uint16_t huff_code_ac_chrominance[256];
  57 } MJpegContext;
  58
  59 #if 0
  60 /* These are the sample quantization tables given in JPEG spec section K.1.
  61  * The spec says that the values given produce "good" quality, and
  62  * when divided by 2, "very good" quality.
  63  */
  64 static const unsigned char std_luminance_quant_tbl[64] = {
  65     16,  11,  10,  16,  24,  40,  51,  61,
  66     12,  12,  14,  19,  26,  58,  60,  55,
  67     14,  13,  16,  24,  40,  57,  69,  56,
  68     14,  17,  22,  29,  51,  87,  80,  62,
  69     18,  22,  37,  56,  68, 109, 103,  77,
  70     24,  35,  55,  64,  81, 104, 113,  92,
  71     49,  64,  78,  87, 103, 121, 120, 101,
  72     72,  92,  95,  98, 112, 100, 103,  99
  73 };
  74 static const unsigned char std_chrominance_quant_tbl[64] = {
  75     17,  18,  24,  47,  99,  99,  99,  99,
  76     18,  21,  26,  66,  99,  99,  99,  99,
  77     24,  26,  56,  99,  99,  99,  99,  99,
  78     47,  66,  99,  99,  99,  99,  99,  99,
  79     99,  99,  99,  99,  99,  99,  99,  99,
  80     99,  99,  99,  99,  99,  99,  99,  99,
  81     99,  99,  99,  99,  99,  99,  99,  99,
  82     99,  99,  99,  99,  99,  99,  99,  99
  83 };
  84 #endif
  85
  86 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
  87 /* IMPORTANT: these are only valid for 8-bit data precision! */
  88 static const uint8_t bits_dc_luminance[17] =
  89 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
  90 static const uint8_t val_dc_luminance[] =
  91 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  92
  93 static const uint8_t bits_dc_chrominance[17] =
  94 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
  95 static const uint8_t val_dc_chrominance[] =
  96 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  97
  98 static const uint8_t bits_ac_luminance[17] =
  99 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
 100 static const uint8_t val_ac_luminance[] =
 101 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 102   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 103   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 104   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 105   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 106   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 107   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 108   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 109   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 110   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 111   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 112   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 113   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 114   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 115   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 116   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 117   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 118   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 119   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 120   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 121   0xf9, 0xfa
 122 };
 123
 124 static const uint8_t bits_ac_chrominance[17] =
 125 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
 126
 127 static const uint8_t val_ac_chrominance[] =
 128 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
 129   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
 130   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
 131   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
 132   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
 133   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
 134   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
 135   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
 136   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
 137   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
 138   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
 139   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 140   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
 141   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
 142   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
 143   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
 144   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
 145   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
 146   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
 147   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 148   0xf9, 0xfa
 149 };
 150
 151 /* isn't this function nicer than the one in the libjpeg ? */
 152 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
 153                                 const uint8_t *bits_table, const uint8_t *val_table)
 154 {
 155     int i, j, k,nb, code, sym;
 156
 157     code = 0;
 158     k = 0;
 159     for(i=1;i<=16;i++) {
 160         nb = bits_table[i];
 161         for(j=0;j<nb;j++) {
 162             sym = val_table[k++];
 163             huff_size[sym] = i;
 164             huff_code[sym] = code;
 165             code++;
 166         }
 167         code <<= 1;
 168     }
 169 }
 170
 171 #ifdef CONFIG_ENCODERS
 172 int mjpeg_init(MpegEncContext *s)
 173 {
 174     MJpegContext *m;
 175
 176     m = av_malloc(sizeof(MJpegContext));
 177     if (!m)
 178         return -1;
 179
 180     s->min_qcoeff=-1023;
 181     s->max_qcoeff= 1023;
 182
 183     /* build all the huffman tables */
 184     build_huffman_codes(m->huff_size_dc_luminance,
 185                         m->huff_code_dc_luminance,
 186                         bits_dc_luminance,
 187                         val_dc_luminance);
 188     build_huffman_codes(m->huff_size_dc_chrominance,
 189                         m->huff_code_dc_chrominance,
 190                         bits_dc_chrominance,
 191                         val_dc_chrominance);
 192     build_huffman_codes(m->huff_size_ac_luminance,
 193                         m->huff_code_ac_luminance,
 194                         bits_ac_luminance,
 195                         val_ac_luminance);
 196     build_huffman_codes(m->huff_size_ac_chrominance,
 197                         m->huff_code_ac_chrominance,
 198                         bits_ac_chrominance,
 199                         val_ac_chrominance);
 200
 201     s->mjpeg_ctx = m;
 202     return 0;
 203 }
 204
 205 void mjpeg_close(MpegEncContext *s)
 206 {
 207     av_free(s->mjpeg_ctx);
 208 }
 209 #endif //CONFIG_ENCODERS
 210
 211 #define PREDICT(ret, topleft, top, left, predictor)\
 212     switch(predictor){\
 213         case 1: ret= left; break;\
 214         case 2: ret= top; break;\
 215         case 3: ret= topleft; break;\
 216         case 4: ret= left   +   top - topleft; break;\
 217         case 5: ret= left   + ((top - topleft)>>1); break;\
 218         case 6: ret= top + ((left   - topleft)>>1); break;\
 219         default:\
 220         case 7: ret= (left + top)>>1; break;\
 221     }
 222
 223 #ifdef CONFIG_ENCODERS
 224 /* table_class: 0 = DC coef, 1 = AC coefs */
 225 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
 226                              const uint8_t *bits_table, const uint8_t *value_table)
 227 {
 228     PutBitContext *p = &s->pb;
 229     int n, i;
 230
 231     put_bits(p, 4, table_class);
 232     put_bits(p, 4, table_id);
 233
 234     n = 0;
 235     for(i=1;i<=16;i++) {
 236         n += bits_table[i];
 237         put_bits(p, 8, bits_table[i]);
 238     }
 239
 240     for(i=0;i<n;i++)
 241         put_bits(p, 8, value_table[i]);
 242
 243     return n + 17;
 244 }
 245
 246 static void jpeg_table_header(MpegEncContext *s)
 247 {
 248     PutBitContext *p = &s->pb;
 249     int i, j, size;
 250     uint8_t *ptr;
 251
 252     /* quant matrixes */
 253     put_marker(p, DQT);
 254 #ifdef TWOMATRIXES
 255     put_bits(p, 16, 2 + 2 * (1 + 64));
 256 #else
 257     put_bits(p, 16, 2 + 1 * (1 + 64));
 258 #endif
 259     put_bits(p, 4, 0); /* 8 bit precision */
 260     put_bits(p, 4, 0); /* table 0 */
 261     for(i=0;i<64;i++) {
 262         j = s->intra_scantable.permutated[i];
 263         put_bits(p, 8, s->intra_matrix[j]);
 264     }
 265 #ifdef TWOMATRIXES
 266     put_bits(p, 4, 0); /* 8 bit precision */
 267     put_bits(p, 4, 1); /* table 1 */
 268     for(i=0;i<64;i++) {
 269         j = s->intra_scantable.permutated[i];
 270         put_bits(p, 8, s->chroma_intra_matrix[j]);
 271     }
 272 #endif
 273
 274     /* huffman table */
 275     put_marker(p, DHT);
 276     flush_put_bits(p);
 277     ptr = pbBufPtr(p);
 278     put_bits(p, 16, 0); /* patched later */
 279     size = 2;
 280     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
 281     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
 282
 283     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
 284     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
 285     ptr[0] = size >> 8;
 286     ptr[1] = size;
 287 }
 288
 289 static void jpeg_put_comments(MpegEncContext *s)
 290 {
 291     PutBitContext *p = &s->pb;
 292     int size;
 293     uint8_t *ptr;
 294
 295     if (s->aspect_ratio_info /* && !lossless */)
 296     {
 297     /* JFIF header */
 298     put_marker(p, APP0);
 299     put_bits(p, 16, 16);
 300     ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
 301     put_bits(p, 16, 0x0201); /* v 1.02 */
 302     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
 303     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
 304     put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
 305     put_bits(p, 8, 0); /* thumbnail width */
 306     put_bits(p, 8, 0); /* thumbnail height */
 307     }
 308
 309     /* comment */
 310     if(!(s->flags & CODEC_FLAG_BITEXACT)){
 311         put_marker(p, COM);
 312         flush_put_bits(p);
 313         ptr = pbBufPtr(p);
 314         put_bits(p, 16, 0); /* patched later */
 315         ff_put_string(p, LIBAVCODEC_IDENT, 1);
 316         size = strlen(LIBAVCODEC_IDENT)+3;
 317         ptr[0] = size >> 8;
 318         ptr[1] = size;
 319     }
 320
 321     if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
 322        ||s->avctx->pix_fmt == PIX_FMT_YUV422P
 323        ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
 324         put_marker(p, COM);
 325         flush_put_bits(p);
 326         ptr = pbBufPtr(p);
 327         put_bits(p, 16, 0); /* patched later */
 328         ff_put_string(p, "CS=ITU601", 1);
 329         size = strlen("CS=ITU601")+3;
 330         ptr[0] = size >> 8;
 331         ptr[1] = size;
 332     }
 333 }
 334
 335 void mjpeg_picture_header(MpegEncContext *s)
 336 {
 337     const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
 338
 339     put_marker(&s->pb, SOI);
 340
 341     jpeg_put_comments(s);
 342
 343     jpeg_table_header(s);
 344
 345     switch(s->avctx->codec_id){
 346     case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
 347     case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
 348     default: assert(0);
 349     }
 350
 351     put_bits(&s->pb, 16, 17);
 352     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)
 353         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
 354     else
 355         put_bits(&s->pb, 8, 8); /* 8 bits/component */
 356     put_bits(&s->pb, 16, s->height);
 357     put_bits(&s->pb, 16, s->width);
 358     put_bits(&s->pb, 8, 3); /* 3 components */
 359
 360     /* Y component */
 361     put_bits(&s->pb, 8, 1); /* component number */
 362     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
 363     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
 364     put_bits(&s->pb, 8, 0); /* select matrix */
 365
 366     /* Cb component */
 367     put_bits(&s->pb, 8, 2); /* component number */
 368     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
 369     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
 370 #ifdef TWOMATRIXES
 371     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 372 #else
 373     put_bits(&s->pb, 8, 0); /* select matrix */
 374 #endif
 375
 376     /* Cr component */
 377     put_bits(&s->pb, 8, 3); /* component number */
 378     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
 379     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
 380 #ifdef TWOMATRIXES
 381     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
 382 #else
 383     put_bits(&s->pb, 8, 0); /* select matrix */
 384 #endif
 385
 386     /* scan header */
 387     put_marker(&s->pb, SOS);
 388     put_bits(&s->pb, 16, 12); /* length */
 389     put_bits(&s->pb, 8, 3); /* 3 components */
 390
 391     /* Y component */
 392     put_bits(&s->pb, 8, 1); /* index */
 393     put_bits(&s->pb, 4, 0); /* DC huffman table index */
 394     put_bits(&s->pb, 4, 0); /* AC huffman table index */
 395
 396     /* Cb component */
 397     put_bits(&s->pb, 8, 2); /* index */
 398     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 399     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 400
 401     /* Cr component */
 402     put_bits(&s->pb, 8, 3); /* index */
 403     put_bits(&s->pb, 4, 1); /* DC huffman table index */
 404     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
 405
 406     put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
 407
 408     switch(s->avctx->codec_id){
 409     case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
 410     case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
 411     default: assert(0);
 412     }
 413
 414     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 415 }
 416
 417 static void escape_FF(MpegEncContext *s, int start)
 418 {
 419     int size= put_bits_count(&s->pb) - start*8;
 420     int i, ff_count;
 421     uint8_t *buf= s->pb.buf + start;
 422     int align= (-(size_t)(buf))&3;
 423
 424     assert((size&7) == 0);
 425     size >>= 3;
 426
 427     ff_count=0;
 428     for(i=0; i<size && i<align; i++){
 429         if(buf[i]==0xFF) ff_count++;
 430     }
 431     for(; i<size-15; i+=16){
 432         int acc, v;
 433
 434         v= *(uint32_t*)(&buf[i]);
 435         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 436         v= *(uint32_t*)(&buf[i+4]);
 437         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 438         v= *(uint32_t*)(&buf[i+8]);
 439         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 440         v= *(uint32_t*)(&buf[i+12]);
 441         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
 442
 443         acc>>=4;
 444         acc+= (acc>>16);
 445         acc+= (acc>>8);
 446         ff_count+= acc&0xFF;
 447     }
 448     for(; i<size; i++){
 449         if(buf[i]==0xFF) ff_count++;
 450     }
 451
 452     if(ff_count==0) return;
 453
 454     /* skip put bits */
 455     for(i=0; i<ff_count-3; i+=4)
 456         put_bits(&s->pb, 32, 0);
 457     put_bits(&s->pb, (ff_count-i)*8, 0);
 458     flush_put_bits(&s->pb);
 459
 460     for(i=size-1; ff_count; i--){
 461         int v= buf[i];
 462
 463         if(v==0xFF){
 464 //printf("%d %d\n", i, ff_count);
 465             buf[i+ff_count]= 0;
 466             ff_count--;
 467         }
 468
 469         buf[i+ff_count]= v;
 470     }
 471 }
 472
 473 void ff_mjpeg_stuffing(PutBitContext * pbc)
 474 {
 475     int length;
 476     length= (-put_bits_count(pbc))&7;
 477     if(length) put_bits(pbc, length, (1<<length)-1);
 478 }
 479
 480 void mjpeg_picture_trailer(MpegEncContext *s)
 481 {
 482     ff_mjpeg_stuffing(&s->pb);
 483     flush_put_bits(&s->pb);
 484
 485     assert((s->header_bits&7)==0);
 486
 487     escape_FF(s, s->header_bits>>3);
 488
 489     put_marker(&s->pb, EOI);
 490 }
 491
 492 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
 493                                    uint8_t *huff_size, uint16_t *huff_code)
 494 {
 495     int mant, nbits;
 496
 497     if (val == 0) {
 498         put_bits(&s->pb, huff_size[0], huff_code[0]);
 499     } else {
 500         mant = val;
 501         if (val < 0) {
 502             val = -val;
 503             mant--;
 504         }
 505
 506         nbits= av_log2_16bit(val) + 1;
 507
 508         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
 509
 510         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 511     }
 512 }
 513
 514 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
 515 {
 516     int mant, nbits, code, i, j;
 517     int component, dc, run, last_index, val;
 518     MJpegContext *m = s->mjpeg_ctx;
 519     uint8_t *huff_size_ac;
 520     uint16_t *huff_code_ac;
 521
 522     /* DC coef */
 523     component = (n <= 3 ? 0 : (n&1) + 1);
 524     dc = block[0]; /* overflow is impossible */
 525     val = dc - s->last_dc[component];
 526     if (n < 4) {
 527         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
 528         huff_size_ac = m->huff_size_ac_luminance;
 529         huff_code_ac = m->huff_code_ac_luminance;
 530     } else {
 531         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 532         huff_size_ac = m->huff_size_ac_chrominance;
 533         huff_code_ac = m->huff_code_ac_chrominance;
 534     }
 535     s->last_dc[component] = dc;
 536
 537     /* AC coefs */
 538
 539     run = 0;
 540     last_index = s->block_last_index[n];
 541     for(i=1;i<=last_index;i++) {
 542         j = s->intra_scantable.permutated[i];
 543         val = block[j];
 544         if (val == 0) {
 545             run++;
 546         } else {
 547             while (run >= 16) {
 548                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
 549                 run -= 16;
 550             }
 551             mant = val;
 552             if (val < 0) {
 553                 val = -val;
 554                 mant--;
 555             }
 556
 557             nbits= av_log2(val) + 1;
 558             code = (run << 4) | nbits;
 559
 560             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
 561
 562             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
 563             run = 0;
 564         }
 565     }
 566
 567     /* output EOB only if not already 64 values */
 568     if (last_index < 63 || run != 0)
 569         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
 570 }
 571
 572 void mjpeg_encode_mb(MpegEncContext *s,
 573                      DCTELEM block[6][64])
 574 {
 575     int i;
 576     for(i=0;i<5;i++) {
 577         encode_block(s, block[i], i);
 578     }
 579     if (s->chroma_format == CHROMA_420) {
 580         encode_block(s, block[5], 5);
 581     } else {
 582         encode_block(s, block[6], 6);
 583         encode_block(s, block[5], 5);
 584         encode_block(s, block[7], 7);
 585     }
 586 }
 587
 588 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 589     MpegEncContext * const s = avctx->priv_data;
 590     MJpegContext * const m = s->mjpeg_ctx;
 591     AVFrame *pict = data;
 592     const int width= s->width;
 593     const int height= s->height;
 594     AVFrame * const p= (AVFrame*)&s->current_picture;
 595     const int predictor= avctx->prediction_method+1;
 596
 597     init_put_bits(&s->pb, buf, buf_size);
 598
 599     *p = *pict;
 600     p->pict_type= FF_I_TYPE;
 601     p->key_frame= 1;
 602
 603     mjpeg_picture_header(s);
 604
 605     s->header_bits= put_bits_count(&s->pb);
 606
 607     if(avctx->pix_fmt == PIX_FMT_RGB32){
 608         int x, y, i;
 609         const int linesize= p->linesize[0];
 610         uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
 611         int left[3], top[3], topleft[3];
 612
 613         for(i=0; i<3; i++){
 614             buffer[0][i]= 1 << (9 - 1);
 615         }
 616
 617         for(y = 0; y < height; y++) {
 618             const int modified_predictor= y ? predictor : 1;
 619             uint8_t *ptr = p->data[0] + (linesize * y);
 620
 621             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
 622                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 623                 return -1;
 624             }
 625
 626             for(i=0; i<3; i++){
 627                 top[i]= left[i]= topleft[i]= buffer[0][i];
 628             }
 629             for(x = 0; x < width; x++) {
 630                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
 631                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
 632                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
 633
 634                 for(i=0;i<3;i++) {
 635                     int pred, diff;
 636
 637                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
 638
 639                     topleft[i]= top[i];
 640                     top[i]= buffer[x+1][i];
 641
 642                     left[i]= buffer[x][i];
 643
 644                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
 645
 646                     if(i==0)
 647                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 648                     else
 649                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 650                 }
 651             }
 652         }
 653     }else{
 654         int mb_x, mb_y, i;
 655         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
 656         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
 657
 658         for(mb_y = 0; mb_y < mb_height; mb_y++) {
 659             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){
 660                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 661                 return -1;
 662             }
 663             for(mb_x = 0; mb_x < mb_width; mb_x++) {
 664                 if(mb_x==0 || mb_y==0){
 665                     for(i=0;i<3;i++) {
 666                         uint8_t *ptr;
 667                         int x, y, h, v, linesize;
 668                         h = s->mjpeg_hsample[i];
 669                         v = s->mjpeg_vsample[i];
 670                         linesize= p->linesize[i];
 671
 672                         for(y=0; y<v; y++){
 673                             for(x=0; x<h; x++){
 674                                 int pred;
 675
 676                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 677                                 if(y==0 && mb_y==0){
 678                                     if(x==0 && mb_x==0){
 679                                         pred= 128;
 680                                     }else{
 681                                         pred= ptr[-1];
 682                                     }
 683                                 }else{
 684                                     if(x==0 && mb_x==0){
 685                                         pred= ptr[-linesize];
 686                                     }else{
 687                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 688                                     }
 689                                 }
 690
 691                                 if(i==0)
 692                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 693                                 else
 694                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 695                             }
 696                         }
 697                     }
 698                 }else{
 699                     for(i=0;i<3;i++) {
 700                         uint8_t *ptr;
 701                         int x, y, h, v, linesize;
 702                         h = s->mjpeg_hsample[i];
 703                         v = s->mjpeg_vsample[i];
 704                         linesize= p->linesize[i];
 705
 706                         for(y=0; y<v; y++){
 707                             for(x=0; x<h; x++){
 708                                 int pred;
 709
 710                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
 711 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
 712                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
 713
 714                                 if(i==0)
 715                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
 716                                 else
 717                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
 718                             }
 719                         }
 720                     }
 721                 }
 722             }
 723         }
 724     }
 725
 726     emms_c();
 727
 728     mjpeg_picture_trailer(s);
 729     s->picture_number++;
 730
 731     flush_put_bits(&s->pb);
 732     return pbBufPtr(&s->pb) - s->pb.buf;
 733 //    return (put_bits_count(&f->pb)+7)/8;
 734 }
 735
 736 #endif //CONFIG_ENCODERS
 737
 738 /******************************************/
 739 /* decoding */
 740
 741 static int mjpeg_decode_dht(MJpegDecodeContext *s);
 742
 743 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
 744                       int nb_codes, int use_static, int is_ac)
 745 {
 746     uint8_t huff_size[256+16];
 747     uint16_t huff_code[256+16];
 748
 749     assert(nb_codes <= 256);
 750
 751     memset(huff_size, 0, sizeof(huff_size));
 752     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
 753
 754     if(is_ac){
 755         memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
 756         memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
 757         memset(huff_size, 0, sizeof(uint8_t)*16);
 758         memset(huff_code, 0, sizeof(uint16_t)*16);
 759         nb_codes += 16;
 760     }
 761
 762     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
 763 }
 764
 765 static int mjpeg_decode_init(AVCodecContext *avctx)
 766 {
 767     MJpegDecodeContext *s = avctx->priv_data;
 768
 769     s->avctx = avctx;
 770     dsputil_init(&s->dsp, avctx);
 771     ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
 772     s->buffer_size = 0;
 773     s->buffer = NULL;
 774     s->start_code = -1;
 775     s->first_picture = 1;
 776     s->org_height = avctx->coded_height;
 777
 778     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
 779     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
 780     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
 781     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
 782
 783     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
 784     {
 785         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
 786         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 787         mjpeg_decode_dht(s);
 788         /* should check for error - but dunno */
 789     }
 790     if (avctx->extradata_size > 9 &&
 791         AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) {
 792         if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */
 793             s->interlace_polarity = 1; /* bottom field first */
 794             av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
 795         }
 796     }
 797
 798     return 0;
 799 }
 800
 801
 802 /* quantize tables */
 803 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
 804 {
 805     int len, index, i, j;
 806
 807     len = get_bits(&s->gb, 16) - 2;
 808
 809     while (len >= 65) {
 810         /* only 8 bit precision handled */
 811         if (get_bits(&s->gb, 4) != 0)
 812         {
 813             av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
 814             return -1;
 815         }
 816         index = get_bits(&s->gb, 4);
 817         if (index >= 4)
 818             return -1;
 819         av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
 820         /* read quant table */
 821         for(i=0;i<64;i++) {
 822             j = s->scantable.permutated[i];
 823             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 824         }
 825
 826         //XXX FIXME finetune, and perhaps add dc too
 827         s->qscale[index]= FFMAX(
 828             s->quant_matrixes[index][s->scantable.permutated[1]],
 829             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
 830         av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
 831         len -= 65;
 832     }
 833
 834     return 0;
 835 }
 836
 837 /* decode huffman tables and build VLC decoders */
 838 static int mjpeg_decode_dht(MJpegDecodeContext *s)
 839 {
 840     int len, index, i, class, n, v, code_max;
 841     uint8_t bits_table[17];
 842     uint8_t val_table[256];
 843
 844     len = get_bits(&s->gb, 16) - 2;
 845
 846     while (len > 0) {
 847         if (len < 17)
 848             return -1;
 849         class = get_bits(&s->gb, 4);
 850         if (class >= 2)
 851             return -1;
 852         index = get_bits(&s->gb, 4);
 853         if (index >= 4)
 854             return -1;
 855         n = 0;
 856         for(i=1;i<=16;i++) {
 857             bits_table[i] = get_bits(&s->gb, 8);
 858             n += bits_table[i];
 859         }
 860         len -= 17;
 861         if (len < n || n > 256)
 862             return -1;
 863
 864         code_max = 0;
 865         for(i=0;i<n;i++) {
 866             v = get_bits(&s->gb, 8);
 867             if (v > code_max)
 868                 code_max = v;
 869             val_table[i] = v;
 870         }
 871         len -= n;
 872
 873         /* build VLC and flush previous vlc if present */
 874         free_vlc(&s->vlcs[class][index]);
 875         av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
 876                class, index, code_max + 1);
 877         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
 878             return -1;
 879         }
 880     }
 881     return 0;
 882 }
 883
 884 static int mjpeg_decode_sof(MJpegDecodeContext *s)
 885 {
 886     int len, nb_components, i, width, height, pix_fmt_id;
 887
 888     /* XXX: verify len field validity */
 889     len = get_bits(&s->gb, 16);
 890     s->bits= get_bits(&s->gb, 8);
 891
 892     if(s->pegasus_rct) s->bits=9;
 893     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
 894
 895     if (s->bits != 8 && !s->lossless){
 896         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
 897         return -1;
 898     }
 899
 900     height = get_bits(&s->gb, 16);
 901     width = get_bits(&s->gb, 16);
 902
 903     //HACK for odd_height.mov
 904     if(s->interlaced && s->width == width && s->height == height + 1)
 905         height= s->height;
 906
 907     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
 908     if(avcodec_check_dimensions(s->avctx, width, height))
 909         return -1;
 910
 911     nb_components = get_bits(&s->gb, 8);
 912     if (nb_components <= 0 ||
 913         nb_components > MAX_COMPONENTS)
 914         return -1;
 915     if (s->ls && !(s->bits <= 8 || nb_components == 1)){
 916         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
 917         return -1;
 918     }
 919     s->nb_components = nb_components;
 920     s->h_max = 1;
 921     s->v_max = 1;
 922     for(i=0;i<nb_components;i++) {
 923         /* component id */
 924         s->component_id[i] = get_bits(&s->gb, 8) - 1;
 925         s->h_count[i] = get_bits(&s->gb, 4);
 926         s->v_count[i] = get_bits(&s->gb, 4);
 927         /* compute hmax and vmax (only used in interleaved case) */
 928         if (s->h_count[i] > s->h_max)
 929             s->h_max = s->h_count[i];
 930         if (s->v_count[i] > s->v_max)
 931             s->v_max = s->v_count[i];
 932         s->quant_index[i] = get_bits(&s->gb, 8);
 933         if (s->quant_index[i] >= 4)
 934             return -1;
 935         av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
 936                s->v_count[i], s->component_id[i], s->quant_index[i]);
 937     }
 938
 939     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
 940         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
 941         return -1;
 942     }
 943
 944     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
 945
 946     /* if different size, realloc/alloc picture */
 947     /* XXX: also check h_count and v_count */
 948     if (width != s->width || height != s->height) {
 949         av_freep(&s->qscale_table);
 950
 951         s->width = width;
 952         s->height = height;
 953         s->interlaced = 0;
 954
 955         /* test interlaced mode */
 956         if (s->first_picture &&
 957             s->org_height != 0 &&
 958             s->height < ((s->org_height * 3) / 4)) {
 959             s->interlaced = 1;
 960             s->bottom_field = s->interlace_polarity;
 961             s->picture.interlaced_frame = 1;
 962             s->picture.top_field_first = !s->interlace_polarity;
 963             height *= 2;
 964         }
 965
 966         avcodec_set_dimensions(s->avctx, width, height);
 967
 968         s->qscale_table= av_mallocz((s->width+15)/16);
 969
 970         s->first_picture = 0;
 971     }
 972
 973     if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
 974         return 0;
 975
 976     /* XXX: not complete test ! */
 977     pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
 978                  (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
 979                  (s->h_count[2] <<  4) |  s->v_count[2];
 980     av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
 981     switch(pix_fmt_id){
 982     case 0x222222:
 983     case 0x111111:
 984         if(s->rgb){
 985             s->avctx->pix_fmt = PIX_FMT_RGB32;
 986         }else if(s->nb_components==3)
 987             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
 988         else
 989             s->avctx->pix_fmt = PIX_FMT_GRAY8;
 990         break;
 991     case 0x211111:
 992     case 0x221212:
 993         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
 994         break;
 995     default:
 996     case 0x221111:
 997         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
 998         break;
 999     }
1000     if(s->ls){
1001         if(s->nb_components > 1)
1002             s->avctx->pix_fmt = PIX_FMT_RGB24;
1003         else if(s->bits <= 8)
1004             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1005         else
1006             s->avctx->pix_fmt = PIX_FMT_GRAY16;
1007     }
1008
1009     if(s->picture.data[0])
1010         s->avctx->release_buffer(s->avctx, &s->picture);
1011
1012     s->picture.reference= 0;
1013     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1014         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1015         return -1;
1016     }
1017     s->picture.pict_type= I_TYPE;
1018     s->picture.key_frame= 1;
1019
1020     for(i=0; i<3; i++){
1021         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1022     }
1023
1024 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1025
1026     if (len != (8+(3*nb_components)))
1027     {
1028         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1029     }
1030
1031     /* totally blank picture as progressive JPEG will only add details to it */
1032     if(s->progressive){
1033         memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1034         memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1035         memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1036     }
1037     return 0;
1038 }
1039
1040 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1041 {
1042     int code;
1043     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1044     if (code < 0)
1045     {
1046         av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1047                &s->vlcs[0][dc_index]);
1048         return 0xffff;
1049     }
1050
1051     if(code)
1052         return get_xbits(&s->gb, code);
1053     else
1054         return 0;
1055 }
1056
1057 /* decode block and dequantize */
1058 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1059                         int component, int dc_index, int ac_index, int16_t *quant_matrix)
1060 {
1061     int code, i, j, level, val;
1062
1063     /* DC coef */
1064     val = mjpeg_decode_dc(s, dc_index);
1065     if (val == 0xffff) {
1066         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1067         return -1;
1068     }
1069     val = val * quant_matrix[0] + s->last_dc[component];
1070     s->last_dc[component] = val;
1071     block[0] = val;
1072     /* AC coefs */
1073     i = 0;
1074     {OPEN_READER(re, &s->gb)
1075     for(;;) {
1076         UPDATE_CACHE(re, &s->gb);
1077         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1078
1079         /* EOB */
1080         if (code == 0x10)
1081             break;
1082         i += ((unsigned)code) >> 4;
1083         if(code != 0x100){
1084             code &= 0xf;
1085             if(code > MIN_CACHE_BITS - 16){
1086                 UPDATE_CACHE(re, &s->gb)
1087             }
1088             {
1089                 int cache=GET_CACHE(re,&s->gb);
1090                 int sign=(~cache)>>31;
1091                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1092             }
1093
1094             LAST_SKIP_BITS(re, &s->gb, code)
1095
1096             if (i >= 63) {
1097                 if(i == 63){
1098                     j = s->scantable.permutated[63];
1099                     block[j] = level * quant_matrix[j];
1100                     break;
1101                 }
1102                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1103                 return -1;
1104             }
1105             j = s->scantable.permutated[i];
1106             block[j] = level * quant_matrix[j];
1107         }
1108     }
1109     CLOSE_READER(re, &s->gb)}
1110
1111     return 0;
1112 }
1113
1114 /* decode block and dequantize - progressive JPEG version */
1115 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1116                         int component, int dc_index, int ac_index, int16_t *quant_matrix,
1117                         int ss, int se, int Ah, int Al, int *EOBRUN)
1118 {
1119     int code, i, j, level, val, run;
1120
1121     /* DC coef */
1122     if(!ss){
1123         val = mjpeg_decode_dc(s, dc_index);
1124         if (val == 0xffff) {
1125             av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1126             return -1;
1127         }
1128         val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1129     }else
1130         val = 0;
1131     s->last_dc[component] = val;
1132     block[0] = val;
1133     if(!se) return 0;
1134     /* AC coefs */
1135     if(*EOBRUN){
1136         (*EOBRUN)--;
1137         return 0;
1138     }
1139     {OPEN_READER(re, &s->gb)
1140     for(i=ss;;i++) {
1141         UPDATE_CACHE(re, &s->gb);
1142         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1143         /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1144         code -= 16;
1145         if(code & 0xF) {
1146             i += ((unsigned) code) >> 4;
1147             code &= 0xf;
1148             if(code > MIN_CACHE_BITS - 16){
1149                 UPDATE_CACHE(re, &s->gb)
1150             }
1151             {
1152                 int cache=GET_CACHE(re,&s->gb);
1153                 int sign=(~cache)>>31;
1154                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1155             }
1156
1157             LAST_SKIP_BITS(re, &s->gb, code)
1158
1159             if (i >= se) {
1160                 if(i == se){
1161                     j = s->scantable.permutated[se];
1162                     block[j] = level * quant_matrix[j] << Al;
1163                     break;
1164                 }
1165                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1166                 return -1;
1167             }
1168             j = s->scantable.permutated[i];
1169             block[j] = level * quant_matrix[j] << Al;
1170         }else{
1171             run = ((unsigned) code) >> 4;
1172             if(run == 0xF){// ZRL - skip 15 coefficients
1173                 i += 15;
1174             }else{
1175                 val = run;
1176                 run = (1 << run);
1177                 UPDATE_CACHE(re, &s->gb);
1178                 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1179                 if(val)
1180                     LAST_SKIP_BITS(re, &s->gb, val);
1181                 *EOBRUN = run - 1;
1182                 break;
1183             }
1184         }
1185     }
1186     CLOSE_READER(re, &s->gb)}
1187
1188     return 0;
1189 }
1190
1191 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1192     int i, mb_x, mb_y;
1193     uint16_t buffer[32768][4];
1194     int left[3], top[3], topleft[3];
1195     const int linesize= s->linesize[0];
1196     const int mask= (1<<s->bits)-1;
1197
1198     if((unsigned)s->mb_width > 32768) //dynamic alloc
1199         return -1;
1200
1201     for(i=0; i<3; i++){
1202         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1203     }
1204     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1205         const int modified_predictor= mb_y ? predictor : 1;
1206         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1207
1208         if (s->interlaced && s->bottom_field)
1209             ptr += linesize >> 1;
1210
1211         for(i=0; i<3; i++){
1212             top[i]= left[i]= topleft[i]= buffer[0][i];
1213         }
1214         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215             if (s->restart_interval && !s->restart_count)
1216                 s->restart_count = s->restart_interval;
1217
1218             for(i=0;i<3;i++) {
1219                 int pred;
1220
1221                 topleft[i]= top[i];
1222                 top[i]= buffer[mb_x][i];
1223
1224                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1225
1226                 left[i]=
1227                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1228             }
1229
1230             if (s->restart_interval && !--s->restart_count) {
1231                 align_get_bits(&s->gb);
1232                 skip_bits(&s->gb, 16); /* skip RSTn */
1233             }
1234         }
1235
1236         if(s->rct){
1237             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1238                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1239                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1240                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1241             }
1242         }else if(s->pegasus_rct){
1243             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1244                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1245                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1246                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1247             }
1248         }else{
1249             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1250                 ptr[4*mb_x+0] = buffer[mb_x][0];
1251                 ptr[4*mb_x+1] = buffer[mb_x][1];
1252                 ptr[4*mb_x+2] = buffer[mb_x][2];
1253             }
1254         }
1255     }
1256     return 0;
1257 }
1258
1259 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1260     int i, mb_x, mb_y;
1261     const int nb_components=3;
1262
1263     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1264         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1265             if (s->restart_interval && !s->restart_count)
1266                 s->restart_count = s->restart_interval;
1267
1268             if(mb_x==0 || mb_y==0 || s->interlaced){
1269                 for(i=0;i<nb_components;i++) {
1270                     uint8_t *ptr;
1271                     int n, h, v, x, y, c, j, linesize;
1272                     n = s->nb_blocks[i];
1273                     c = s->comp_index[i];
1274                     h = s->h_scount[i];
1275                     v = s->v_scount[i];
1276                     x = 0;
1277                     y = 0;
1278                     linesize= s->linesize[c];
1279
1280                     for(j=0; j<n; j++) {
1281                         int pred;
1282
1283                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1284                         if(y==0 && mb_y==0){
1285                             if(x==0 && mb_x==0){
1286                                 pred= 128 << point_transform;
1287                             }else{
1288                                 pred= ptr[-1];
1289                             }
1290                         }else{
1291                             if(x==0 && mb_x==0){
1292                                 pred= ptr[-linesize];
1293                             }else{
1294                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1295                             }
1296                         }
1297
1298                         if (s->interlaced && s->bottom_field)
1299                             ptr += linesize >> 1;
1300                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1301
1302                         if (++x == h) {
1303                             x = 0;
1304                             y++;
1305                         }
1306                     }
1307                 }
1308             }else{
1309                 for(i=0;i<nb_components;i++) {
1310                     uint8_t *ptr;
1311                     int n, h, v, x, y, c, j, linesize;
1312                     n = s->nb_blocks[i];
1313                     c = s->comp_index[i];
1314                     h = s->h_scount[i];
1315                     v = s->v_scount[i];
1316                     x = 0;
1317                     y = 0;
1318                     linesize= s->linesize[c];
1319
1320                     for(j=0; j<n; j++) {
1321                         int pred;
1322
1323                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1324                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1325                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1326                         if (++x == h) {
1327                             x = 0;
1328                             y++;
1329                         }
1330                     }
1331                 }
1332             }
1333             if (s->restart_interval && !--s->restart_count) {
1334                 align_get_bits(&s->gb);
1335                 skip_bits(&s->gb, 16); /* skip RSTn */
1336             }
1337         }
1338     }
1339     return 0;
1340 }
1341
1342 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1343     int i, mb_x, mb_y;
1344     int EOBRUN = 0;
1345
1346     if(Ah) return 0; /* TODO decode refinement planes too */
1347     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1348         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1349             if (s->restart_interval && !s->restart_count)
1350                 s->restart_count = s->restart_interval;
1351
1352             for(i=0;i<nb_components;i++) {
1353                 uint8_t *ptr;
1354                 int n, h, v, x, y, c, j;
1355                 n = s->nb_blocks[i];
1356                 c = s->comp_index[i];
1357                 h = s->h_scount[i];
1358                 v = s->v_scount[i];
1359                 x = 0;
1360                 y = 0;
1361                 for(j=0;j<n;j++) {
1362                     memset(s->block, 0, sizeof(s->block));
1363                     if (!s->progressive && decode_block(s, s->block, i,
1364                                      s->dc_index[i], s->ac_index[i],
1365                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1366                         av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1367                         return -1;
1368                     }
1369                     if (s->progressive && decode_block_progressive(s, s->block, i,
1370                                      s->dc_index[i], s->ac_index[i],
1371                                      s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1372                         av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1373                         return -1;
1374                     }
1375 //                    av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1376                     ptr = s->picture.data[c] +
1377                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1378                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1379                     if (s->interlaced && s->bottom_field)
1380                         ptr += s->linesize[c] >> 1;
1381 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1382                     if(!s->progressive)
1383                         s->dsp.idct_put(ptr, s->linesize[c], s->block);
1384                     else
1385                         s->dsp.idct_add(ptr, s->linesize[c], s->block);
1386                     if (++x == h) {
1387                         x = 0;
1388                         y++;
1389                     }
1390                 }
1391             }
1392             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1393             if (s->restart_interval && (s->restart_interval < 1350) &&
1394                 !--s->restart_count) {
1395                 align_get_bits(&s->gb);
1396                 skip_bits(&s->gb, 16); /* skip RSTn */
1397                 for (i=0; i<nb_components; i++) /* reset dc */
1398                     s->last_dc[i] = 1024;
1399             }
1400         }
1401     }
1402     return 0;
1403 }
1404
1405 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1406 {
1407     int len, nb_components, i, h, v, predictor, point_transform;
1408     int vmax, hmax, index, id;
1409     const int block_size= s->lossless ? 1 : 8;
1410     int ilv, prev_shift;
1411
1412     /* XXX: verify len field validity */
1413     len = get_bits(&s->gb, 16);
1414     nb_components = get_bits(&s->gb, 8);
1415     if (len != 6+2*nb_components)
1416     {
1417         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1418         return -1;
1419     }
1420     vmax = 0;
1421     hmax = 0;
1422     for(i=0;i<nb_components;i++) {
1423         id = get_bits(&s->gb, 8) - 1;
1424         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1425         /* find component index */
1426         for(index=0;index<s->nb_components;index++)
1427             if (id == s->component_id[index])
1428                 break;
1429         if (index == s->nb_components)
1430         {
1431             av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1432             return -1;
1433         }
1434
1435         s->comp_index[i] = index;
1436
1437         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1438         s->h_scount[i] = s->h_count[index];
1439         s->v_scount[i] = s->v_count[index];
1440
1441         s->dc_index[i] = get_bits(&s->gb, 4);
1442         s->ac_index[i] = get_bits(&s->gb, 4);
1443
1444         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1445             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1446             goto out_of_range;
1447 #if 0 //buggy
1448         switch(s->start_code)
1449         {
1450             case SOF0:
1451                 if (dc_index[i] > 1 || ac_index[i] > 1)
1452                     goto out_of_range;
1453                 break;
1454             case SOF1:
1455             case SOF2:
1456                 if (dc_index[i] > 3 || ac_index[i] > 3)
1457                     goto out_of_range;
1458                 break;
1459             case SOF3:
1460                 if (dc_index[i] > 3 || ac_index[i] != 0)
1461                     goto out_of_range;
1462                 break;
1463         }
1464 #endif
1465     }
1466
1467     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1468     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1469     prev_shift = get_bits(&s->gb, 4); /* Ah */
1470     point_transform= get_bits(&s->gb, 4); /* Al */
1471
1472     for(i=0;i<nb_components;i++)
1473         s->last_dc[i] = 1024;
1474
1475     if (nb_components > 1) {
1476         /* interleaved stream */
1477         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1478         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1479     } else if(!s->ls) { /* skip this for JPEG-LS */
1480         h = s->h_max / s->h_scount[0];
1481         v = s->v_max / s->v_scount[0];
1482         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1483         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1484         s->nb_blocks[0] = 1;
1485         s->h_scount[0] = 1;
1486         s->v_scount[0] = 1;
1487     }
1488
1489     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1490         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
1491                predictor, point_transform, ilv, s->bits,
1492                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1493
1494
1495     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1496     for (i = s->mjpb_skiptosod; i > 0; i--)
1497         skip_bits(&s->gb, 8);
1498
1499     if(s->lossless){
1500         if(s->ls){
1501 //            for(){
1502 //            reset_ls_coding_parameters(s, 0);
1503
1504             ff_jpegls_decode_picture(s, predictor, point_transform, ilv);
1505         }else{
1506             if(s->rgb){
1507                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1508                     return -1;
1509             }else{
1510                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1511                     return -1;
1512             }
1513         }
1514     }else{
1515         if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1516             return -1;
1517     }
1518     emms_c();
1519     return 0;
1520  out_of_range:
1521     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1522     return -1;
1523 }
1524
1525 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1526 {
1527     if (get_bits(&s->gb, 16) != 4)
1528         return -1;
1529     s->restart_interval = get_bits(&s->gb, 16);
1530     s->restart_count = 0;
1531     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1532
1533     return 0;
1534 }
1535
1536 static int mjpeg_decode_app(MJpegDecodeContext *s)
1537 {
1538     int len, id, i;
1539
1540     len = get_bits(&s->gb, 16);
1541     if (len < 5)
1542         return -1;
1543     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1544         return -1;
1545
1546     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1547     id = be2me_32(id);
1548     len -= 6;
1549
1550     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1551         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1552     }
1553
1554     /* buggy AVID, it puts EOI only at every 10th frame */
1555     /* also this fourcc is used by non-avid files too, it holds some
1556        informations, but it's always present in AVID creates files */
1557     if (id == ff_get_fourcc("AVI1"))
1558     {
1559         /* structure:
1560             4bytes      AVI1
1561             1bytes      polarity
1562             1bytes      always zero
1563             4bytes      field_size
1564             4bytes      field_size_less_padding
1565         */
1566             s->buggy_avid = 1;
1567 //        if (s->first_picture)
1568 //            printf("mjpeg: workarounding buggy AVID\n");
1569         i = get_bits(&s->gb, 8);
1570         if     (i==2) s->bottom_field= 1;
1571         else if(i==1) s->bottom_field= 0;
1572 #if 0
1573         skip_bits(&s->gb, 8);
1574         skip_bits(&s->gb, 32);
1575         skip_bits(&s->gb, 32);
1576         len -= 10;
1577 #endif
1578 //        if (s->interlace_polarity)
1579 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1580         goto out;
1581     }
1582
1583 //    len -= 2;
1584
1585     if (id == ff_get_fourcc("JFIF"))
1586     {
1587         int t_w, t_h, v1, v2;
1588         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1589         v1= get_bits(&s->gb, 8);
1590         v2= get_bits(&s->gb, 8);
1591         skip_bits(&s->gb, 8);
1592
1593         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1594         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1595
1596         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1597             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1598                 v1, v2,
1599                 s->avctx->sample_aspect_ratio.num,
1600                 s->avctx->sample_aspect_ratio.den
1601             );
1602
1603         t_w = get_bits(&s->gb, 8);
1604         t_h = get_bits(&s->gb, 8);
1605         if (t_w && t_h)
1606         {
1607             /* skip thumbnail */
1608             if (len-10-(t_w*t_h*3) > 0)
1609                 len -= t_w*t_h*3;
1610         }
1611         len -= 10;
1612         goto out;
1613     }
1614
1615     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1616     {
1617         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1618             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1619         skip_bits(&s->gb, 16); /* version */
1620         skip_bits(&s->gb, 16); /* flags0 */
1621         skip_bits(&s->gb, 16); /* flags1 */
1622         skip_bits(&s->gb, 8);  /* transform */
1623         len -= 7;
1624         goto out;
1625     }
1626
1627     if (id == ff_get_fourcc("LJIF")){
1628         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1629             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1630         skip_bits(&s->gb, 16); /* version ? */
1631         skip_bits(&s->gb, 16); /* unknwon always 0? */
1632         skip_bits(&s->gb, 16); /* unknwon always 0? */
1633         skip_bits(&s->gb, 16); /* unknwon always 0? */
1634         switch( get_bits(&s->gb, 8)){
1635         case 1:
1636             s->rgb= 1;
1637             s->pegasus_rct=0;
1638             break;
1639         case 2:
1640             s->rgb= 1;
1641             s->pegasus_rct=1;
1642             break;
1643         default:
1644             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1645         }
1646         len -= 9;
1647         goto out;
1648     }
1649
1650     /* Apple MJPEG-A */
1651     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1652     {
1653         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1654         id = be2me_32(id);
1655         len -= 4;
1656         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1657         {
1658 #if 0
1659             skip_bits(&s->gb, 32); /* field size */
1660             skip_bits(&s->gb, 32); /* pad field size */
1661             skip_bits(&s->gb, 32); /* next off */
1662             skip_bits(&s->gb, 32); /* quant off */
1663             skip_bits(&s->gb, 32); /* huff off */
1664             skip_bits(&s->gb, 32); /* image off */
1665             skip_bits(&s->gb, 32); /* scan off */
1666             skip_bits(&s->gb, 32); /* data off */
1667 #endif
1668             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1669                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1670         }
1671     }
1672
1673 out:
1674     /* slow but needed for extreme adobe jpegs */
1675     if (len < 0)
1676         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1677     while(--len > 0)
1678         skip_bits(&s->gb, 8);
1679
1680     return 0;
1681 }
1682
1683 static int mjpeg_decode_com(MJpegDecodeContext *s)
1684 {
1685     int len = get_bits(&s->gb, 16);
1686     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1687         char *cbuf = av_malloc(len - 1);
1688         if (cbuf) {
1689             int i;
1690             for (i = 0; i < len - 2; i++)
1691                 cbuf[i] = get_bits(&s->gb, 8);
1692             if (i > 0 && cbuf[i-1] == '\n')
1693                 cbuf[i-1] = 0;
1694             else
1695                 cbuf[i] = 0;
1696
1697             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1698                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1699
1700             /* buggy avid, it puts EOI only at every 10th frame */
1701             if (!strcmp(cbuf, "AVID"))
1702             {
1703                 s->buggy_avid = 1;
1704                 //        if (s->first_picture)
1705                 //            printf("mjpeg: workarounding buggy AVID\n");
1706             }
1707             else if(!strcmp(cbuf, "CS=ITU601")){
1708                 s->cs_itu601= 1;
1709             }
1710
1711             av_free(cbuf);
1712         }
1713     }
1714
1715     return 0;
1716 }
1717
1718 #if 0
1719 static int valid_marker_list[] =
1720 {
1721         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1722 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1723 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1724 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1725 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1726 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1727 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1728 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1729 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1730 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1731 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1732 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1733 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1734 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1735 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1736 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1737 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1738 }
1739 #endif
1740
1741 /* return the 8 bit start code value and update the search
1742    state. Return -1 if no start code found */
1743 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1744 {
1745     uint8_t *buf_ptr;
1746     unsigned int v, v2;
1747     int val;
1748 #ifdef DEBUG
1749     int skipped=0;
1750 #endif
1751
1752     buf_ptr = *pbuf_ptr;
1753     while (buf_ptr < buf_end) {
1754         v = *buf_ptr++;
1755         v2 = *buf_ptr;
1756         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1757             val = *buf_ptr++;
1758             goto found;
1759         }
1760 #ifdef DEBUG
1761         skipped++;
1762 #endif
1763     }
1764     val = -1;
1765 found:
1766 #ifdef DEBUG
1767     av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
1768 #endif
1769     *pbuf_ptr = buf_ptr;
1770     return val;
1771 }
1772
1773 static int mjpeg_decode_frame(AVCodecContext *avctx,
1774                               void *data, int *data_size,
1775                               uint8_t *buf, int buf_size)
1776 {
1777     MJpegDecodeContext *s = avctx->priv_data;
1778     uint8_t *buf_end, *buf_ptr;
1779     int start_code;
1780     AVFrame *picture = data;
1781
1782     buf_ptr = buf;
1783     buf_end = buf + buf_size;
1784     while (buf_ptr < buf_end) {
1785         /* find start next marker */
1786         start_code = find_marker(&buf_ptr, buf_end);
1787         {
1788             /* EOF */
1789             if (start_code < 0) {
1790                 goto the_end;
1791             } else {
1792                 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1793
1794                 if ((buf_end - buf_ptr) > s->buffer_size)
1795                 {
1796                     av_free(s->buffer);
1797                     s->buffer_size = buf_end-buf_ptr;
1798                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1799                     av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
1800                         s->buffer_size);
1801                 }
1802
1803                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1804                 if (start_code == SOS && !s->ls)
1805                 {
1806                     uint8_t *src = buf_ptr;
1807                     uint8_t *dst = s->buffer;
1808
1809                     while (src<buf_end)
1810                     {
1811                         uint8_t x = *(src++);
1812
1813                         *(dst++) = x;
1814                         if (avctx->codec_id != CODEC_ID_THP)
1815                         {
1816                             if (x == 0xff) {
1817                                 while (src < buf_end && x == 0xff)
1818                                     x = *(src++);
1819
1820                                 if (x >= 0xd0 && x <= 0xd7)
1821                                     *(dst++) = x;
1822                                 else if (x)
1823                                     break;
1824                             }
1825                         }
1826                     }
1827                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1828
1829                     av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
1830                            (buf_end - buf_ptr) - (dst - s->buffer));
1831                 }
1832                 else if(start_code == SOS && s->ls){
1833                     uint8_t *src = buf_ptr;
1834                     uint8_t *dst = s->buffer;
1835                     int bit_count = 0;
1836                     int t = 0, b = 0;
1837                     PutBitContext pb;
1838
1839                     s->cur_scan++;
1840
1841                     /* find marker */
1842                     while (src + t < buf_end){
1843                         uint8_t x = src[t++];
1844                         if (x == 0xff){
1845                             while((src + t < buf_end) && x == 0xff)
1846                                 x = src[t++];
1847                             if (x & 0x80) {
1848                                 t -= 2;
1849                                 break;
1850                             }
1851                         }
1852                     }
1853                     bit_count = t * 8;
1854
1855                     init_put_bits(&pb, dst, t);
1856
1857                     /* unescape bitstream */
1858                     while(b < t){
1859                         uint8_t x = src[b++];
1860                         put_bits(&pb, 8, x);
1861                         if(x == 0xFF){
1862                             x = src[b++];
1863                             put_bits(&pb, 7, x);
1864                             bit_count--;
1865                         }
1866                     }
1867                     flush_put_bits(&pb);
1868
1869                     init_get_bits(&s->gb, dst, bit_count);
1870                 }
1871                 else
1872                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1873
1874                 s->start_code = start_code;
1875                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1876                     av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1877                 }
1878
1879                 /* process markers */
1880                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1881                     av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
1882                     /* APP fields */
1883                 } else if (start_code >= APP0 && start_code <= APP15) {
1884                     mjpeg_decode_app(s);
1885                     /* Comment */
1886                 } else if (start_code == COM){
1887                     mjpeg_decode_com(s);
1888                 }
1889
1890                 switch(start_code) {
1891                 case SOI:
1892                     s->restart_interval = 0;
1893
1894                     s->restart_count = 0;
1895                     /* nothing to do on SOI */
1896                     break;
1897                 case DQT:
1898                     mjpeg_decode_dqt(s);
1899                     break;
1900                 case DHT:
1901                     if(mjpeg_decode_dht(s) < 0){
1902                         av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
1903                         return -1;
1904                     }
1905                     break;
1906                 case SOF0:
1907                     s->lossless=0;
1908                     s->ls=0;
1909                     s->progressive=0;
1910                     if (mjpeg_decode_sof(s) < 0)
1911                         return -1;
1912                     break;
1913                 case SOF2:
1914                     s->lossless=0;
1915                     s->ls=0;
1916                     s->progressive=1;
1917                     if (mjpeg_decode_sof(s) < 0)
1918                         return -1;
1919                     break;
1920                 case SOF3:
1921                     s->lossless=1;
1922                     s->ls=0;
1923                     s->progressive=0;
1924                     if (mjpeg_decode_sof(s) < 0)
1925                         return -1;
1926                     break;
1927                 case SOF48:
1928                     s->lossless=1;
1929                     s->ls=1;
1930                     s->progressive=0;
1931                     if (mjpeg_decode_sof(s) < 0)
1932                         return -1;
1933                     break;
1934                 case LSE:
1935                     if (ff_jpegls_decode_lse(s) < 0)
1936                         return -1;
1937                     break;
1938                 case EOI:
1939                     s->cur_scan = 0;
1940                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1941                         break;
1942 eoi_parser:
1943                     {
1944                         if (s->interlaced) {
1945                             s->bottom_field ^= 1;
1946                             /* if not bottom field, do not output image yet */
1947                             if (s->bottom_field == !s->interlace_polarity)
1948                                 goto not_the_end;
1949                         }
1950                         *picture = s->picture;
1951                         *data_size = sizeof(AVFrame);
1952
1953                         if(!s->lossless){
1954                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1955                             picture->qstride= 0;
1956                             picture->qscale_table= s->qscale_table;
1957                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1958                             if(avctx->debug & FF_DEBUG_QP)
1959                                 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1960                             picture->quality*= FF_QP2LAMBDA;
1961                         }
1962
1963                         goto the_end;
1964                     }
1965                     break;
1966                 case SOS:
1967                     mjpeg_decode_sos(s);
1968                     /* buggy avid puts EOI every 10-20th frame */
1969                     /* if restart period is over process EOI */
1970                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1971                         goto eoi_parser;
1972                     break;
1973                 case DRI:
1974                     mjpeg_decode_dri(s);
1975                     break;
1976                 case SOF1:
1977                 case SOF5:
1978                 case SOF6:
1979                 case SOF7:
1980                 case SOF9:
1981                 case SOF10:
1982                 case SOF11:
1983                 case SOF13:
1984                 case SOF14:
1985                 case SOF15:
1986                 case JPG:
1987                     av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1988                     break;
1989 //                default:
1990 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
1991 //                    break;
1992                 }
1993
1994 not_the_end:
1995                 /* eof process start code */
1996                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1997                 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
1998                        (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1999             }
2000         }
2001     }
2002 the_end:
2003     av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2004 //    return buf_end - buf_ptr;
2005     return buf_ptr - buf;
2006 }
2007
2008 static int mjpegb_decode_frame(AVCodecContext *avctx,
2009                               void *data, int *data_size,
2010                               uint8_t *buf, int buf_size)
2011 {
2012     MJpegDecodeContext *s = avctx->priv_data;
2013     uint8_t *buf_end, *buf_ptr;
2014     AVFrame *picture = data;
2015     GetBitContext hgb; /* for the header */
2016     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2017     uint32_t field_size, sod_offs;
2018
2019     buf_ptr = buf;
2020     buf_end = buf + buf_size;
2021
2022 read_header:
2023     /* reset on every SOI */
2024     s->restart_interval = 0;
2025     s->restart_count = 0;
2026     s->mjpb_skiptosod = 0;
2027
2028     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2029
2030     skip_bits(&hgb, 32); /* reserved zeros */
2031
2032     if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2033     {
2034         av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2035         return 0;
2036     }
2037
2038     field_size = get_bits_long(&hgb, 32); /* field size */
2039     av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2040     skip_bits(&hgb, 32); /* padded field size */
2041     second_field_offs = get_bits_long(&hgb, 32);
2042     av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2043
2044     dqt_offs = get_bits_long(&hgb, 32);
2045     av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
2046     if (dqt_offs)
2047     {
2048         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2049         s->start_code = DQT;
2050         mjpeg_decode_dqt(s);
2051     }
2052
2053     dht_offs = get_bits_long(&hgb, 32);
2054     av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
2055     if (dht_offs)
2056     {
2057         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2058         s->start_code = DHT;
2059         mjpeg_decode_dht(s);
2060     }
2061
2062     sof_offs = get_bits_long(&hgb, 32);
2063     av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
2064     if (sof_offs)
2065     {
2066         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2067         s->start_code = SOF0;
2068         if (mjpeg_decode_sof(s) < 0)
2069             return -1;
2070     }
2071
2072     sos_offs = get_bits_long(&hgb, 32);
2073     av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
2074     sod_offs = get_bits_long(&hgb, 32);
2075     av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
2076     if (sos_offs)
2077     {
2078 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2079         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2080         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2081         s->start_code = SOS;
2082         mjpeg_decode_sos(s);
2083     }
2084
2085     if (s->interlaced) {
2086         s->bottom_field ^= 1;
2087         /* if not bottom field, do not output image yet */
2088         if (s->bottom_field && second_field_offs)
2089         {
2090             buf_ptr = buf + second_field_offs;
2091             second_field_offs = 0;
2092             goto read_header;
2093             }
2094     }
2095
2096     //XXX FIXME factorize, this looks very similar to the EOI code
2097
2098     *picture= s->picture;
2099     *data_size = sizeof(AVFrame);
2100
2101     if(!s->lossless){
2102         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2103         picture->qstride= 0;
2104         picture->qscale_table= s->qscale_table;
2105         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2106         if(avctx->debug & FF_DEBUG_QP)
2107             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2108         picture->quality*= FF_QP2LAMBDA;
2109     }
2110
2111     return buf_ptr - buf;
2112 }
2113
2114 #include "sp5x.h"
2115
2116 static int sp5x_decode_frame(AVCodecContext *avctx,
2117                               void *data, int *data_size,
2118                               uint8_t *buf, int buf_size)
2119 {
2120 #if 0
2121     MJpegDecodeContext *s = avctx->priv_data;
2122 #endif
2123     const int qscale = 5;
2124     uint8_t *buf_ptr, *buf_end, *recoded;
2125     int i = 0, j = 0;
2126
2127     if (!avctx->width || !avctx->height)
2128         return -1;
2129
2130     buf_ptr = buf;
2131     buf_end = buf + buf_size;
2132
2133 #if 1
2134     recoded = av_mallocz(buf_size + 1024);
2135     if (!recoded)
2136         return -1;
2137
2138     /* SOI */
2139     recoded[j++] = 0xFF;
2140     recoded[j++] = 0xD8;
2141
2142     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2143     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2144     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2145     j += sizeof(sp5x_data_dqt);
2146
2147     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2148     j += sizeof(sp5x_data_dht);
2149
2150     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2151     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2152     recoded[j+6] = avctx->coded_height & 0xFF;
2153     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2154     recoded[j+8] = avctx->coded_width & 0xFF;
2155     j += sizeof(sp5x_data_sof);
2156
2157     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2158     j += sizeof(sp5x_data_sos);
2159
2160     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2161     {
2162         recoded[j++] = buf[i];
2163         if (buf[i] == 0xff)
2164             recoded[j++] = 0;
2165     }
2166
2167     /* EOI */
2168     recoded[j++] = 0xFF;
2169     recoded[j++] = 0xD9;
2170
2171     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2172
2173     av_free(recoded);
2174
2175 #else
2176     /* SOF */
2177     s->bits = 8;
2178     s->width  = avctx->coded_width;
2179     s->height = avctx->coded_height;
2180     s->nb_components = 3;
2181     s->component_id[0] = 0;
2182     s->h_count[0] = 2;
2183     s->v_count[0] = 2;
2184     s->quant_index[0] = 0;
2185     s->component_id[1] = 1;
2186     s->h_count[1] = 1;
2187     s->v_count[1] = 1;
2188     s->quant_index[1] = 1;
2189     s->component_id[2] = 2;
2190     s->h_count[2] = 1;
2191     s->v_count[2] = 1;
2192     s->quant_index[2] = 1;
2193     s->h_max = 2;
2194     s->v_max = 2;
2195
2196     s->qscale_table = av_mallocz((s->width+15)/16);
2197     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2198     s->interlaced = 0;
2199
2200     s->picture.reference = 0;
2201     if (avctx->get_buffer(avctx, &s->picture) < 0)
2202     {
2203         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2204         return -1;
2205     }
2206
2207     s->picture.pict_type = I_TYPE;
2208     s->picture.key_frame = 1;
2209
2210     for (i = 0; i < 3; i++)
2211         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2212
2213     /* DQT */
2214     for (i = 0; i < 64; i++)
2215     {
2216         j = s->scantable.permutated[i];
2217         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2218     }
2219     s->qscale[0] = FFMAX(
2220         s->quant_matrixes[0][s->scantable.permutated[1]],
2221         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2222
2223     for (i = 0; i < 64; i++)
2224     {
2225         j = s->scantable.permutated[i];
2226         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2227     }
2228     s->qscale[1] = FFMAX(
2229         s->quant_matrixes[1][s->scantable.permutated[1]],
2230         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2231
2232     /* DHT */
2233
2234     /* SOS */
2235     s->comp_index[0] = 0;
2236     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2237     s->h_scount[0] = s->h_count[0];
2238     s->v_scount[0] = s->v_count[0];
2239     s->dc_index[0] = 0;
2240     s->ac_index[0] = 0;
2241
2242     s->comp_index[1] = 1;
2243     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2244     s->h_scount[1] = s->h_count[1];
2245     s->v_scount[1] = s->v_count[1];
2246     s->dc_index[1] = 1;
2247     s->ac_index[1] = 1;
2248
2249     s->comp_index[2] = 2;
2250     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2251     s->h_scount[2] = s->h_count[2];
2252     s->v_scount[2] = s->v_count[2];
2253     s->dc_index[2] = 1;
2254     s->ac_index[2] = 1;
2255
2256     for (i = 0; i < 3; i++)
2257         s->last_dc[i] = 1024;
2258
2259     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2260     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2261
2262     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2263
2264     return mjpeg_decode_scan(s);
2265 #endif
2266
2267     return i;
2268 }
2269
2270 static int mjpeg_decode_end(AVCodecContext *avctx)
2271 {
2272     MJpegDecodeContext *s = avctx->priv_data;
2273     int i, j;
2274
2275     av_free(s->buffer);
2276     av_free(s->qscale_table);
2277
2278     for(i=0;i<2;i++) {
2279         for(j=0;j<4;j++)
2280             free_vlc(&s->vlcs[i][j]);
2281     }
2282     return 0;
2283 }
2284
2285 static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2286                               uint8_t **poutbuf, int *poutbuf_size,
2287                               const uint8_t *buf, int buf_size, int keyframe)
2288 {
2289     uint8_t *poutbufp;
2290     int i;
2291
2292     if (avctx->codec_id != CODEC_ID_MJPEG) {
2293         av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2294         return 0;
2295     }
2296
2297     *poutbuf_size = 0;
2298     *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
2299     poutbufp = *poutbuf;
2300     bytestream_put_byte(&poutbufp, 0xff);
2301     bytestream_put_byte(&poutbufp, SOI);
2302     bytestream_put_byte(&poutbufp, 0xff);
2303     bytestream_put_byte(&poutbufp, APP1);
2304     bytestream_put_be16(&poutbufp, 42); /* size */
2305     bytestream_put_be32(&poutbufp, 0);
2306     bytestream_put_buffer(&poutbufp, "mjpg", 4);
2307     bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
2308     bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
2309     bytestream_put_be32(&poutbufp, 0);             /* next ptr */
2310
2311     for (i = 0; i < buf_size - 1; i++) {
2312         if (buf[i] == 0xff) {
2313             switch (buf[i + 1]) {
2314             case DQT:  /* quant off */
2315             case DHT:  /* huff  off */
2316             case SOF0: /* image off */
2317                 bytestream_put_be32(&poutbufp, i + 46);
2318                 break;
2319             case SOS:
2320                 bytestream_put_be32(&poutbufp, i + 46); /* scan off */
2321                 bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */
2322                 bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
2323                 *poutbuf_size = poutbufp - *poutbuf;
2324                 return 1;
2325             case APP1:
2326                 if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {
2327                     av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
2328                     memcpy(*poutbuf, buf, buf_size);
2329                     *poutbuf_size = buf_size;
2330                     return 1;
2331                 }
2332             }
2333         }
2334     }
2335     av_freep(poutbuf);
2336     av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
2337     return 0;
2338 }
2339
2340 AVCodec mjpeg_decoder = {
2341     "mjpeg",
2342     CODEC_TYPE_VIDEO,
2343     CODEC_ID_MJPEG,
2344     sizeof(MJpegDecodeContext),
2345     mjpeg_decode_init,
2346     NULL,
2347     mjpeg_decode_end,
2348     mjpeg_decode_frame,
2349     CODEC_CAP_DR1,
2350     NULL
2351 };
2352
2353 AVCodec thp_decoder = {
2354     "thp",
2355     CODEC_TYPE_VIDEO,
2356     CODEC_ID_THP,
2357     sizeof(MJpegDecodeContext),
2358     mjpeg_decode_init,
2359     NULL,
2360     mjpeg_decode_end,
2361     mjpeg_decode_frame,
2362     CODEC_CAP_DR1,
2363     NULL
2364 };
2365
2366 AVCodec mjpegb_decoder = {
2367     "mjpegb",
2368     CODEC_TYPE_VIDEO,
2369     CODEC_ID_MJPEGB,
2370     sizeof(MJpegDecodeContext),
2371     mjpeg_decode_init,
2372     NULL,
2373     mjpeg_decode_end,
2374     mjpegb_decode_frame,
2375     CODEC_CAP_DR1,
2376     NULL
2377 };
2378
2379 AVCodec sp5x_decoder = {
2380     "sp5x",
2381     CODEC_TYPE_VIDEO,
2382     CODEC_ID_SP5X,
2383     sizeof(MJpegDecodeContext),
2384     mjpeg_decode_init,
2385     NULL,
2386     mjpeg_decode_end,
2387     sp5x_decode_frame,
2388     CODEC_CAP_DR1,
2389     NULL
2390 };
2391
2392 #ifdef CONFIG_ENCODERS
2393 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2394     "ljpeg",
2395     CODEC_TYPE_VIDEO,
2396     CODEC_ID_LJPEG,
2397     sizeof(MpegEncContext),
2398     MPV_encode_init,
2399     encode_picture_lossless,
2400     MPV_encode_end,
2401 };
2402 #endif
2403
2404 #ifdef CONFIG_MJPEGA_DUMP_HEADER_BSF
2405 AVBitStreamFilter mjpega_dump_header_bsf = {
2406     "mjpegadump",
2407     0,
2408     mjpega_dump_header,
2409 };
2410 #endif