← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavcodec/mjpeg.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060401161343-n621cgjlujio0otg
Tags: upstream-0.10.1
Import upstream version 0.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavcodec/mjpeg.c
16
16
 *
17
17
 * You should have received a copy of the GNU Lesser General Public
18
18
 * License along with this library; if not, write to the Free Software
19
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 *
21
21
 * Support for external huffman table, various fixes (AVID workaround),
22
22
 * aspecting, new decode_frame mechanism and apple mjpeg-b support
27
27
 * @file mjpeg.c
28
28
 * MJPEG encoder and decoder.
29
29
 */
30
 
 
 
30
 
31
31
//#define DEBUG
32
32
#include <assert.h>
33
33
 
40
40
#undef TWOMATRIXES
41
41
 
42
42
typedef struct MJpegContext {
43
 
    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
 
43
    uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
44
44
    uint16_t huff_code_dc_luminance[12];
45
45
    uint8_t huff_size_dc_chrominance[12];
46
46
    uint16_t huff_code_dc_chrominance[12];
54
54
/* JPEG marker codes */
55
55
typedef enum {
56
56
    /* start of frame */
57
 
    SOF0  = 0xc0,       /* baseline */
58
 
    SOF1  = 0xc1,       /* extended sequential, huffman */
59
 
    SOF2  = 0xc2,       /* progressive, huffman */
60
 
    SOF3  = 0xc3,       /* lossless, huffman */
61
 
 
62
 
    SOF5  = 0xc5,       /* differential sequential, huffman */
63
 
    SOF6  = 0xc6,       /* differential progressive, huffman */
64
 
    SOF7  = 0xc7,       /* differential lossless, huffman */
65
 
    JPG   = 0xc8,       /* reserved for JPEG extension */
66
 
    SOF9  = 0xc9,       /* extended sequential, arithmetic */
67
 
    SOF10 = 0xca,       /* progressive, arithmetic */
68
 
    SOF11 = 0xcb,       /* lossless, arithmetic */
69
 
 
70
 
    SOF13 = 0xcd,       /* differential sequential, arithmetic */
71
 
    SOF14 = 0xce,       /* differential progressive, arithmetic */
72
 
    SOF15 = 0xcf,       /* differential lossless, arithmetic */
73
 
 
74
 
    DHT   = 0xc4,       /* define huffman tables */
75
 
 
76
 
    DAC   = 0xcc,       /* define arithmetic-coding conditioning */
 
57
    SOF0  = 0xc0,       /* baseline */
 
58
    SOF1  = 0xc1,       /* extended sequential, huffman */
 
59
    SOF2  = 0xc2,       /* progressive, huffman */
 
60
    SOF3  = 0xc3,       /* lossless, huffman */
 
61
 
 
62
    SOF5  = 0xc5,       /* differential sequential, huffman */
 
63
    SOF6  = 0xc6,       /* differential progressive, huffman */
 
64
    SOF7  = 0xc7,       /* differential lossless, huffman */
 
65
    JPG   = 0xc8,       /* reserved for JPEG extension */
 
66
    SOF9  = 0xc9,       /* extended sequential, arithmetic */
 
67
    SOF10 = 0xca,       /* progressive, arithmetic */
 
68
    SOF11 = 0xcb,       /* lossless, arithmetic */
 
69
 
 
70
    SOF13 = 0xcd,       /* differential sequential, arithmetic */
 
71
    SOF14 = 0xce,       /* differential progressive, arithmetic */
 
72
    SOF15 = 0xcf,       /* differential lossless, arithmetic */
 
73
 
 
74
    DHT   = 0xc4,       /* define huffman tables */
 
75
 
 
76
    DAC   = 0xcc,       /* define arithmetic-coding conditioning */
77
77
 
78
78
    /* restart with modulo 8 count "m" */
79
79
    RST0  = 0xd0,
85
85
    RST6  = 0xd6,
86
86
    RST7  = 0xd7,
87
87
 
88
 
    SOI   = 0xd8,       /* start of image */
89
 
    EOI   = 0xd9,       /* end of image */
90
 
    SOS   = 0xda,       /* start of scan */
91
 
    DQT   = 0xdb,       /* define quantization tables */
92
 
    DNL   = 0xdc,       /* define number of lines */
93
 
    DRI   = 0xdd,       /* define restart interval */
94
 
    DHP   = 0xde,       /* define hierarchical progression */
95
 
    EXP   = 0xdf,       /* expand reference components */
 
88
    SOI   = 0xd8,       /* start of image */
 
89
    EOI   = 0xd9,       /* end of image */
 
90
    SOS   = 0xda,       /* start of scan */
 
91
    DQT   = 0xdb,       /* define quantization tables */
 
92
    DNL   = 0xdc,       /* define number of lines */
 
93
    DRI   = 0xdd,       /* define restart interval */
 
94
    DHP   = 0xde,       /* define hierarchical progression */
 
95
    EXP   = 0xdf,       /* expand reference components */
96
96
 
97
97
    APP0  = 0xe0,
98
98
    APP1  = 0xe1,
118
118
    JPG4  = 0xf4,
119
119
    JPG5  = 0xf5,
120
120
    JPG6  = 0xf6,
121
 
    JPG7  = 0xf7,
122
 
    JPG8  = 0xf8,
 
121
    SOF48 = 0xf7,       ///< JPEG-LS
 
122
    LSE   = 0xf8,       ///< JPEG-LS extension parameters
123
123
    JPG9  = 0xf9,
124
124
    JPG10 = 0xfa,
125
125
    JPG11 = 0xfb,
126
126
    JPG12 = 0xfc,
127
127
    JPG13 = 0xfd,
128
128
 
129
 
    COM   = 0xfe,       /* comment */
 
129
    COM   = 0xfe,       /* comment */
130
130
 
131
 
    TEM   = 0x01,       /* temporary private use for arithmetic coding */
 
131
    TEM   = 0x01,       /* temporary private use for arithmetic coding */
132
132
 
133
133
    /* 0x02 -> 0xbf reserved */
134
134
} JPEG_MARKER;
195
195
  0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
196
196
  0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
197
197
  0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
198
 
  0xf9, 0xfa 
 
198
  0xf9, 0xfa
199
199
};
200
200
 
201
201
static const uint8_t bits_ac_chrominance[17] =
222
222
  0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
223
223
  0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
224
224
  0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
225
 
  0xf9, 0xfa 
 
225
  0xf9, 0xfa
226
226
};
227
227
 
228
228
/* isn't this function nicer than the one in the libjpeg ? */
249
249
int mjpeg_init(MpegEncContext *s)
250
250
{
251
251
    MJpegContext *m;
252
 
    
 
252
 
253
253
    m = av_malloc(sizeof(MJpegContext));
254
254
    if (!m)
255
255
        return -1;
256
 
    
 
256
 
257
257
    s->min_qcoeff=-1023;
258
258
    s->max_qcoeff= 1023;
259
259
 
274
274
                        m->huff_code_ac_chrominance,
275
275
                        bits_ac_chrominance,
276
276
                        val_ac_chrominance);
277
 
    
 
277
 
278
278
    s->mjpeg_ctx = m;
279
279
    return 0;
280
280
}
362
362
    size = 2;
363
363
    size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
364
364
    size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
365
 
    
 
365
 
366
366
    size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
367
367
    size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
368
368
    ptr[0] = size >> 8;
401
401
        ptr[1] = size;
402
402
    }
403
403
 
