251
#ifdef CONFIG_ENCODERS
252
int mjpeg_init(MpegEncContext *s)
256
m = av_malloc(sizeof(MJpegContext));
263
/* build all the huffman tables */
264
build_huffman_codes(m->huff_size_dc_luminance,
265
m->huff_code_dc_luminance,
268
build_huffman_codes(m->huff_size_dc_chrominance,
269
m->huff_code_dc_chrominance,
272
build_huffman_codes(m->huff_size_ac_luminance,
273
m->huff_code_ac_luminance,
276
build_huffman_codes(m->huff_size_ac_chrominance,
277
m->huff_code_ac_chrominance,
285
void mjpeg_close(MpegEncContext *s)
287
av_free(s->mjpeg_ctx);
289
#endif //CONFIG_ENCODERS
291
#define PREDICT(ret, topleft, top, left, predictor)\
293
case 1: ret= left; break;\
294
case 2: ret= top; break;\
295
case 3: ret= topleft; break;\
296
case 4: ret= left + top - topleft; break;\
297
case 5: ret= left + ((top - topleft)>>1); break;\
298
case 6: ret= top + ((left - topleft)>>1); break;\
300
case 7: ret= (left + top)>>1; break;\
303
#ifdef CONFIG_ENCODERS
304
static inline void put_marker(PutBitContext *p, int code)
306
put_bits(p, 8, 0xff);
307
put_bits(p, 8, code);
310
/* table_class: 0 = DC coef, 1 = AC coefs */
311
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
312
const uint8_t *bits_table, const uint8_t *value_table)
314
PutBitContext *p = &s->pb;
317
put_bits(p, 4, table_class);
318
put_bits(p, 4, table_id);
323
put_bits(p, 8, bits_table[i]);
327
put_bits(p, 8, value_table[i]);
332
static void jpeg_table_header(MpegEncContext *s)
334
PutBitContext *p = &s->pb;
341
put_bits(p, 16, 2 + 2 * (1 + 64));
343
put_bits(p, 16, 2 + 1 * (1 + 64));
345
put_bits(p, 4, 0); /* 8 bit precision */
346
put_bits(p, 4, 0); /* table 0 */
348
j = s->intra_scantable.permutated[i];
349
put_bits(p, 8, s->intra_matrix[j]);
352
put_bits(p, 4, 0); /* 8 bit precision */
353
put_bits(p, 4, 1); /* table 1 */
355
j = s->intra_scantable.permutated[i];
356
put_bits(p, 8, s->chroma_intra_matrix[j]);
364
put_bits(p, 16, 0); /* patched later */
366
size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
367
size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
369
size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
370
size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
375
static void jpeg_put_comments(MpegEncContext *s)
377
PutBitContext *p = &s->pb;
381
if (s->aspect_ratio_info /* && !lossless */)
386
ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
387
put_bits(p, 16, 0x0201); /* v 1.02 */
388
put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
389
put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
390
put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
391
put_bits(p, 8, 0); /* thumbnail width */
392
put_bits(p, 8, 0); /* thumbnail height */
396
if(!(s->flags & CODEC_FLAG_BITEXACT)){
400
put_bits(p, 16, 0); /* patched later */
401
ff_put_string(p, LIBAVCODEC_IDENT, 1);
402
size = strlen(LIBAVCODEC_IDENT)+3;
407
if( s->avctx->pix_fmt == PIX_FMT_YUV420P
408
||s->avctx->pix_fmt == PIX_FMT_YUV422P
409
||s->avctx->pix_fmt == PIX_FMT_YUV444P){
413
put_bits(p, 16, 0); /* patched later */
414
ff_put_string(p, "CS=ITU601", 1);
415
size = strlen("CS=ITU601")+3;
421
void mjpeg_picture_header(MpegEncContext *s)
423
const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
424
const int ls = s->avctx->codec_id == CODEC_ID_JPEGLS;
426
assert(!(ls && s->mjpeg_write_tables));
428
put_marker(&s->pb, SOI);
430
if (!s->mjpeg_data_only_frames)
432
jpeg_put_comments(s);
434
if (s->mjpeg_write_tables) jpeg_table_header(s);
436
switch(s->avctx->codec_id){
437
case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
438
case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
439
case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
443
put_bits(&s->pb, 16, 17);
444
if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)
445
put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
447
put_bits(&s->pb, 8, 8); /* 8 bits/component */
448
put_bits(&s->pb, 16, s->height);
449
put_bits(&s->pb, 16, s->width);
450
put_bits(&s->pb, 8, 3); /* 3 components */
453
put_bits(&s->pb, 8, 1); /* component number */
454
put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
455
put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
456
put_bits(&s->pb, 8, 0); /* select matrix */
459
put_bits(&s->pb, 8, 2); /* component number */
460
put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
461
put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
463
put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
465
put_bits(&s->pb, 8, 0); /* select matrix */
469
put_bits(&s->pb, 8, 3); /* component number */
470
put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
471
put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
473
put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
475
put_bits(&s->pb, 8, 0); /* select matrix */
480
put_marker(&s->pb, SOS);
481
put_bits(&s->pb, 16, 12); /* length */
482
put_bits(&s->pb, 8, 3); /* 3 components */
485
put_bits(&s->pb, 8, 1); /* index */
486
put_bits(&s->pb, 4, 0); /* DC huffman table index */
487
put_bits(&s->pb, 4, 0); /* AC huffman table index */
490
put_bits(&s->pb, 8, 2); /* index */
491
put_bits(&s->pb, 4, 1); /* DC huffman table index */
492
put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
495
put_bits(&s->pb, 8, 3); /* index */
496
put_bits(&s->pb, 4, 1); /* DC huffman table index */
497
put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
499
put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
501
switch(s->avctx->codec_id){
502
case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
503
case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
504
case CODEC_ID_JPEGLS: put_bits(&s->pb, 8, 1); break; /* ILV = line interleaved */
508
put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
510
//FIXME DC/AC entropy table selectors stuff in jpegls
513
static void escape_FF(MpegEncContext *s, int start)
515
int size= put_bits_count(&s->pb) - start*8;
517
uint8_t *buf= s->pb.buf + start;
518
int align= (-(size_t)(buf))&3;
520
assert((size&7) == 0);
524
for(i=0; i<size && i<align; i++){
525
if(buf[i]==0xFF) ff_count++;
527
for(; i<size-15; i+=16){
530
v= *(uint32_t*)(&buf[i]);
531
acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
532
v= *(uint32_t*)(&buf[i+4]);
533
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
534
v= *(uint32_t*)(&buf[i+8]);
535
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
536
v= *(uint32_t*)(&buf[i+12]);
537
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
545
if(buf[i]==0xFF) ff_count++;
548
if(ff_count==0) return;
551
for(i=0; i<ff_count-3; i+=4)
552
put_bits(&s->pb, 32, 0);
553
put_bits(&s->pb, (ff_count-i)*8, 0);
554
flush_put_bits(&s->pb);
556
for(i=size-1; ff_count; i--){
560
//printf("%d %d\n", i, ff_count);
569
void ff_mjpeg_stuffing(PutBitContext * pbc)
572
length= (-put_bits_count(pbc))&7;
573
if(length) put_bits(pbc, length, (1<<length)-1);
576
void mjpeg_picture_trailer(MpegEncContext *s)
578
ff_mjpeg_stuffing(&s->pb);
579
flush_put_bits(&s->pb);
581
assert((s->header_bits&7)==0);
583
escape_FF(s, s->header_bits>>3);
585
put_marker(&s->pb, EOI);
588
static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
589
uint8_t *huff_size, uint16_t *huff_code)
594
put_bits(&s->pb, huff_size[0], huff_code[0]);
602
nbits= av_log2_16bit(val) + 1;
604
put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
606
put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
610
static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
612
int mant, nbits, code, i, j;
613
int component, dc, run, last_index, val;
614
MJpegContext *m = s->mjpeg_ctx;
615
uint8_t *huff_size_ac;
616
uint16_t *huff_code_ac;
619
component = (n <= 3 ? 0 : (n&1) + 1);
620
dc = block[0]; /* overflow is impossible */
621
val = dc - s->last_dc[component];
623
mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
624
huff_size_ac = m->huff_size_ac_luminance;
625
huff_code_ac = m->huff_code_ac_luminance;
627
mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
628
huff_size_ac = m->huff_size_ac_chrominance;
629
huff_code_ac = m->huff_code_ac_chrominance;
631
s->last_dc[component] = dc;
636
last_index = s->block_last_index[n];
637
for(i=1;i<=last_index;i++) {
638
j = s->intra_scantable.permutated[i];
644
put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
653
nbits= av_log2(val) + 1;
654
code = (run << 4) | nbits;
656
put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
658
put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
663
/* output EOB only if not already 64 values */
664
if (last_index < 63 || run != 0)
665
put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
668
void mjpeg_encode_mb(MpegEncContext *s,
669
DCTELEM block[6][64])
673
encode_block(s, block[i], i);
675
if (s->chroma_format == CHROMA_420) {
676
encode_block(s, block[5], 5);
678
encode_block(s, block[6], 6);
679
encode_block(s, block[5], 5);
680
encode_block(s, block[7], 7);
684
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
685
MpegEncContext * const s = avctx->priv_data;
686
MJpegContext * const m = s->mjpeg_ctx;
687
AVFrame *pict = data;
688
const int width= s->width;
689
const int height= s->height;
690
AVFrame * const p= (AVFrame*)&s->current_picture;
691
const int predictor= avctx->prediction_method+1;
693
init_put_bits(&s->pb, buf, buf_size);
696
p->pict_type= FF_I_TYPE;
699
mjpeg_picture_header(s);
701
s->header_bits= put_bits_count(&s->pb);
703
if(avctx->pix_fmt == PIX_FMT_RGB32){
705
const int linesize= p->linesize[0];
706
uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
707
int left[3], top[3], topleft[3];
710
buffer[0][i]= 1 << (9 - 1);
713
for(y = 0; y < height; y++) {
714
const int modified_predictor= y ? predictor : 1;
715
uint8_t *ptr = p->data[0] + (linesize * y);
717
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
718
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
723
top[i]= left[i]= topleft[i]= buffer[0][i];
725
for(x = 0; x < width; x++) {
726
buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
727
buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
728
buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
733
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
736
top[i]= buffer[x+1][i];
738
left[i]= buffer[x][i];
740
diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
743
mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
745
mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
751
const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
752
const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
754
for(mb_y = 0; mb_y < mb_height; mb_y++) {
755
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]){
756
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
759
for(mb_x = 0; mb_x < mb_width; mb_x++) {
760
if(mb_x==0 || mb_y==0){
763
int x, y, h, v, linesize;
764
h = s->mjpeg_hsample[i];
765
v = s->mjpeg_vsample[i];
766
linesize= p->linesize[i];
772
ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
781
pred= ptr[-linesize];
783
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
788
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
790
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
797
int x, y, h, v, linesize;
798
h = s->mjpeg_hsample[i];
799
v = s->mjpeg_vsample[i];
800
linesize= p->linesize[i];
806
ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
807
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
808
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
811
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
813
mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
824
mjpeg_picture_trailer(s);
827
flush_put_bits(&s->pb);
828
return pbBufPtr(&s->pb) - s->pb.buf;
829
// return (put_bits_count(&f->pb)+7)/8;
832
#endif //CONFIG_ENCODERS
834
/******************************************/
837
#define MAX_COMPONENTS 4
839
typedef struct MJpegDecodeContext {
840
AVCodecContext *avctx;
842
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
844
int start_code; /* current start code */
848
int16_t quant_matrixes[4][64];
850
int qscale[4]; ///< quantizer scale calculated from quant_matrixes
852
int org_height; /* size given at codec init */
853
int first_picture; /* true if decoding first picture */
854
int interlaced; /* true if interlaced */
855
int bottom_field; /* true if bottom field */
860
int rct; /* standard rct */
861
int pegasus_rct; /* pegasus reversible colorspace transform */
862
int bits; /* bits per component */
865
int near; ///< near lossless bound (si 0 for lossless)
867
int reset; ///< context halfing intervall ?rename
870
int mb_width, mb_height;
872
int component_id[MAX_COMPONENTS];
873
int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
874
int v_count[MAX_COMPONENTS];
875
int comp_index[MAX_COMPONENTS];
876
int dc_index[MAX_COMPONENTS];
877
int ac_index[MAX_COMPONENTS];
878
int nb_blocks[MAX_COMPONENTS];
879
int h_scount[MAX_COMPONENTS];
880
int v_scount[MAX_COMPONENTS];
881
int h_max, v_max; /* maximum h and v counts */
882
int quant_index[4]; /* quant table index for each component */
883
int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
884
AVFrame picture; /* picture structure */
885
int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
886
int8_t *qscale_table;
887
DECLARE_ALIGNED_8(DCTELEM, block[64]);
889
void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
890
void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
892
int restart_interval;
897
int interlace_polarity;
901
int cur_scan; /* current scan, used by JPEG-LS */
902
} MJpegDecodeContext;
904
#include "jpeg_ls.c" //FIXME make jpeg-ls more independent
906
static int mjpeg_decode_dht(MJpegDecodeContext *s);
908
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
909
int nb_codes, int use_static, int is_ac)
911
uint8_t huff_size[256+16];
912
uint16_t huff_code[256+16];
914
assert(nb_codes <= 256);
916
memset(huff_size, 0, sizeof(huff_size));
917
build_huffman_codes(huff_size, huff_code, bits_table, val_table);
920
memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
921
memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
922
memset(huff_size, 0, sizeof(uint8_t)*16);
923
memset(huff_code, 0, sizeof(uint16_t)*16);
927
return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
930
static int mjpeg_decode_init(AVCodecContext *avctx)
932
MJpegDecodeContext *s = avctx->priv_data;
934
memset(s, 0, sizeof(MJpegDecodeContext));
938
/* ugly way to get the idct & scantable FIXME */
939
memset(&s2, 0, sizeof(MpegEncContext));
941
// s2->out_format = FMT_MJPEG;
942
dsputil_init(&s2.dsp, avctx);
943
DCT_common_init(&s2);
945
s->scantable= s2.intra_scantable;
946
s->idct_put= s2.dsp.idct_put;
947
s->idct_add= s2.dsp.idct_add;
949
s->mpeg_enc_ctx_allocated = 0;
953
s->first_picture = 1;
954
s->org_height = avctx->coded_height;
956
build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
957
build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
958
build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
959
build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
961
if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
963
av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
964
init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
966
/* should check for error - but dunno */
968
if (avctx->extradata_size > 9 &&
969
AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) {
970
if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */
971
s->interlace_polarity = 1; /* bottom field first */
972
av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
981
* finds the end of the current frame in the bitstream.
982
* @return the position of the first byte of the next frame, or -1
984
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
988
vop_found= pc->frame_start_found;
993
for(i=0; i<buf_size; i++){
994
state= (state<<8) | buf[i];
1004
/* EOF considered as end of frame */
1007
for(; i<buf_size; i++){
1008
state= (state<<8) | buf[i];
1009
if(state == 0xFFD8){
1010
pc->frame_start_found=0;
1016
pc->frame_start_found= vop_found;
1018
return END_NOT_FOUND;
1021
static int jpeg_parse(AVCodecParserContext *s,
1022
AVCodecContext *avctx,
1023
uint8_t **poutbuf, int *poutbuf_size,
1024
const uint8_t *buf, int buf_size)
1026
ParseContext *pc = s->priv_data;
1029
next= find_frame_end(pc, buf, buf_size);
1031
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1037
*poutbuf = (uint8_t *)buf;
1038
*poutbuf_size = buf_size;
1042
/* quantize tables */
1043
static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1045
int len, index, i, j;
1047
len = get_bits(&s->gb, 16) - 2;
1050
/* only 8 bit precision handled */
1051
if (get_bits(&s->gb, 4) != 0)
1053
av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
1056
index = get_bits(&s->gb, 4);
1059
av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
1060
/* read quant table */
1062
j = s->scantable.permutated[i];
1063
s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1066
//XXX FIXME finetune, and perhaps add dc too
1067
s->qscale[index]= FFMAX(
1068
s->quant_matrixes[index][s->scantable.permutated[1]],
1069
s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1070
av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
1077
/* decode huffman tables and build VLC decoders */
1078
static int mjpeg_decode_dht(MJpegDecodeContext *s)
1080
int len, index, i, class, n, v, code_max;
1081
uint8_t bits_table[17];
1082
uint8_t val_table[256];
1084
len = get_bits(&s->gb, 16) - 2;
1089
class = get_bits(&s->gb, 4);
1092
index = get_bits(&s->gb, 4);
1096
for(i=1;i<=16;i++) {
1097
bits_table[i] = get_bits(&s->gb, 8);
1101
if (len < n || n > 256)
1106
v = get_bits(&s->gb, 8);
1113
/* build VLC and flush previous vlc if present */
1114
free_vlc(&s->vlcs[class][index]);
1115
av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
1116
class, index, code_max + 1);
1117
if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1124
static int mjpeg_decode_sof(MJpegDecodeContext *s)
1126
int len, nb_components, i, width, height, pix_fmt_id;
1128
/* XXX: verify len field validity */
1129
len = get_bits(&s->gb, 16);
1130
s->bits= get_bits(&s->gb, 8);
1132
if(s->pegasus_rct) s->bits=9;
1133
if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1135
if (s->bits != 8 && !s->lossless){
1136
av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1140
height = get_bits(&s->gb, 16);
1141
width = get_bits(&s->gb, 16);
1143
av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
1144
if(avcodec_check_dimensions(s->avctx, width, height))
1147
nb_components = get_bits(&s->gb, 8);
1148
if (nb_components <= 0 ||
1149
nb_components > MAX_COMPONENTS)
1151
if (s->ls && !(s->bits <= 8 || nb_components == 1)){
1152
av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
1155
s->nb_components = nb_components;
1158
for(i=0;i<nb_components;i++) {
1160
s->component_id[i] = get_bits(&s->gb, 8) - 1;
1161
s->h_count[i] = get_bits(&s->gb, 4);
1162
s->v_count[i] = get_bits(&s->gb, 4);
1163
/* compute hmax and vmax (only used in interleaved case) */
1164
if (s->h_count[i] > s->h_max)
1165
s->h_max = s->h_count[i];
1166
if (s->v_count[i] > s->v_max)
1167
s->v_max = s->v_count[i];
1168
s->quant_index[i] = get_bits(&s->gb, 8);
1169
if (s->quant_index[i] >= 4)
1171
av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1172
s->v_count[i], s->component_id[i], s->quant_index[i]);
1175
if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1176
av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1180
if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1182
/* if different size, realloc/alloc picture */
1183
/* XXX: also check h_count and v_count */
1184
if (width != s->width || height != s->height) {
1185
av_freep(&s->qscale_table);
1190
/* test interlaced mode */
1191
if (s->first_picture &&
1192
s->org_height != 0 &&
1193
s->height < ((s->org_height * 3) / 4)) {
1195
s->bottom_field = s->interlace_polarity;
1196
s->picture.interlaced_frame = 1;
1197
s->picture.top_field_first = !s->interlace_polarity;
1201
avcodec_set_dimensions(s->avctx, width, height);
1203
s->qscale_table= av_mallocz((s->width+15)/16);
1205
s->first_picture = 0;
1208
if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
1211
/* XXX: not complete test ! */
1212
pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1213
(s->h_count[1] << 12) | (s->v_count[1] << 8) |
1214
(s->h_count[2] << 4) | s->v_count[2];
1215
av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
1220
s->avctx->pix_fmt = PIX_FMT_RGB32;
1221
}else if(s->nb_components==3)
1222
s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1224
s->avctx->pix_fmt = PIX_FMT_GRAY8;
1228
s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1232
s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1236
if(s->nb_components > 1)
1237
s->avctx->pix_fmt = PIX_FMT_RGB24;
1238
else if(s->bits <= 8)
1239
s->avctx->pix_fmt = PIX_FMT_GRAY8;
1241
s->avctx->pix_fmt = PIX_FMT_GRAY16;
1244
if(s->picture.data[0])
1245
s->avctx->release_buffer(s->avctx, &s->picture);
1247
s->picture.reference= 0;
1248
if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1249
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1252
s->picture.pict_type= I_TYPE;
1253
s->picture.key_frame= 1;
1256
s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1259
// printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1261
if (len != (8+(3*nb_components)))
1263
av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1266
/* totally blank picture as progressive JPEG will only add details to it */
1268
memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1269
memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1270
memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1275
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1278
code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1281
av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1282
&s->vlcs[0][dc_index]);
1287
return get_xbits(&s->gb, code);
1292
/* decode block and dequantize */
1293
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1294
int component, int dc_index, int ac_index, int16_t *quant_matrix)
1296
int code, i, j, level, val;
1299
val = mjpeg_decode_dc(s, dc_index);
1300
if (val == 0xffff) {
1301
av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1304
val = val * quant_matrix[0] + s->last_dc[component];
1305
s->last_dc[component] = val;
1309
{OPEN_READER(re, &s->gb)
1311
UPDATE_CACHE(re, &s->gb);
1312
GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1317
i += ((unsigned)code) >> 4;
1320
if(code > MIN_CACHE_BITS - 16){
1321
UPDATE_CACHE(re, &s->gb)
1324
int cache=GET_CACHE(re,&s->gb);
1325
int sign=(~cache)>>31;
1326
level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1329
LAST_SKIP_BITS(re, &s->gb, code)
1333
j = s->scantable.permutated[63];
1334
block[j] = level * quant_matrix[j];
1337
av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1340
j = s->scantable.permutated[i];
1341
block[j] = level * quant_matrix[j];
1344
CLOSE_READER(re, &s->gb)}
1349
/* decode block and dequantize - progressive JPEG version */
1350
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1351
int component, int dc_index, int ac_index, int16_t *quant_matrix,
1352
int ss, int se, int Ah, int Al, int *EOBRUN)
1354
int code, i, j, level, val, run;
1358
val = mjpeg_decode_dc(s, dc_index);
1359
if (val == 0xffff) {
1360
av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1363
val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1366
s->last_dc[component] = val;
1374
{OPEN_READER(re, &s->gb)
1376
UPDATE_CACHE(re, &s->gb);
1377
GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1378
/* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1381
i += ((unsigned) code) >> 4;
1383
if(code > MIN_CACHE_BITS - 16){
1384
UPDATE_CACHE(re, &s->gb)
1387
int cache=GET_CACHE(re,&s->gb);
1388
int sign=(~cache)>>31;
1389
level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1392
LAST_SKIP_BITS(re, &s->gb, code)
1396
j = s->scantable.permutated[se];
1397
block[j] = level * quant_matrix[j] << Al;
1400
av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1403
j = s->scantable.permutated[i];
1404
block[j] = level * quant_matrix[j] << Al;
1406
run = ((unsigned) code) >> 4;
1407
if(run == 0xF){// ZRL - skip 15 coefficients
1412
UPDATE_CACHE(re, &s->gb);
1413
run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1415
LAST_SKIP_BITS(re, &s->gb, val);
1421
CLOSE_READER(re, &s->gb)}
1426
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1428
uint16_t buffer[32768][4];
1429
int left[3], top[3], topleft[3];
1430
const int linesize= s->linesize[0];
1431
const int mask= (1<<s->bits)-1;
1433
if((unsigned)s->mb_width > 32768) //dynamic alloc
1437
buffer[0][i]= 1 << (s->bits + point_transform - 1);
1439
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1440
const int modified_predictor= mb_y ? predictor : 1;
1441
uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1443
if (s->interlaced && s->bottom_field)
1444
ptr += linesize >> 1;
1447
top[i]= left[i]= topleft[i]= buffer[0][i];
1449
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1450
if (s->restart_interval && !s->restart_count)
1451
s->restart_count = s->restart_interval;
1457
top[i]= buffer[mb_x][i];
1459
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1462
buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1465
if (s->restart_interval && !--s->restart_count) {
1466
align_get_bits(&s->gb);
1467
skip_bits(&s->gb, 16); /* skip RSTn */
1472
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1473
ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1474
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1475
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1477
}else if(s->pegasus_rct){
1478
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1479
ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1480
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1481
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1484
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1485
ptr[4*mb_x+0] = buffer[mb_x][0];
1486
ptr[4*mb_x+1] = buffer[mb_x][1];
1487
ptr[4*mb_x+2] = buffer[mb_x][2];
1494
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1496
const int nb_components=3;
1498
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1499
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1500
if (s->restart_interval && !s->restart_count)
1501
s->restart_count = s->restart_interval;
1503
if(mb_x==0 || mb_y==0 || s->interlaced){
1504
for(i=0;i<nb_components;i++) {
1506
int n, h, v, x, y, c, j, linesize;
1507
n = s->nb_blocks[i];
1508
c = s->comp_index[i];
1513
linesize= s->linesize[c];
1515
for(j=0; j<n; j++) {
1518
ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1519
if(y==0 && mb_y==0){
1520
if(x==0 && mb_x==0){
1521
pred= 128 << point_transform;
1526
if(x==0 && mb_x==0){
1527
pred= ptr[-linesize];
1529
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1533
if (s->interlaced && s->bottom_field)
1534
ptr += linesize >> 1;
1535
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1544
for(i=0;i<nb_components;i++) {
1546
int n, h, v, x, y, c, j, linesize;
1547
n = s->nb_blocks[i];
1548
c = s->comp_index[i];
1553
linesize= s->linesize[c];
1555
for(j=0; j<n; j++) {
1558
ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1559
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1560
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1568
if (s->restart_interval && !--s->restart_count) {
1569
align_get_bits(&s->gb);
1570
skip_bits(&s->gb, 16); /* skip RSTn */
1577
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1581
if(Ah) return 0; /* TODO decode refinement planes too */
1582
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1583
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1584
if (s->restart_interval && !s->restart_count)
1585
s->restart_count = s->restart_interval;
1587
for(i=0;i<nb_components;i++) {
1589
int n, h, v, x, y, c, j;
1590
n = s->nb_blocks[i];
1591
c = s->comp_index[i];
1597
memset(s->block, 0, sizeof(s->block));
1598
if (!s->progressive && decode_block(s, s->block, i,
1599
s->dc_index[i], s->ac_index[i],
1600
s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1601
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1604
if (s->progressive && decode_block_progressive(s, s->block, i,
1605
s->dc_index[i], s->ac_index[i],
1606
s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1607
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1610
// av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1611
ptr = s->picture.data[c] +
1612
(((s->linesize[c] * (v * mb_y + y) * 8) +
1613
(h * mb_x + x) * 8) >> s->avctx->lowres);
1614
if (s->interlaced && s->bottom_field)
1615
ptr += s->linesize[c] >> 1;
1616
//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);
1618
s->idct_put(ptr, s->linesize[c], s->block);
1620
s->idct_add(ptr, s->linesize[c], s->block);
1627
/* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1628
if (s->restart_interval && (s->restart_interval < 1350) &&
1629
!--s->restart_count) {
1630
align_get_bits(&s->gb);
1631
skip_bits(&s->gb, 16); /* skip RSTn */
1632
for (i=0; i<nb_components; i++) /* reset dc */
1633
s->last_dc[i] = 1024;
1640
static int mjpeg_decode_sos(MJpegDecodeContext *s)
1642
int len, nb_components, i, h, v, predictor, point_transform;
1643
int vmax, hmax, index, id;
1644
const int block_size= s->lossless ? 1 : 8;
1645
int ilv, prev_shift;
1647
/* XXX: verify len field validity */
1648
len = get_bits(&s->gb, 16);
1649
nb_components = get_bits(&s->gb, 8);
1650
if (len != 6+2*nb_components)
1652
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1657
for(i=0;i<nb_components;i++) {
1658
id = get_bits(&s->gb, 8) - 1;
1659
av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1660
/* find component index */
1661
for(index=0;index<s->nb_components;index++)
1662
if (id == s->component_id[index])
1664
if (index == s->nb_components)
1666
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1670
s->comp_index[i] = index;
1672
s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1673
s->h_scount[i] = s->h_count[index];
1674
s->v_scount[i] = s->v_count[index];
1676
s->dc_index[i] = get_bits(&s->gb, 4);
1677
s->ac_index[i] = get_bits(&s->gb, 4);
1679
if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1680
s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1683
switch(s->start_code)
1686
if (dc_index[i] > 1 || ac_index[i] > 1)
1691
if (dc_index[i] > 3 || ac_index[i] > 3)
1695
if (dc_index[i] > 3 || ac_index[i] != 0)
1702
predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1703
ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1704
prev_shift = get_bits(&s->gb, 4); /* Ah */
1705
point_transform= get_bits(&s->gb, 4); /* Al */
1707
for(i=0;i<nb_components;i++)
1708
s->last_dc[i] = 1024;
1710
if (nb_components > 1) {
1711
/* interleaved stream */
1712
s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1713
s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1714
} else if(!s->ls) { /* skip this for JPEG-LS */
1715
h = s->h_max / s->h_scount[0];
1716
v = s->v_max / s->v_scount[0];
1717
s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1718
s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1719
s->nb_blocks[0] = 1;
1724
if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1725
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" : "",
1726
predictor, point_transform, ilv, s->bits,
1727
s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1730
/* mjpeg-b can have padding bytes between sos and image data, skip them */
1731
for (i = s->mjpb_skiptosod; i > 0; i--)
1732
skip_bits(&s->gb, 8);
1737
// reset_ls_coding_parameters(s, 0);
1739
ls_decode_picture(s, predictor, point_transform, ilv);
1742
if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1745
if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1750
if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1756
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1760
static int mjpeg_decode_dri(MJpegDecodeContext *s)
1762
if (get_bits(&s->gb, 16) != 4)
1764
s->restart_interval = get_bits(&s->gb, 16);
1765
s->restart_count = 0;
1766
av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1771
static int mjpeg_decode_app(MJpegDecodeContext *s)
1775
len = get_bits(&s->gb, 16);
1778
if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1781
id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1785
if(s->avctx->debug & FF_DEBUG_STARTCODE){
1786
av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1789
/* buggy AVID, it puts EOI only at every 10th frame */
1790
/* also this fourcc is used by non-avid files too, it holds some
1791
informations, but it's always present in AVID creates files */
1792
if (id == ff_get_fourcc("AVI1"))
1799
4bytes field_size_less_padding
1802
// if (s->first_picture)
1803
// printf("mjpeg: workarounding buggy AVID\n");
1804
s->interlace_polarity = get_bits(&s->gb, 8);
1806
skip_bits(&s->gb, 8);
1807
skip_bits(&s->gb, 32);
1808
skip_bits(&s->gb, 32);
1811
// if (s->interlace_polarity)
1812
// printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1818
if (id == ff_get_fourcc("JFIF"))
1820
int t_w, t_h, v1, v2;
1821
skip_bits(&s->gb, 8); /* the trailing zero-byte */
1822
v1= get_bits(&s->gb, 8);
1823
v2= get_bits(&s->gb, 8);
1824
skip_bits(&s->gb, 8);
1826
s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1827
s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1829
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1830
av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1832
s->avctx->sample_aspect_ratio.num,
1833
s->avctx->sample_aspect_ratio.den
1836
t_w = get_bits(&s->gb, 8);
1837
t_h = get_bits(&s->gb, 8);
1840
/* skip thumbnail */
1841
if (len-10-(t_w*t_h*3) > 0)
1848
if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1850
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1851
av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1852
skip_bits(&s->gb, 16); /* version */
1853
skip_bits(&s->gb, 16); /* flags0 */
1854
skip_bits(&s->gb, 16); /* flags1 */
1855
skip_bits(&s->gb, 8); /* transform */
1860
if (id == ff_get_fourcc("LJIF")){
1861
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1862
av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1863
skip_bits(&s->gb, 16); /* version ? */
1864
skip_bits(&s->gb, 16); /* unknwon always 0? */
1865
skip_bits(&s->gb, 16); /* unknwon always 0? */
1866
skip_bits(&s->gb, 16); /* unknwon always 0? */
1867
switch( get_bits(&s->gb, 8)){
1877
av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1884
if ((s->start_code == APP1) && (len > (0x28 - 8)))
1886
id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1889
if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1892
skip_bits(&s->gb, 32); /* field size */
1893
skip_bits(&s->gb, 32); /* pad field size */
1894
skip_bits(&s->gb, 32); /* next off */
1895
skip_bits(&s->gb, 32); /* quant off */
1896
skip_bits(&s->gb, 32); /* huff off */
1897
skip_bits(&s->gb, 32); /* image off */
1898
skip_bits(&s->gb, 32); /* scan off */
1899
skip_bits(&s->gb, 32); /* data off */
1901
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1902
av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1907
/* slow but needed for extreme adobe jpegs */
1909
av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1911
skip_bits(&s->gb, 8);
1916
static int mjpeg_decode_com(MJpegDecodeContext *s)
1918
int len = get_bits(&s->gb, 16);
1919
if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1920
char *cbuf = av_malloc(len - 1);
1923
for (i = 0; i < len - 2; i++)
1924
cbuf[i] = get_bits(&s->gb, 8);
1925
if (i > 0 && cbuf[i-1] == '\n')
1930
if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1931
av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1933
/* buggy avid, it puts EOI only at every 10th frame */
1934
if (!strcmp(cbuf, "AVID"))
1937
// if (s->first_picture)
1938
// printf("mjpeg: workarounding buggy AVID\n");
1940
else if(!strcmp(cbuf, "CS=ITU601")){
1952
static int valid_marker_list[] =
1954
/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1955
/* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1956
/* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1957
/* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1958
/* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1959
/* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1960
/* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1961
/* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1962
/* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1963
/* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1964
/* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1965
/* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1966
/* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1967
/* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1968
/* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1969
/* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1970
/* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1974
/* return the 8 bit start code value and update the search
1975
state. Return -1 if no start code found */
1976
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1985
buf_ptr = *pbuf_ptr;
1986
while (buf_ptr < buf_end) {
1989
if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2000
av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
2002
*pbuf_ptr = buf_ptr;
2006
static int mjpeg_decode_frame(AVCodecContext *avctx,
2007
void *data, int *data_size,
2008
uint8_t *buf, int buf_size)
2010
MJpegDecodeContext *s = avctx->priv_data;
2011
uint8_t *buf_end, *buf_ptr;
2013
AVFrame *picture = data;
2016
buf_end = buf + buf_size;
2017
while (buf_ptr < buf_end) {
2018
/* find start next marker */
2019
start_code = find_marker(&buf_ptr, buf_end);
2022
if (start_code < 0) {
2025
av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
2027
if ((buf_end - buf_ptr) > s->buffer_size)
2030
s->buffer_size = buf_end-buf_ptr;
2031
s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
2032
av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
2036
/* unescape buffer of SOS, use special treatment for JPEG-LS */
2037
if (start_code == SOS && !s->ls)
2039
uint8_t *src = buf_ptr;
2040
uint8_t *dst = s->buffer;
2044
uint8_t x = *(src++);
2049
while(src<buf_end && x == 0xff)
2052
if (x >= 0xd0 && x <= 0xd7)
2058
init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
2060
av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
2061
(buf_end - buf_ptr) - (dst - s->buffer));
2063
else if(start_code == SOS && s->ls){
2064
uint8_t *src = buf_ptr;
2065
uint8_t *dst = s->buffer;
2073
while (src + t < buf_end){
2074
uint8_t x = src[t++];
2076
while((src + t < buf_end) && x == 0xff)
2086
init_put_bits(&pb, dst, t);
2088
/* unescape bitstream */
2090
uint8_t x = src[b++];
2091
put_bits(&pb, 8, x);
2094
put_bits(&pb, 7, x);
2098
flush_put_bits(&pb);
2100
init_get_bits(&s->gb, dst, bit_count);
2103
init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2105
s->start_code = start_code;
2106
if(s->avctx->debug & FF_DEBUG_STARTCODE){
2107
av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2110
/* process markers */
2111
if (start_code >= 0xd0 && start_code <= 0xd7) {
2112
av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
2114
} else if (start_code >= APP0 && start_code <= APP15) {
2115
mjpeg_decode_app(s);
2117
} else if (start_code == COM){
2118
mjpeg_decode_com(s);
2121
switch(start_code) {
2123
s->restart_interval = 0;
2125
s->restart_count = 0;
2126
/* nothing to do on SOI */
2129
mjpeg_decode_dqt(s);
2132
if(mjpeg_decode_dht(s) < 0){
2133
av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2141
if (mjpeg_decode_sof(s) < 0)
2148
if (mjpeg_decode_sof(s) < 0)
2155
if (mjpeg_decode_sof(s) < 0)
2162
if (mjpeg_decode_sof(s) < 0)
2166
if (decode_lse(s) < 0)
2171
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2175
if (s->interlaced) {
2176
s->bottom_field ^= 1;
2177
/* if not bottom field, do not output image yet */
2178
if (s->bottom_field == !s->interlace_polarity)
2181
*picture = s->picture;
2182
*data_size = sizeof(AVFrame);
2185
picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2186
picture->qstride= 0;
2187
picture->qscale_table= s->qscale_table;
2188
memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2189
if(avctx->debug & FF_DEBUG_QP)
2190
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2191
picture->quality*= FF_QP2LAMBDA;
2198
mjpeg_decode_sos(s);
2199
/* buggy avid puts EOI every 10-20th frame */
2200
/* if restart period is over process EOI */
2201
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2205
mjpeg_decode_dri(s);
2218
av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2221
// printf("mjpeg: unsupported marker (%x)\n", start_code);
2226
/* eof process start code */
2227
buf_ptr += (get_bits_count(&s->gb)+7)/8;
2228
av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
2229
(get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2234
av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2235
// return buf_end - buf_ptr;
2236
return buf_ptr - buf;
2239
static int mjpegb_decode_frame(AVCodecContext *avctx,
2240
void *data, int *data_size,
2241
uint8_t *buf, int buf_size)
2243
MJpegDecodeContext *s = avctx->priv_data;
2244
uint8_t *buf_end, *buf_ptr;
2245
AVFrame *picture = data;
2246
GetBitContext hgb; /* for the header */
2247
uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2248
uint32_t field_size, sod_offs;
2251
buf_end = buf + buf_size;
2254
/* reset on every SOI */
2255
s->restart_interval = 0;
2256
s->restart_count = 0;
2257
s->mjpb_skiptosod = 0;
2259
init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2261
skip_bits(&hgb, 32); /* reserved zeros */
2263
if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2265
av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2269
field_size = get_bits_long(&hgb, 32); /* field size */
2270
av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2271
skip_bits(&hgb, 32); /* padded field size */
2272
second_field_offs = get_bits_long(&hgb, 32);
2273
av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2274
if (second_field_offs)
2277
dqt_offs = get_bits_long(&hgb, 32);
2278
av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
2281
init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2282
s->start_code = DQT;
2283
mjpeg_decode_dqt(s);
2286
dht_offs = get_bits_long(&hgb, 32);
2287
av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
2290
init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2291
s->start_code = DHT;
2292
mjpeg_decode_dht(s);
2295
sof_offs = get_bits_long(&hgb, 32);
2296
av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
2299
init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2300
s->start_code = SOF0;
2301
if (mjpeg_decode_sof(s) < 0)
2305
sos_offs = get_bits_long(&hgb, 32);
2306
av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
2307
sod_offs = get_bits_long(&hgb, 32);
2308
av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
2311
// init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2312
init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2313
s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2314
s->start_code = SOS;
2315
mjpeg_decode_sos(s);
2318
if (s->interlaced) {
2319
s->bottom_field ^= 1;
2320
/* if not bottom field, do not output image yet */
2321
if (s->bottom_field && second_field_offs)
2323
buf_ptr = buf + second_field_offs;
2324
second_field_offs = 0;
2329
//XXX FIXME factorize, this looks very similar to the EOI code
2331
*picture= s->picture;
2332
*data_size = sizeof(AVFrame);
2335
picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2336
picture->qstride= 0;
2337
picture->qscale_table= s->qscale_table;
2338
memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2339
if(avctx->debug & FF_DEBUG_QP)
2340
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2341
picture->quality*= FF_QP2LAMBDA;
2344
return buf_ptr - buf;
2349
static int sp5x_decode_frame(AVCodecContext *avctx,
2350
void *data, int *data_size,
2351
uint8_t *buf, int buf_size)
2354
MJpegDecodeContext *s = avctx->priv_data;
2356
const int qscale = 5;
2357
uint8_t *buf_ptr, *buf_end, *recoded;
2360
if (!avctx->width || !avctx->height)
2364
buf_end = buf + buf_size;
2367
recoded = av_mallocz(buf_size + 1024);
2372
recoded[j++] = 0xFF;
2373
recoded[j++] = 0xD8;
2375
memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2376
memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2377
memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2378
j += sizeof(sp5x_data_dqt);
2380
memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2381
j += sizeof(sp5x_data_dht);
2383
memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2384
recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2385
recoded[j+6] = avctx->coded_height & 0xFF;
2386
recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2387
recoded[j+8] = avctx->coded_width & 0xFF;
2388
j += sizeof(sp5x_data_sof);
2390
memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2391
j += sizeof(sp5x_data_sos);
2393
for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2395
recoded[j++] = buf[i];
2401
recoded[j++] = 0xFF;
2402
recoded[j++] = 0xD9;
2404
i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2411
s->width = avctx->coded_width;
2412
s->height = avctx->coded_height;
2413
s->nb_components = 3;
2414
s->component_id[0] = 0;
2417
s->quant_index[0] = 0;
2418
s->component_id[1] = 1;
2421
s->quant_index[1] = 1;
2422
s->component_id[2] = 2;
2425
s->quant_index[2] = 1;
2429
s->qscale_table = av_mallocz((s->width+15)/16);
2430
avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2433
s->picture.reference = 0;
2434
if (avctx->get_buffer(avctx, &s->picture) < 0)
2436
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2440
s->picture.pict_type = I_TYPE;
2441
s->picture.key_frame = 1;
2443
for (i = 0; i < 3; i++)
2444
s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2447
for (i = 0; i < 64; i++)
2449
j = s->scantable.permutated[i];
2450
s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2452
s->qscale[0] = FFMAX(
2453
s->quant_matrixes[0][s->scantable.permutated[1]],
2454
s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2456
for (i = 0; i < 64; i++)
2458
j = s->scantable.permutated[i];
2459
s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2461
s->qscale[1] = FFMAX(
2462
s->quant_matrixes[1][s->scantable.permutated[1]],
2463
s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2468
s->comp_index[0] = 0;
2469
s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2470
s->h_scount[0] = s->h_count[0];
2471
s->v_scount[0] = s->v_count[0];
2475
s->comp_index[1] = 1;
2476
s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2477
s->h_scount[1] = s->h_count[1];
2478
s->v_scount[1] = s->v_count[1];
2482
s->comp_index[2] = 2;
2483
s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2484
s->h_scount[2] = s->h_count[2];
2485
s->v_scount[2] = s->v_count[2];
2489
for (i = 0; i < 3; i++)
2490
s->last_dc[i] = 1024;
2492
s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2493
s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2495
init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2497
return mjpeg_decode_scan(s);
2503
static int mjpeg_decode_end(AVCodecContext *avctx)
2505
MJpegDecodeContext *s = avctx->priv_data;
2509
av_free(s->qscale_table);
2513
free_vlc(&s->vlcs[i][j]);
2518
static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2519
uint8_t **poutbuf, int *poutbuf_size,
2520
const uint8_t *buf, int buf_size, int keyframe)
2525
if (avctx->codec_id != CODEC_ID_MJPEG) {
2526
av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2531
*poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
2532
poutbufp = *poutbuf;
2533
bytestream_put_byte(&poutbufp, 0xff);
2534
bytestream_put_byte(&poutbufp, SOI);
2535
bytestream_put_byte(&poutbufp, 0xff);
2536
bytestream_put_byte(&poutbufp, APP1);
2537
bytestream_put_be16(&poutbufp, 42); /* size */
2538
bytestream_put_be32(&poutbufp, 0);
2539
bytestream_put_buffer(&poutbufp, "mjpg", 4);
2540
bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
2541
bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
2542
bytestream_put_be32(&poutbufp, 0); /* next ptr */
2544
for (i = 0; i < buf_size - 1; i++) {
2545
if (buf[i] == 0xff) {
2546
switch (buf[i + 1]) {
2547
case DQT: /* quant off */
2548
case DHT: /* huff off */
2549
case SOF0: /* image off */
2550
bytestream_put_be32(&poutbufp, i + 46);
2553
bytestream_put_be32(&poutbufp, i + 46); /* scan off */
2554
bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */
2555
bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
2556
*poutbuf_size = poutbufp - *poutbuf;
2559
if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {
2560
av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
2561
memcpy(*poutbuf, buf, buf_size);
2562
*poutbuf_size = buf_size;
2569
av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
2573
AVCodec mjpeg_decoder = {
2577
sizeof(MJpegDecodeContext),
2586
AVCodec mjpegb_decoder = {
2590
sizeof(MJpegDecodeContext),
2594
mjpegb_decode_frame,
2599
AVCodec sp5x_decoder = {
2603
sizeof(MJpegDecodeContext),
2612
#ifdef CONFIG_ENCODERS
2613
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2617
sizeof(MpegEncContext),
2619
encode_picture_lossless,
2624
AVCodecParser mjpeg_parser = {
2626
sizeof(ParseContext),
2632
AVBitStreamFilter mjpega_dump_header_bsf = {
added
removed
ffmpeg/libavcodec/mjpeg.c