404
 
    if(  s->avctx->pix_fmt == PIX_FMT_YUV420P 
 
404
    if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
405
405
       ||s->avctx->pix_fmt == PIX_FMT_YUV422P
406
406
       ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
407
407
        put_marker(p, COM);
417
417
 
418
418
void mjpeg_picture_header(MpegEncContext *s)
419
419
{
420
 
    const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
 
420
    const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
 
421
    const int ls      = s->avctx->codec_id == CODEC_ID_JPEGLS;
 
422
 
 
423
    assert(!(ls && s->mjpeg_write_tables));
421
424
 
422
425
    put_marker(&s->pb, SOI);
423
426
 
424
427
    if (!s->mjpeg_data_only_frames)
425
428
    {
426
 
    jpeg_put_comments(s);    
 
429
    jpeg_put_comments(s);
427
430
 
428
431
    if (s->mjpeg_write_tables) jpeg_table_header(s);
429
432
 
430
 
    put_marker(&s->pb, lossless ? SOF3 : SOF0);
 
433
    switch(s->avctx->codec_id){
 
434
    case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
 
435
    case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
 
436
    case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
 
437
    default: assert(0);
 
438
    }
431
439
 
432
440
    put_bits(&s->pb, 16, 17);
433
441
    if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
437
445
    put_bits(&s->pb, 16, s->height);
438
446
    put_bits(&s->pb, 16, s->width);
439
447
    put_bits(&s->pb, 8, 3); /* 3 components */
440
 
    
 
448
 
441
449
    /* Y component */
442
450
    put_bits(&s->pb, 8, 1); /* component number */
443
451
    put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
444
452
    put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
445
453
    put_bits(&s->pb, 8, 0); /* select matrix */
446
 
    
 
454
 
447
455
    /* Cb component */
448
456
    put_bits(&s->pb, 8, 2); /* component number */
449
457
    put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
469
477
    put_marker(&s->pb, SOS);
470
478
    put_bits(&s->pb, 16, 12); /* length */
471
479
    put_bits(&s->pb, 8, 3); /* 3 components */
472
 
    
 
480
 
473
481
    /* Y component */
474
482
    put_bits(&s->pb, 8, 1); /* index */
475
483
    put_bits(&s->pb, 4, 0); /* DC huffman table index */
476
484
    put_bits(&s->pb, 4, 0); /* AC huffman table index */
477
 
    
 
485
 
478
486
    /* Cb component */
479
487
    put_bits(&s->pb, 8, 2); /* index */
480
488
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
481
489
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
482
 
    
 
490
 
483
491
    /* Cr component */
484
492
    put_bits(&s->pb, 8, 3); /* index */
485
493
    put_bits(&s->pb, 4, 1); /* DC huffman table index */
486
494
    put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
487
495
 
488
 
    put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
489
 
    put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
 
496
    put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
 
497
 
 
498
    switch(s->avctx->codec_id){
 
499
    case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
 
500
    case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
 
501
    case CODEC_ID_JPEGLS: put_bits(&s->pb, 8,  1); break; /* ILV = line interleaved */
 
502
    default: assert(0);
 
503
    }
 
504
 
490
505
    put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
 
506
 
 
507
    //FIXME DC/AC entropy table selectors stuff in jpegls
491
508
}
492
509
 
493
510
static void escape_FF(MpegEncContext *s, int start)
496
513
    int i, ff_count;
497
514
    uint8_t *buf= s->pb.buf + start;
498
515
    int align= (-(size_t)(buf))&3;
499
 
    
 
516
 
500
517
    assert((size&7) == 0);
501
518
    size >>= 3;
502
 
    
 
519
 
503
520
    ff_count=0;
504
521
    for(i=0; i<size && i<align; i++){
505
522
        if(buf[i]==0xFF) ff_count++;
526
543
    }
527
544
 
528
545
    if(ff_count==0) return;
529
 
    
 
546
 
530
547
    /* skip put bits */
531
548
    for(i=0; i<ff_count-3; i+=4)
532
549
        put_bits(&s->pb, 32, 0);
533
550
    put_bits(&s->pb, (ff_count-i)*8, 0);
534
 
    flush_put_bits(&s->pb); 
 
551
    flush_put_bits(&s->pb);
535
552
 
536
553
    for(i=size-1; ff_count; i--){
537
554
        int v= buf[i];
559
576
    flush_put_bits(&s->pb);
560
577
 
561
578
    assert((s->header_bits&7)==0);
562
 
    
 
579
 
563
580
    escape_FF(s, s->header_bits>>3);
564
581
 
565
582
    put_marker(&s->pb, EOI);
566
583
}
567
584
 
568
585
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
569
 
                                   uint8_t *huff_size, uint16_t *huff_code)
 
586
                                   uint8_t *huff_size, uint16_t *huff_code)
570
587
{
571
588
    int mant, nbits;
572
589
 
578
595
            val = -val;
579
596
            mant--;
580
597
        }
581
 
        
 
598
 
582
599
        nbits= av_log2_16bit(val) + 1;
583
 
            
 
600
 
584
601
        put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
585
 
        
 
602
 
586
603
        put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
587
604
    }
588
605
}
594
611
    MJpegContext *m = s->mjpeg_ctx;
595
612
    uint8_t *huff_size_ac;
596
613
    uint16_t *huff_code_ac;
597
 
    
 
614
 
598
615
    /* DC coef */
599
616
    component = (n <= 3 ? 0 : n - 4 + 1);
600
617
    dc = block[0]; /* overflow is impossible */
609
626
        huff_code_ac = m->huff_code_ac_chrominance;
610
627
    }
611
628
    s->last_dc[component] = dc;
612
 
    
 
629
 
613
630
    /* AC coefs */
614
 
    
 
631
 
615
632
    run = 0;
616
633
    last_index = s->block_last_index[n];
617
634
    for(i=1;i<=last_index;i++) {
629
646
                val = -val;
630
647
                mant--;
631
648
            }
632
 
            
 
649
 
633
650
            nbits= av_log2(val) + 1;
634
651
            code = (run << 4) | nbits;
635
652
 
636
653
            put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
637
 
        
 
654
 
638
655
            put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
639
656
            run = 0;
640
657
        }
645
662
        put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
646
663
}
647
664
 
648
 
void mjpeg_encode_mb(MpegEncContext *s, 
 
665
void mjpeg_encode_mb(MpegEncContext *s,
649
666
                     DCTELEM block[6][64])
650
667
{
651
668
    int i;
668
685
    *p = *pict;
669
686
    p->pict_type= FF_I_TYPE;
670
687
    p->key_frame= 1;
671
 
    
 
688
 
672
689
    mjpeg_picture_header(s);
673
690
 
674
691
    s->header_bits= put_bits_count(&s->pb);
675
 
    
 
692
 
676
693
    if(avctx->pix_fmt == PIX_FMT_RGBA32){
677
694
        int x, y, i;
678
695
        const int linesize= p->linesize[0];
691
708
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
692
709
                return -1;
693
710
            }
694
 
            
 
711
 
695
712
            for(i=0; i<3; i++){
696
713
                top[i]= left[i]= topleft[i]= buffer[0][i];
697
714
            }
704
721
                    int pred, diff;
705
722
 
706
723
                    PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
707
 
                        
 
724
 
708
725
                    topleft[i]= top[i];
709
726
                    top[i]= buffer[x+1][i];
710
 
                    
 
727
 
711
728
                    left[i]= buffer[x][i];
712
729
 
713
730
                    diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
714
 
                    
 
731
 
715
732
                    if(i==0)
716
733
                        mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
717
734
                    else
723
740
        int mb_x, mb_y, i;
724
741
        const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
725
742
        const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
726
 
        
 
743
 
727
744
        for(mb_y = 0; mb_y < mb_height; mb_y++) {
728
745
            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]){
729
746
                av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
756
773
                                        PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
757
774
                                    }
758
775
                                }
759
 
                                
 
776
 
760
777
                                if(i==0)
761
778
                                    mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
762
779
                                else
771
788
                        h = s->mjpeg_hsample[i];
772
789
                        v = s->mjpeg_vsample[i];
773
790
                        linesize= p->linesize[i];
774
 
                             
 
791
 
775
792
                        for(y=0; y<v; y++){
776
793
                            for(x=0; x<h; x++){
777
794
                                int pred;
778
795
 
779
796
                                ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
780
 
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); 
 
797
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
781
798
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
782
799
 
783
800
                                if(i==0)
793
810
    }
794
811
 
795
812
    emms_c();
796
 
    
 
813
 
797
814
    mjpeg_picture_trailer(s);
798
815
    s->picture_number++;
799
816
 
827
844
    int interlaced;     /* true if interlaced */
828
845
    int bottom_field;   /* true if bottom field */
829
846
    int lossless;
 
847
    int ls;
830
848
    int rgb;
831
 
    int rct;            /* standard rct */  
832
 
    int pegasus_rct;    /* pegasus reversible colorspace transform */  
 
849
    int rct;            /* standard rct */
 
850
    int pegasus_rct;    /* pegasus reversible colorspace transform */
833
851
    int bits;           /* bits per component */
834
852
 
 
853
    int maxval;
 
854
    int near;         ///< near lossless bound (si 0 for lossless)
 
855
    int t1,t2,t3;
 
856
    int reset;        ///< context halfing intervall ?rename
 
857
 
835
858
    int width, height;
836
859
    int mb_width, mb_height;
837
860
    int nb_components;
850
873
    AVFrame picture; /* picture structure */
851
874
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
852
875
    int8_t *qscale_table;
853
 
    DCTELEM block[64] __align8;
 
876
    DECLARE_ALIGNED_8(DCTELEM, block[64]);
854
877
    ScanTable scantable;
855
878
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
856
879
 
862
885
    int interlace_polarity;
863
886
 
864
887
    int mjpb_skiptosod;
 
888
 
 
889
    int cur_scan; /* current scan, used by JPEG-LS */
865
890
} MJpegDecodeContext;
866
891
 
 
892
#include "jpeg_ls.c" //FIXME make jpeg-ls more independant
 
893
 
867
894
static int mjpeg_decode_dht(MJpegDecodeContext *s);
868
895
 
869
 
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
 
896
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
870
897
                      int nb_codes, int use_static)
871
898
{
872
899
    uint8_t huff_size[256];
874
901
 
875
902
    memset(huff_size, 0, sizeof(huff_size));
876
903
    build_huffman_codes(huff_size, huff_code, bits_table, val_table);
877
 
    
 
904
 
878
905
    return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
879
906
}
880
907
 
902
929
    s->start_code = -1;
903
930
    s->first_picture = 1;
904
931
    s->org_height = avctx->coded_height;
905
 
    
 
932
 
906
933
    build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0);
907
934
    build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0);
908
935
    build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0);
910
937
 
911
938
    if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
912
939
    {
913
 
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
914
 
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
915
 
        mjpeg_decode_dht(s);
916
 
        /* should check for error - but dunno */
 
940
        av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
 
941
        init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
 
942
        mjpeg_decode_dht(s);
 
943
        /* should check for error - but dunno */
917
944
    }
918
945
 
919
946
    return 0;
927
954
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
928
955
    int vop_found, i;
929
956
    uint16_t state;
930
 
    
 
957
 
931
958
    vop_found= pc->frame_start_found;
932
959
    state= pc->state;
933
 
    
 
960
 
934
961
    i=0;
935
962
    if(!vop_found){
936
963
        for(i=0; i<buf_size; i++){
951
978
            state= (state<<8) | buf[i];
952
979
            if(state == 0xFFD8){
953
980
                pc->frame_start_found=0;
954
 
                pc->state=0; 
 
981
                pc->state=0;
955
982
                return i-1;
956
983
            }
957
984
        }
963
990
 
964
991
static int jpeg_parse(AVCodecParserContext *s,
965
992
                           AVCodecContext *avctx,
966
 
                           uint8_t **poutbuf, int *poutbuf_size, 
 
993
                           uint8_t **poutbuf, int *poutbuf_size,
967
994
                           const uint8_t *buf, int buf_size)
968
995
{
969
996
    ParseContext *pc = s->priv_data;
970
997
    int next;
971
 
    
 
998
 
972
999
    next= find_frame_end(pc, buf, buf_size);
973
1000
 
974
1001
    if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
986
1013
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
987
1014
{
988
1015
    int len, index, i, j;
989
 
    
 
1016
 
990
1017
    len = get_bits(&s->gb, 16) - 2;
991
1018
 
992
1019
    while (len >= 65) {
993
1020
        /* only 8 bit precision handled */
994
1021
        if (get_bits(&s->gb, 4) != 0)
995
 
        {
996
 
            dprintf("dqt: 16bit precision\n");
 
1022
        {
 
1023
            dprintf("dqt: 16bit precision\n");
997
1024
            return -1;
998
 
        }
 
1025
        }
999
1026
        index = get_bits(&s->gb, 4);
1000
1027
        if (index >= 4)
1001
1028
            return -1;
1003
1030
        /* read quant table */
1004
1031
        for(i=0;i<64;i++) {
1005
1032
            j = s->scantable.permutated[i];
1006
 
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
 
1033
            s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1007
1034
        }
1008
1035
 
1009
1036
        //XXX FIXME finetune, and perhaps add dc too
1010
1037
        s->qscale[index]= FFMAX(
1011
1038
            s->quant_matrixes[index][s->scantable.permutated[1]],
1012
1039
            s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1013
 
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
 
1040
        dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1014
1041
        len -= 65;
1015
1042
    }
1016
 
    
 
1043
 
1017
1044
    return 0;
1018
1045
}
1019
1046
 
1023
1050
    int len, index, i, class, n, v, code_max;
1024
1051
    uint8_t bits_table[17];
1025
1052
    uint8_t val_table[256];
1026
 
    
 
1053
 
1027
1054
    len = get_bits(&s->gb, 16) - 2;
1028
1055
 
1029
1056
    while (len > 0) {
1071
1098
    /* XXX: verify len field validity */
1072
1099
    len = get_bits(&s->gb, 16);
1073
1100
    s->bits= get_bits(&s->gb, 8);
1074
 
    
1075
 
    if(s->pegasus_rct) s->bits=9;  
 
1101
 
 
1102
    if(s->pegasus_rct) s->bits=9;
1076
1103
    if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1077
1104
 
1078
1105
    if (s->bits != 8 && !s->lossless){
1079
1106
        av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1080
1107
        return -1;
1081
1108
    }
 
1109
    if (s->bits > 8 && s->ls){
 
1110
        av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
 
1111
        return -1;
 
1112
    }
 
1113
 
1082
1114
    height = get_bits(&s->gb, 16);
1083
1115
    width = get_bits(&s->gb, 16);
1084
 
    
 
1116
 
1085
1117
    dprintf("sof0: picture: %dx%d\n", width, height);
1086
1118
    if(avcodec_check_dimensions(s->avctx, width, height))
1087
1119
        return -1;
1107
1139
        if (s->quant_index[i] >= 4)
1108
1140
            return -1;
1109
1141
        dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1110
 
            s->v_count[i], s->component_id[i], s->quant_index[i]);
1111
 
    }
1112
 
    
 
1142
            s->v_count[i], s->component_id[i], s->quant_index[i]);
 
1143
    }
 
1144
 
 
1145
    if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
 
1146
        av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
 
1147
        return -1;
 
1148
    }
 
1149
 
1113
1150
    if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1114
1151
 
1115
1152
    /* if different size, realloc/alloc picture */
1116
1153
    /* XXX: also check h_count and v_count */
1117
1154
    if (width != s->width || height != s->height) {
1118
1155
        av_freep(&s->qscale_table);
1119
 
            
 
1156
 
1120
1157
        s->width = width;
1121
1158
        s->height = height;
1122
 
        avcodec_set_dimensions(s->avctx, width, height);
1123
1159
 
1124
1160
        /* test interlaced mode */
1125
1161
        if (s->first_picture &&
1126
1162
            s->org_height != 0 &&
1127
1163
            s->height < ((s->org_height * 3) / 4)) {
1128
1164
            s->interlaced = 1;
1129
 
//          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
 
1165
//            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1130
1166
            s->bottom_field = 0;
1131
 
            s->avctx->height *= 2;
 
1167
            height *= 2;
1132
1168
        }
1133
1169
 
 
1170
        avcodec_set_dimensions(s->avctx, width, height);
 
1171
 
1134
1172
        s->qscale_table= av_mallocz((s->width+15)/16);
1135
1173
 
1136
1174
        s->first_picture = 0;
1137
1175
    }
1138
 
    
 
1176
 
1139
1177
    if(s->interlaced && s->bottom_field)
1140
1178
        return 0;
1141
 
 
 
1179
 
1142
1180
    /* XXX: not complete test ! */
1143
1181
    switch((s->h_count[0] << 4) | s->v_count[0]) {
1144
1182
    case 0x11:
1157
1195
        s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1158
1196
        break;
1159
1197
    }
 
1198
    if(s->ls){
 
1199
        if(s->nb_components > 1)
 
1200
            s->avctx->pix_fmt = PIX_FMT_RGB24;
 
1201
        else
 
1202
            s->avctx->pix_fmt = PIX_FMT_GRAY8;
 
1203
    }
1160
1204
 
1161
1205
    if(s->picture.data[0])
1162
1206
        s->avctx->release_buffer(s->avctx, &s->picture);
1168
1212
    }
1169
1213
    s->picture.pict_type= I_TYPE;
1170
1214
    s->picture.key_frame= 1;
1171
 
    
 
1215
 
1172
1216
    for(i=0; i<3; i++){
1173
1217
        s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1174
1218
    }
1175
1219
 
1176
1220
//    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1177
 
    
 
1221
 
1178
1222
    if (len != (8+(3*nb_components)))
1179
1223
    {
1180
 
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
 
1224
        dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1181
1225
    }
1182
 
    
 
1226
 
1183
1227
    return 0;
1184
1228
}
1185
1229
 
1189
1233
    code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1190
1234
    if (code < 0)
1191
1235
    {
1192
 
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
 
1236
        dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1193
1237
                &s->vlcs[0][dc_index]);
1194
1238
        return 0xffff;
1195
1239
    }
1201
1245
}
1202
1246
 
1203
1247
/* decode block and dequantize */
1204
 
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
 
1248
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1205
1249
                        int component, int dc_index, int ac_index, int quant_index)
1206
1250
{
1207
1251
    int code, i, j, level, val;
1222
1266
    ac_vlc = &s->vlcs[1][ac_index];
1223
1267
    i = 1;
1224
1268
    for(;;) {
1225
 
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
 
1269
        code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1226
1270
 
1227
1271
        if (code < 0) {
1228
1272
            dprintf("error ac\n");
1256
1300
    int left[3], top[3], topleft[3];
1257
1301
    const int linesize= s->linesize[0];
1258
1302
    const int mask= (1<<s->bits)-1;
1259
 
    
 
1303
 
1260
1304
    if((unsigned)s->mb_width > 32768) //dynamic alloc
1261
1305
        return -1;
1262
 
    
 
1306
 
1263
1307
    for(i=0; i<3; i++){
1264
1308
        buffer[0][i]= 1 << (s->bits + point_transform - 1);
1265
1309
    }
1284
1328
                top[i]= buffer[mb_x][i];
1285
1329
 
1286
1330
                PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1287
 
                
1288
 
                left[i]= 
 
1331
 
 
1332
                left[i]=
1289
1333
                buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1290
1334
            }
1291
1335
 
1338
1382
                    x = 0;
1339
1383
                    y = 0;
1340
1384
                    linesize= s->linesize[c];
1341
 
                    
 
1385
 
1342
1386
                    for(j=0; j<n; j++) {
1343
1387
                        int pred;
1344
1388
 
1356
1400
                                PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1357
1401
                            }
1358
1402
                        }
1359
 
                        
 
1403
 
1360
1404
                        if (s->interlaced && s->bottom_field)
1361
1405
                            ptr += linesize >> 1;
1362
1406
                        *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1378
1422
                    x = 0;
1379
1423
                    y = 0;
1380
1424
                    linesize= s->linesize[c];
1381
 
                    
 
1425
 
1382
1426
                    for(j=0; j<n; j++) {
1383
1427
                        int pred;
1384
1428
 
1421
1465
                y = 0;
1422
1466
                for(j=0;j<n;j++) {
1423
1467
                    memset(s->block, 0, sizeof(s->block));
1424
 
                    if (decode_block(s, s->block, i, 
1425
 
                                     s->dc_index[i], s->ac_index[i], 
 
1468
                    if (decode_block(s, s->block, i,
 
1469
                                     s->dc_index[i], s->ac_index[i],
1426
1470
                                     s->quant_index[c]) < 0) {
1427
1471
                        dprintf("error y=%d x=%d\n", mb_y, mb_x);
1428
1472
                        return -1;
1429
1473
                    }
1430
 
//                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1431
 
                    ptr = s->picture.data[c] + 
1432
 
                        (((s->linesize[c] * (v * mb_y + y) * 8) + 
 
1474
//                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
 
1475
                    ptr = s->picture.data[c] +
 
1476
                        (((s->linesize[c] * (v * mb_y + y) * 8) +
1433
1477
                        (h * mb_x + x) * 8) >> s->avctx->lowres);
1434
1478
                    if (s->interlaced && s->bottom_field)
1435
1479
                        ptr += s->linesize[c] >> 1;
1459
1503
    int len, nb_components, i, h, v, predictor, point_transform;
1460
1504
    int vmax, hmax, index, id;
1461
1505
    const int block_size= s->lossless ? 1 : 8;
 
1506
    int ilv;
1462
1507
 
1463
1508
    /* XXX: verify len field validity */
1464
1509
    len = get_bits(&s->gb, 16);
1465
1510
    nb_components = get_bits(&s->gb, 8);
1466
1511
    if (len != 6+2*nb_components)
1467
1512
    {
1468
 
        dprintf("decode_sos: invalid len (%d)\n", len);
1469
 
        return -1;
 
1513
        dprintf("decode_sos: invalid len (%d)\n", len);
 
1514
        return -1;
1470
1515
    }
1471
1516
    /* XXX: only interleaved scan accepted */
1472
 
    if (nb_components != s->nb_components)
 
1517
    if ((nb_components != s->nb_components) && !s->ls)
1473
1518
    {
1474
 
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
 
1519
        dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1475
1520
        return -1;
1476
1521
    }
1477
1522
    vmax = 0;
1478
1523
    hmax = 0;
1479
1524
    for(i=0;i<nb_components;i++) {
1480
1525
        id = get_bits(&s->gb, 8) - 1;
1481
 
        dprintf("component: %d\n", id);
 
1526
        dprintf("component: %d\n", id);
1482
1527
        /* find component index */
1483
1528
        for(index=0;index<s->nb_components;index++)
1484
1529
            if (id == s->component_id[index])
1485
1530
                break;
1486
1531
        if (index == s->nb_components)
1487
 
        {
1488
 
            dprintf("decode_sos: index(%d) out of components\n", index);
 
1532
        {
 
1533
            dprintf("decode_sos: index(%d) out of components\n", index);
1489
1534
            return -1;
1490
 
        }
 
1535
        }
1491
1536
 
1492
1537
        s->comp_index[i] = index;
1493
1538
 
1498
1543
        s->dc_index[i] = get_bits(&s->gb, 4);
1499
1544
        s->ac_index[i] = get_bits(&s->gb, 4);
1500
1545
 
1501
 
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1502
 
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1503
 
            goto out_of_range;
 
1546
        if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
 
1547
            s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
 
1548
            goto out_of_range;
1504
1549
#if 0 //buggy
1505
 
        switch(s->start_code)
1506
 
        {
1507
 
            case SOF0:
1508
 
                if (dc_index[i] > 1 || ac_index[i] > 1)
1509
 
                    goto out_of_range;
1510
 
                break;
1511
 
            case SOF1:
1512
 
            case SOF2:
1513
 
                if (dc_index[i] > 3 || ac_index[i] > 3)
1514
 
                    goto out_of_range;
1515
 
                break;
1516
 
            case SOF3:
1517
 
                if (dc_index[i] > 3 || ac_index[i] != 0)
1518
 
                    goto out_of_range;
1519
 
                break;  
1520
 
        }
 
1550
        switch(s->start_code)
 
1551
        {
 
1552
            case SOF0:
 
1553
                if (dc_index[i] > 1 || ac_index[i] > 1)
 
1554
                    goto out_of_range;
 
1555
                break;
 
1556
            case SOF1:
 
1557
            case SOF2:
 
1558
                if (dc_index[i] > 3 || ac_index[i] > 3)
 
1559
                    goto out_of_range;
 
1560
                break;
 
1561
            case SOF3:
 
1562
                if (dc_index[i] > 3 || ac_index[i] != 0)
 
1563
                    goto out_of_range;
 
1564
                break;
 
1565
        }
1521
1566
#endif
1522
1567
    }
1523
1568
 
1524
 
    predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1525
 
    skip_bits(&s->gb, 8); /* Se */
 
1569
    predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
 
1570
    ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1526
1571
    skip_bits(&s->gb, 4); /* Ah */
1527
1572
    point_transform= get_bits(&s->gb, 4); /* Al */
1528
1573
 
1529
 
    for(i=0;i<nb_components;i++) 
 
1574
    for(i=0;i<nb_components;i++)
1530
1575
        s->last_dc[i] = 1024;
1531
1576
 
1532
1577
    if (nb_components > 1) {
1533
1578
        /* interleaved stream */
1534
1579
        s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1535
1580
        s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1536
 
    } else {
 
1581
    } else if(!s->ls) { /* skip this for JPEG-LS */
1537
1582
        h = s->h_max / s->h_scount[s->comp_index[0]];
1538
1583
        v = s->v_max / s->v_scount[s->comp_index[0]];
1539
1584
        s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1544
1589
    }
1545
1590
 
1546
1591
    if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1547
 
        av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1548
 
    
 
1592
        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" : "",
 
1593
               predictor, point_transform, ilv, s->bits,
 
1594
               s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
 
1595
 
 
1596
 
1549
1597
    /* mjpeg-b can have padding bytes between sos and image data, skip them */
1550
1598
    for (i = s->mjpb_skiptosod; i > 0; i--)
1551
1599
        skip_bits(&s->gb, 8);
1552
1600
 
1553
1601
    if(s->lossless){
 
1602
        if(s->ls){
 
1603
//            for(){
 
1604
//            reset_ls_coding_parameters(s, 0);
 
1605
 
 
1606
            ls_decode_picture(s, predictor, point_transform, ilv);
 
1607
        }else{
1554
1608
            if(s->rgb){
1555
1609
                if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1556
1610
                    return -1;
1558
1612
                if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1559
1613
                    return -1;
1560
1614
            }
 
1615
        }
1561
1616
    }else{
1562
1617
        if(mjpeg_decode_scan(s) < 0)
1563
1618
            return -1;
1572
1627
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1573
1628
{
1574
1629
    if (get_bits(&s->gb, 16) != 4)
1575
 
        return -1;
 
1630
        return -1;
1576
1631
    s->restart_interval = get_bits(&s->gb, 16);
1577
1632
    s->restart_count = 0;
1578
1633
    dprintf("restart interval: %d\n", s->restart_interval);
1586
1641
 
1587
1642
    len = get_bits(&s->gb, 16);
1588
1643
    if (len < 5)
1589
 
        return -1;
 
1644
        return -1;
1590
1645
    if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1591
1646
        return -1;
1592
1647
 
1595
1650
    len -= 6;
1596
1651
 
1597
1652
    if(s->avctx->debug & FF_DEBUG_STARTCODE){
1598
 
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
 
1653
        av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1599
1654
    }
1600
 
    
 
1655
 
1601
1656
    /* buggy AVID, it puts EOI only at every 10th frame */
1602
1657
    /* also this fourcc is used by non-avid files too, it holds some
1603
1658
       informations, but it's always present in AVID creates files */
1604
1659
    if (id == ff_get_fourcc("AVI1"))
1605
1660
    {
1606
 
        /* structure:
1607
 
            4bytes      AVI1
1608
 
            1bytes      polarity
1609
 
            1bytes      always zero
1610
 
            4bytes      field_size
1611
 
            4bytes      field_size_less_padding
1612
 
        */
1613
 
        s->buggy_avid = 1;
1614
 
//      if (s->first_picture)
1615
 
//          printf("mjpeg: workarounding buggy AVID\n");
1616
 
        s->interlace_polarity = get_bits(&s->gb, 8);
 
1661
        /* structure:
 
1662
            4bytes      AVI1
 
1663
            1bytes      polarity
 
1664
            1bytes      always zero
 
1665
            4bytes      field_size
 
1666
            4bytes      field_size_less_padding
 
1667
        */
 
1668
            s->buggy_avid = 1;
 
1669
//        if (s->first_picture)
 
1670
//            printf("mjpeg: workarounding buggy AVID\n");
 
1671
        s->interlace_polarity = get_bits(&s->gb, 8);
1617
1672
#if 0
1618
 
        skip_bits(&s->gb, 8);
1619
 
        skip_bits(&s->gb, 32);
1620
 
        skip_bits(&s->gb, 32);
1621
 
        len -= 10;
 
1673
        skip_bits(&s->gb, 8);
 
1674
        skip_bits(&s->gb, 32);
 
1675
        skip_bits(&s->gb, 32);
 
1676
        len -= 10;
1622
1677
#endif
1623
 
//      if (s->interlace_polarity)
1624
 
//          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1625
 
        goto out;
 
1678
//        if (s->interlace_polarity)
 
1679
//            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
 
1680
        goto out;
1626
1681
    }
1627
 
    
 
1682
 
1628
1683
//    len -= 2;
1629
 
    
 
1684
 
1630
1685
    if (id == ff_get_fourcc("JFIF"))
1631
1686
    {
1632
 
        int t_w, t_h, v1, v2;
1633
 
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
1634
 
        v1= get_bits(&s->gb, 8);
 
1687
        int t_w, t_h, v1, v2;
 
1688
        skip_bits(&s->gb, 8); /* the trailing zero-byte */
 
1689
        v1= get_bits(&s->gb, 8);
1635
1690
        v2= get_bits(&s->gb, 8);
1636
1691
        skip_bits(&s->gb, 8);
1637
1692
 
1645
1700
                s->avctx->sample_aspect_ratio.den
1646
1701
            );
1647
1702
 
1648
 
        t_w = get_bits(&s->gb, 8);
1649
 
        t_h = get_bits(&s->gb, 8);
1650
 
        if (t_w && t_h)
1651
 
        {
1652
 
            /* skip thumbnail */
1653
 
            if (len-10-(t_w*t_h*3) > 0)
1654
 
                len -= t_w*t_h*3;
1655
 
        }
1656
 
        len -= 10;
1657
 
        goto out;
 
1703
        t_w = get_bits(&s->gb, 8);
 
1704
        t_h = get_bits(&s->gb, 8);
 
1705
        if (t_w && t_h)
 
1706
        {
 
1707
            /* skip thumbnail */
 
1708
            if (len-10-(t_w*t_h*3) > 0)
 
1709
                len -= t_w*t_h*3;
 
1710
        }
 
1711
        len -= 10;
 
1712
        goto out;
1658
1713
    }
1659
 
    
 
1714
 
1660
1715
    if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1661
1716
    {
1662
1717
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1663
1718
            av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1664
 
        skip_bits(&s->gb, 16); /* version */
1665
 
        skip_bits(&s->gb, 16); /* flags0 */
1666
 
        skip_bits(&s->gb, 16); /* flags1 */
1667
 
        skip_bits(&s->gb, 8); /* transform */
1668
 
        len -= 7;
1669
 
        goto out;
 
1719
        skip_bits(&s->gb, 16); /* version */
 
1720
        skip_bits(&s->gb, 16); /* flags0 */
 
1721
        skip_bits(&s->gb, 16); /* flags1 */
 
1722
        skip_bits(&s->gb, 8);  /* transform */
 
1723
        len -= 7;
 
1724
        goto out;
1670
1725
    }
1671
1726
 
1672
1727
    if (id == ff_get_fourcc("LJIF")){
1673
1728
        if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1674
1729
            av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1675
 
        skip_bits(&s->gb, 16); /* version ? */
1676
 
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1677
 
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1678
 
        skip_bits(&s->gb, 16); /* unknwon always 0? */
 
1730
        skip_bits(&s->gb, 16); /* version ? */
 
1731
        skip_bits(&s->gb, 16); /* unknwon always 0? */
 
1732
        skip_bits(&s->gb, 16); /* unknwon always 0? */
 
1733
        skip_bits(&s->gb, 16); /* unknwon always 0? */
1679
1734
        switch( get_bits(&s->gb, 8)){
1680
1735
        case 1:
1681
1736
            s->rgb= 1;
1691
1746
        len -= 9;
1692
1747
        goto out;
1693
1748
    }
1694
 
    
 
1749
 
1695
1750
    /* Apple MJPEG-A */
1696
1751
    if ((s->start_code == APP1) && (len > (0x28 - 8)))
1697
1752
    {
1698
 
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1699
 
        id = be2me_32(id);
1700
 
        len -= 4;
1701
 
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1702
 
        {
 
1753
        id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
 
1754
        id = be2me_32(id);
 
1755
        len -= 4;
 
1756
        if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
 
1757
        {
1703
1758
#if 0
1704
 
            skip_bits(&s->gb, 32); /* field size */
1705
 
            skip_bits(&s->gb, 32); /* pad field size */
1706
 
            skip_bits(&s->gb, 32); /* next off */
1707
 
            skip_bits(&s->gb, 32); /* quant off */
1708
 
            skip_bits(&s->gb, 32); /* huff off */
1709
 
            skip_bits(&s->gb, 32); /* image off */
1710
 
            skip_bits(&s->gb, 32); /* scan off */
1711
 
            skip_bits(&s->gb, 32); /* data off */
 
1759
            skip_bits(&s->gb, 32); /* field size */
 
1760
            skip_bits(&s->gb, 32); /* pad field size */
 
1761
            skip_bits(&s->gb, 32); /* next off */
 
1762
            skip_bits(&s->gb, 32); /* quant off */
 
1763
            skip_bits(&s->gb, 32); /* huff off */
 
1764
            skip_bits(&s->gb, 32); /* image off */
 
1765
            skip_bits(&s->gb, 32); /* scan off */
 
1766
            skip_bits(&s->gb, 32); /* data off */
1712
1767
#endif
1713
1768
            if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714
 
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1715
 
        }
 
1769
                av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
 
1770
        }
1716
1771
    }
1717
1772
 
1718
1773
out:
1719
1774
    /* slow but needed for extreme adobe jpegs */
1720
1775
    if (len < 0)
1721
 
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
 
1776
        av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1722
1777
    while(--len > 0)
1723
 
        skip_bits(&s->gb, 8);
 
1778
        skip_bits(&s->gb, 8);
1724
1779
 
1725
1780
    return 0;
1726
1781
}
1729
1784
{
1730
1785
    int len = get_bits(&s->gb, 16);
1731
1786
    if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1732
 
        uint8_t *cbuf = av_malloc(len - 1);
1733
 
        if (cbuf) {
1734
 
            int i;
1735
 
            for (i = 0; i < len - 2; i++)
1736
 
                cbuf[i] = get_bits(&s->gb, 8);
1737
 
            if (i > 0 && cbuf[i-1] == '\n')
1738
 
                cbuf[i-1] = 0;
1739
 
            else
1740
 
                cbuf[i] = 0;
 
1787
        uint8_t *cbuf = av_malloc(len - 1);
 
1788
        if (cbuf) {
 
1789
            int i;
 
1790
            for (i = 0; i < len - 2; i++)
 
1791
                cbuf[i] = get_bits(&s->gb, 8);
 
1792
            if (i > 0 && cbuf[i-1] == '\n')
 
1793
                cbuf[i-1] = 0;
 
1794
            else
 
1795
                cbuf[i] = 0;
1741
1796
 
1742
1797
            if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1743
1798
                av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1744
1799
 
1745
 
            /* buggy avid, it puts EOI only at every 10th frame */
1746
 
            if (!strcmp(cbuf, "AVID"))
1747
 
            {
1748
 
                s->buggy_avid = 1;
1749
 
                //      if (s->first_picture)
1750
 
                //          printf("mjpeg: workarounding buggy AVID\n");
1751
 
            }
 
1800
            /* buggy avid, it puts EOI only at every 10th frame */
 
1801
            if (!strcmp(cbuf, "AVID"))
 
1802
            {
 
1803
                s->buggy_avid = 1;
 
1804
                //        if (s->first_picture)
 
1805
                //            printf("mjpeg: workarounding buggy AVID\n");
 
1806
            }
1752
1807
            else if(!strcmp(cbuf, "CS=ITU601")){
1753
1808
                s->cs_itu601= 1;
1754
1809
            }
1755
1810
 
1756
 
            av_free(cbuf);
1757
 
        }
 
1811
            av_free(cbuf);
 
1812
        }
1758
1813
    }
1759
1814
 
1760
1815
    return 0;
1797
1852
    buf_ptr = *pbuf_ptr;
1798
1853
    while (buf_ptr < buf_end - 1) {
1799
1854
        v = *buf_ptr++;
1800
 
        v2 = *buf_ptr;
 
1855
        v2 = *buf_ptr;
1801
1856
        if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1802
 
            val = *buf_ptr++;
1803
 
            goto found;
 
1857
            val = *buf_ptr++;
 
1858
            goto found;
1804
1859
        }
1805
1860
#ifdef DEBUG
1806
 
        skipped++;
 
1861
        skipped++;
1807
1862
#endif
1808
1863
    }
1809
1864
    val = -1;
1815
1870
    return val;
1816
1871
}
1817
1872
 
1818
 
static int mjpeg_decode_frame(AVCodecContext *avctx, 
 
1873
static int mjpeg_decode_frame(AVCodecContext *avctx,
1819
1874
                              void *data, int *data_size,
1820
1875
                              uint8_t *buf, int buf_size)
1821
1876
{
1829
1884
    while (buf_ptr < buf_end) {
1830
1885
        /* find start next marker */
1831
1886
        start_code = find_marker(&buf_ptr, buf_end);
1832
 
        {
1833
 
            /* EOF */
 
1887
        {
 
1888
            /* EOF */
1834
1889
            if (start_code < 0) {
1835
 
                goto the_end;
 
1890
                goto the_end;
1836
1891
            } else {
1837
1892
                dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1838
 
                
1839
 
                if ((buf_end - buf_ptr) > s->buffer_size)
1840
 
                {
1841
 
                    av_free(s->buffer);
1842
 
                    s->buffer_size = buf_end-buf_ptr;
 
1893
 
 
1894
                if ((buf_end - buf_ptr) > s->buffer_size)
 
1895
                {
 
1896
                    av_free(s->buffer);
 
1897
                    s->buffer_size = buf_end-buf_ptr;
1843
1898
                    s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1844
 
                    dprintf("buffer too small, expanding to %d bytes\n",
1845
 
                        s->buffer_size);
1846
 
                }
1847
 
                
1848
 
                /* unescape buffer of SOS */
1849
 
                if (start_code == SOS)
1850
 
                {
1851
 
                    uint8_t *src = buf_ptr;
1852
 
                    uint8_t *dst = s->buffer;
1853
 
 
1854
 
                    while (src<buf_end)
1855
 
                    {
1856
 
                        uint8_t x = *(src++);
1857
 
 
1858
 
                        *(dst++) = x;
1859
 
                        if (x == 0xff)
1860
 
                        {
 
1899
                    dprintf("buffer too small, expanding to %d bytes\n",
 
1900
                        s->buffer_size);
 
1901
                }
 
1902
 
 
1903
                /* unescape buffer of SOS, use special treatment for JPEG-LS */
 
1904
                if (start_code == SOS && !s->ls)
 
1905
                {
 
1906
                    uint8_t *src = buf_ptr;
 
1907
                    uint8_t *dst = s->buffer;
 
1908
 
 
1909
                    while (src<buf_end)
 
1910
                    {
 
1911
                        uint8_t x = *(src++);
 
1912
 
 
1913
                        *(dst++) = x;
 
1914
                        if (x == 0xff)
 
1915
                        {
1861
1916
                            while(src<buf_end && x == 0xff)
1862
1917
                                x = *(src++);
1863
1918
 
1864
 
                            if (x >= 0xd0 && x <= 0xd7)
1865
 
                                *(dst++) = x;
1866
 
                            else if (x)
1867
 
                                break;
1868
 
                        }
1869
 
                    }
1870
 
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1871
 
                    
1872
 
                    dprintf("escaping removed %d bytes\n",
1873
 
                        (buf_end - buf_ptr) - (dst - s->buffer));
1874
 
                }
1875
 
                else
1876
 
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1877
 
                
1878
 
                s->start_code = start_code;
 
1919
                            if (x >= 0xd0 && x <= 0xd7)
 
1920
                                *(dst++) = x;
 
1921
                            else if (x)
 
1922
                                break;
 
1923
                        }
 
1924
                    }
 
1925
                    init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
 
1926
 
 
1927
                    dprintf("escaping removed %d bytes\n",
 
1928
                        (buf_end - buf_ptr) - (dst - s->buffer));
 
1929
                }
 
1930
                else if(start_code == SOS && s->ls){
 
1931
                    uint8_t *src = buf_ptr;
 
1932
                    uint8_t *dst = s->buffer;
 
1933
                    int bit_count = 0;
 
1934
                    int t = 0, b = 0;
 
1935
                    PutBitContext pb;
 
1936
 
 
1937
                    s->cur_scan++;
 
1938
 
 
1939
                    /* find marker */
 
1940
                    while (src + t < buf_end){
 
1941
                        uint8_t x = src[t++];
 
1942
                        if (x == 0xff){
 
1943
                            while((src + t < buf_end) && x == 0xff)
 
1944
                                x = src[t++];
 
1945
                            if (x & 0x80) {
 
1946
                                t -= 2;
 
1947
                                break;
 
1948
                            }
 
1949
                        }
 
1950
                    }
 
1951
                    bit_count = t * 8;
 
1952
 
 
1953
                    init_put_bits(&pb, dst, t);
 
1954
 
 
1955
                    /* unescape bitstream */
 
1956
                    while(b < t){
 
1957
                        uint8_t x = src[b++];
 
1958
                        put_bits(&pb, 8, x);
 
1959
                        if(x == 0xFF){
 
1960
                            x = src[b++];
 
1961
                            put_bits(&pb, 7, x);
 
1962
                            bit_count--;
 
1963
                        }
 
1964
                    }
 
1965
                    flush_put_bits(&pb);
 
1966
 
 
1967
                    init_get_bits(&s->gb, dst, bit_count);
 
1968
                }
 
1969
                else
 
1970
                    init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
 
1971
 
 
1972
                s->start_code = start_code;
1879
1973
                if(s->avctx->debug & FF_DEBUG_STARTCODE){
1880
1974
                    av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1881
1975
                }
1882
1976
 
1883
 
                /* process markers */
1884
 
                if (start_code >= 0xd0 && start_code <= 0xd7) {
1885
 
                    dprintf("restart marker: %d\n", start_code&0x0f);
1886
 
                    /* APP fields */
1887
 
                } else if (start_code >= APP0 && start_code <= APP15) {
1888
 
                    mjpeg_decode_app(s);
1889
 
                    /* Comment */
1890
 
                } else if (start_code == COM){
1891
 
                    mjpeg_decode_com(s);
1892
 
                }
 
1977
                /* process markers */
 
1978
                if (start_code >= 0xd0 && start_code <= 0xd7) {
 
1979
                    dprintf("restart marker: %d\n", start_code&0x0f);
 
1980
                    /* APP fields */
 
1981
                } else if (start_code >= APP0 && start_code <= APP15) {
 
1982
                    mjpeg_decode_app(s);
 
1983
                    /* Comment */
 
1984
                } else if (start_code == COM){
 
1985
                    mjpeg_decode_com(s);
 
1986
                }
1893
1987
 
1894
1988
                switch(start_code) {
1895
1989
                case SOI:
1896
 
                    s->restart_interval = 0;
1897
 
                    s->restart_count = 0;
 
1990
                    s->restart_interval = 0;
 
1991
 
 
1992
                    s->restart_count = 0;
1898
1993
                    /* nothing to do on SOI */
1899
1994
                    break;
1900
1995
                case DQT:
1908
2003
                    break;
1909
2004
                case SOF0:
1910
2005
                    s->lossless=0;
1911
 
                    if (mjpeg_decode_sof(s) < 0) 
1912
 
                        return -1;
 
2006
                    if (mjpeg_decode_sof(s) < 0)
 
2007
                        return -1;
1913
2008
                    break;
1914
2009
                case SOF3:
1915
2010
                    s->lossless=1;
1916
 
                    if (mjpeg_decode_sof(s) < 0) 
1917
 
                        return -1;
1918
 
                    break;
1919
 
                case EOI:
1920
 
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
 
2011
                    if (mjpeg_decode_sof(s) < 0)
 
2012
                        return -1;
 
2013
                    break;
 
2014
                case SOF48:
 
2015
                    s->lossless=1;
 
2016
                    s->ls=1;
 
2017
                    if (mjpeg_decode_sof(s) < 0)
 
2018
                        return -1;
 
2019
                    break;
 
2020
                case LSE:
 
2021
                    if (decode_lse(s) < 0)
 
2022
                        return -1;
 
2023
                    break;
 
2024
                case EOI:
 
2025
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1921
2026
                        break;
1922
2027
eoi_parser:
1923
 
                    {
 
2028
                    {
1924
2029
                        if (s->interlaced) {
1925
2030
                            s->bottom_field ^= 1;
1926
2031
                            /* if not bottom field, do not output image yet */
1931
2036
                        *data_size = sizeof(AVFrame);
1932
2037
 
1933
2038
                        if(!s->lossless){
1934
 
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
 
2039
                            picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1935
2040
                            picture->qstride= 0;
1936
2041
                            picture->qscale_table= s->qscale_table;
1937
2042
                            memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1939
2044
                                av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1940
2045
                            picture->quality*= FF_QP2LAMBDA;
1941
2046
                        }
1942
 
                        
 
2047
 
1943
2048
                        goto the_end;
1944
2049
                    }
1945
 
                    break;
 
2050
                    break;
1946
2051
                case SOS:
1947
2052
                    mjpeg_decode_sos(s);
1948
 
                    /* buggy avid puts EOI every 10-20th frame */
1949
 
                    /* if restart period is over process EOI */
1950
 
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1951
 
                        goto eoi_parser;
1952
 
                    break;
1953
 
                case DRI:
1954
 
                    mjpeg_decode_dri(s);
1955
 
                    break;
1956
 
                case SOF1:
1957
 
                case SOF2:
1958
 
                case SOF5:
1959
 
                case SOF6:
1960
 
                case SOF7:
1961
 
                case SOF9:
1962
 
                case SOF10:
1963
 
                case SOF11:
1964
 
                case SOF13:
1965
 
                case SOF14:
1966
 
                case SOF15:
1967
 
                case JPG:
1968
 
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1969
 
                    break;
1970
 
//              default:
1971
 
//                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1972
 
//                  break;
 
2053
                    /* buggy avid puts EOI every 10-20th frame */
 
2054
                    /* if restart period is over process EOI */
 
2055
                    if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
 
2056
                        goto eoi_parser;
 
2057
                    break;
 
2058
                case DRI:
 
2059
                    mjpeg_decode_dri(s);
 
2060
                    break;
 
2061
                case SOF1:
 
2062
                case SOF2:
 
2063
                case SOF5:
 
2064
                case SOF6:
 
2065
                case SOF7:
 
2066
                case SOF9:
 
2067
                case SOF10:
 
2068
                case SOF11:
 
2069
                case SOF13:
 
2070
                case SOF14:
 
2071
                case SOF15:
 
2072
                case JPG:
 
2073
                    av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
 
2074
                    break;
 
2075
//                default:
 
2076
//                    printf("mjpeg: unsupported marker (%x)\n", start_code);
 
2077
//                    break;
1973
2078
                }
1974
2079
 
1975
2080
not_the_end:
1976
 
                /* eof process start code */
1977
 
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
1978
 
                dprintf("marker parser used %d bytes (%d bits)\n",
1979
 
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
 
2081
                /* eof process start code */
 
2082
                buf_ptr += (get_bits_count(&s->gb)+7)/8;
 
2083
                dprintf("marker parser used %d bytes (%d bits)\n",
 
2084
                    (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1980
2085
            }
1981
2086
        }
1982
2087
    }
1986
2091
    return buf_ptr - buf;
1987
2092
}
1988
2093
 
1989
 
static int mjpegb_decode_frame(AVCodecContext *avctx, 
 
2094
static int mjpegb_decode_frame(AVCodecContext *avctx,
1990
2095
                              void *data, int *data_size,
1991
2096
                              uint8_t *buf, int buf_size)
1992
2097
{
1999
2104
 
2000
2105
    buf_ptr = buf;
2001
2106
    buf_end = buf + buf_size;
2002
 
    
 
2107
 
2003
2108
read_header:
2004
2109
    /* reset on every SOI */
2005
2110
    s->restart_interval = 0;
2009
2114
    init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2010
2115
 
2011
2116
    skip_bits(&hgb, 32); /* reserved zeros */
2012
 
    
 
2117
 
2013
2118
    if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2014
2119
    {
2015
 
        dprintf("not mjpeg-b (bad fourcc)\n");
2016
 
        return 0;
 
2120
        dprintf("not mjpeg-b (bad fourcc)\n");
 
2121
        return 0;
2017
2122
    }
2018
2123
 
2019
2124
    field_size = get_bits_long(&hgb, 32); /* field size */
2022
2127
    second_field_offs = get_bits_long(&hgb, 32);
2023
2128
    dprintf("second field offs: 0x%x\n", second_field_offs);
2024
2129
    if (second_field_offs)
2025
 
        s->interlaced = 1;
 
2130
        s->interlaced = 1;
2026
2131
 
2027
2132
    dqt_offs = get_bits_long(&hgb, 32);
2028
2133
    dprintf("dqt offs: 0x%x\n", dqt_offs);
2029
2134
    if (dqt_offs)
2030
2135
    {
2031
 
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2032
 
        s->start_code = DQT;
2033
 
        mjpeg_decode_dqt(s);
 
2136
        init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
 
2137
        s->start_code = DQT;
 
2138
        mjpeg_decode_dqt(s);
2034
2139
    }
2035
 
    
 
2140
 
2036
2141
    dht_offs = get_bits_long(&hgb, 32);
2037
2142
    dprintf("dht offs: 0x%x\n", dht_offs);
2038
2143
    if (dht_offs)
2039
2144
    {
2040
 
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2041
 
        s->start_code = DHT;
2042
 
        mjpeg_decode_dht(s);
 
2145
        init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
 
2146
        s->start_code = DHT;
 
2147
        mjpeg_decode_dht(s);
2043
2148
    }
2044
2149
 
2045
2150
    sof_offs = get_bits_long(&hgb, 32);
2046
2151
    dprintf("sof offs: 0x%x\n", sof_offs);
2047
2152
    if (sof_offs)
2048
2153
    {
2049
 
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2050
 
        s->start_code = SOF0;
2051
 
        if (mjpeg_decode_sof(s) < 0)
2052
 
            return -1;
 
2154
        init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
 
2155
        s->start_code = SOF0;
 
2156
        if (mjpeg_decode_sof(s) < 0)
 
2157
            return -1;
2053
2158
    }
2054
2159
 
2055
2160
    sos_offs = get_bits_long(&hgb, 32);
2058
2163
    dprintf("sod offs: 0x%x\n", sod_offs);
2059
2164
    if (sos_offs)
2060
2165
    {
2061
 
//      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2062
 
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2063
 
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2064
 
        s->start_code = SOS;
2065
 
        mjpeg_decode_sos(s);
 
2166
//        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
 
2167
        init_get_bits(&s->gb, buf+sos_offs, field_size*8);
 
2168
        s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
 
2169
        s->start_code = SOS;
 
2170
        mjpeg_decode_sos(s);
2066
2171
    }
2067
2172
 
2068
2173
    if (s->interlaced) {
2069
2174
        s->bottom_field ^= 1;
2070
2175
        /* if not bottom field, do not output image yet */
2071
2176
        if (s->bottom_field && second_field_offs)
2072
 
        {
2073
 
            buf_ptr = buf + second_field_offs;
2074
 
            second_field_offs = 0;
2075
 
            goto read_header;
2076
 
        }
 
2177
        {
 
2178
            buf_ptr = buf + second_field_offs;
 
2179
            second_field_offs = 0;
 
2180
            goto read_header;
 
2181
            }
2077
2182
    }
2078
2183
 
2079
2184
    //XXX FIXME factorize, this looks very similar to the EOI code
2080
2185
 
2081
2186
    *picture= s->picture;
2082
2187
    *data_size = sizeof(AVFrame);
2083
 
    
 
2188
 
2084
2189
    if(!s->lossless){
2085
 
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
 
2190
        picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2086
2191
        picture->qstride= 0;
2087
2192
        picture->qscale_table= s->qscale_table;
2088
2193
        memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2096
2201
 
2097
2202
#include "sp5x.h"
2098
2203
 
2099
 
static int sp5x_decode_frame(AVCodecContext *avctx, 
 
2204
static int sp5x_decode_frame(AVCodecContext *avctx,
2100
2205
                              void *data, int *data_size,
2101
2206
                              uint8_t *buf, int buf_size)
2102
2207
{
2108
2213
    int i = 0, j = 0;
2109
2214
 
2110
2215
    if (!avctx->width || !avctx->height)
2111
 
        return -1;
 
2216
        return -1;
2112
2217
 
2113
2218
    buf_ptr = buf;
2114
2219
    buf_end = buf + buf_size;
2116
2221
#if 1
2117
2222
    recoded = av_mallocz(buf_size + 1024);
2118
2223
    if (!recoded)
2119
 
        return -1;
 
2224
        return -1;
2120
2225
 
2121
2226
    /* SOI */
2122
2227
    recoded[j++] = 0xFF;
2142
2247
 
2143
2248
    for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2144
2249
    {
2145
 
        recoded[j++] = buf[i];
2146
 
        if (buf[i] == 0xff)
2147
 
            recoded[j++] = 0;
 
2250
        recoded[j++] = buf[i];
 
2251
        if (buf[i] == 0xff)
 
2252
            recoded[j++] = 0;
2148
2253
    }
2149
2254
 
2150
2255
    /* EOI */
2175
2280
    s->quant_index[2] = 1;
2176
2281
    s->h_max = 2;
2177
2282
    s->v_max = 2;
2178
 
    
 
2283
 
2179
2284
    s->qscale_table = av_mallocz((s->width+15)/16);
2180
2285
    avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2181
2286
    s->interlaced = 0;
2182
 
    
 
2287
 
2183
2288
    s->picture.reference = 0;
2184
2289
    if (avctx->get_buffer(avctx, &s->picture) < 0)
2185
2290
    {
2186
2291
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2187
 
        return -1;
 
2292
        return -1;
2188
2293
    }
2189
2294
 
2190
2295
    s->picture.pict_type = I_TYPE;
2191
2296
    s->picture.key_frame = 1;
2192
2297
 
2193
2298
    for (i = 0; i < 3; i++)
2194
 
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
 
2299
        s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2195
2300
 
2196
2301
    /* DQT */
2197
2302
    for (i = 0; i < 64; i++)
2198
2303
    {
2199
 
        j = s->scantable.permutated[i];
2200
 
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
 
2304
        j = s->scantable.permutated[i];
 
2305
        s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2201
2306
    }
2202
2307
    s->qscale[0] = FFMAX(
2203
 
        s->quant_matrixes[0][s->scantable.permutated[1]],
2204
 
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
 
2308
        s->quant_matrixes[0][s->scantable.permutated[1]],
 
2309
        s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2205
2310
 
2206
2311
    for (i = 0; i < 64; i++)
2207
2312
    {
2208
 
        j = s->scantable.permutated[i];
2209
 
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
 
2313
        j = s->scantable.permutated[i];
 
2314
        s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2210
2315
    }
2211
2316
    s->qscale[1] = FFMAX(
2212
 
        s->quant_matrixes[1][s->scantable.permutated[1]],
2213
 
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
 
2317
        s->quant_matrixes[1][s->scantable.permutated[1]],
 
2318
        s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2214
2319
 
2215
2320
    /* DHT */
2216
2321
 
2235
2340
    s->v_scount[2] = s->v_count[2];
2236
2341
    s->dc_index[2] = 1;
2237
2342
    s->ac_index[2] = 1;
2238
 
    
 
2343
 
2239
2344
    for (i = 0; i < 3; i++)
2240
 
        s->last_dc[i] = 1024;
 
2345
        s->last_dc[i] = 1024;
2241
2346
 
2242
2347
    s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2243
2348
    s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2244
2349
 
2245
2350
    init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2246
 
    
 
2351
 
2247
2352
    return mjpeg_decode_scan(s);
2248
2353
#endif
2249
2354
 
2257
2362
 
2258
2363
    av_free(s->buffer);
2259
2364
    av_free(s->qscale_table);
2260
 
    
 
2365
 
2261
2366
    for(i=0;i<2;i++) {
2262
2367
        for(j=0;j<4;j++)
2263
2368
            free_vlc(&s->vlcs[i][j]);