30 
30 
* MJPEG encoder and decoder.

31 
31 
*/

32 
32 

33 

//#define DEBUG

34 

#include <assert.h>

35 


36 

#include "avcodec.h"

37 

#include "dsputil.h"

38 

#include "mpegvideo.h"

39 

#include "bytestream.h"

40 
33 
#include "mjpeg.h"

41 

#include "jpeglsdec.h"

42 


43 

/* use two quantizer tables (one for luminance and one for chrominance) */

44 

/* not yet working */

45 

#undef TWOMATRIXES

46 
34 

47 

typedef struct MJpegContext {

48 

uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing

49 

uint16_t huff_code_dc_luminance[12];

50 

uint8_t huff_size_dc_chrominance[12];

51 

uint16_t huff_code_dc_chrominance[12];

52 


53 

uint8_t huff_size_ac_luminance[256];

54 

uint16_t huff_code_ac_luminance[256];

55 

uint8_t huff_size_ac_chrominance[256];

56 

uint16_t huff_code_ac_chrominance[256];

57 

} MJpegContext;

58 
35 

59 
36 
#if 0

60 
37 
/* These are the sample quantization tables given in JPEG spec section K.1.

61 
38 
* The spec says that the values given produce "good" quality, and

62 
39 
* when divided by 2, "very good" quality.

63 
40 
*/

64 

static const unsigned char std_luminance_quant_tbl[64] = {


41 
const unsigned char std_luminance_quant_tbl[64] = {

65 
42 
16, 11, 10, 16, 24, 40, 51, 61,

66 
43 
12, 12, 14, 19, 26, 58, 60, 55,

67 
44 
14, 13, 16, 24, 40, 57, 69, 56,

...  ...  
71 
48 
49, 64, 78, 87, 103, 121, 120, 101,

72 
49 
72, 92, 95, 98, 112, 100, 103, 99

73 
50 
};

74 

static const unsigned char std_chrominance_quant_tbl[64] = {


51 
const unsigned char std_chrominance_quant_tbl[64] = {

75 
52 
17, 18, 24, 47, 99, 99, 99, 99,

76 
53 
18, 21, 26, 66, 99, 99, 99, 99,

77 
54 
24, 26, 56, 99, 99, 99, 99, 99,

...  ...  
85 
62 

86 
63 
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */

87 
64 
/* IMPORTANT: these are only valid for 8bit data precision! */

88 

static const uint8_t bits_dc_luminance[17] =


65 
const uint8_t bits_dc_luminance[17] =

89 
66 
{ /* 0base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };

90 

static const uint8_t val_dc_luminance[] =


67 
const uint8_t val_dc_luminance[] =

91 
68 
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

92 
69 

93 

static const uint8_t bits_dc_chrominance[17] =


70 
const uint8_t bits_dc_chrominance[17] =

94 
71 
{ /* 0base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };

95 

static const uint8_t val_dc_chrominance[] =


72 
const uint8_t val_dc_chrominance[] =

96 
73 
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

97 
74 

98 

static const uint8_t bits_ac_luminance[17] =


75 
const uint8_t bits_ac_luminance[17] =

99 
76 
{ /* 0base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };

100 

static const uint8_t val_ac_luminance[] =


77 
const uint8_t val_ac_luminance[] =

101 
78 
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,

102 
79 
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

103 
80 
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,

...  ...  
121 
98 
0xf9, 0xfa

122 
99 
};

123 
100 

124 

static const uint8_t bits_ac_chrominance[17] =


101 
const uint8_t bits_ac_chrominance[17] =

125 
102 
{ /* 0base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };

126 
103 

127 

static const uint8_t val_ac_chrominance[] =


104 
const uint8_t val_ac_chrominance[] =

128 
105 
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,

129 
106 
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,

130 
107 
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,

...  ...  
149 
126 
};

150 
127 

151 
128 
/* isn't this function nicer than the one in the libjpeg ? */

152 

static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,


129 
void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,

153 
130 
const uint8_t *bits_table, const uint8_t *val_table)

154 
131 
{

155 
132 
int i, j, k,nb, code, sym;

...  ...  
167 
144 
code <<= 1;

168 
145 
}

169 
146 
}

170 


171 

#ifdef CONFIG_ENCODERS

172 

int mjpeg_init(MpegEncContext *s)

173 

{

174 

MJpegContext *m;

175 


176 

m = av_malloc(sizeof(MJpegContext));

177 

if (!m)

178 

return 1;

179 


180 

s>min_qcoeff=1023;

181 

s>max_qcoeff= 1023;

182 


183 

/* build all the huffman tables */

184 

build_huffman_codes(m>huff_size_dc_luminance,

185 

m>huff_code_dc_luminance,

186 

bits_dc_luminance,

187 

val_dc_luminance);

188 

build_huffman_codes(m>huff_size_dc_chrominance,

189 

m>huff_code_dc_chrominance,

190 

bits_dc_chrominance,

191 

val_dc_chrominance);

192 

build_huffman_codes(m>huff_size_ac_luminance,

193 

m>huff_code_ac_luminance,

194 

bits_ac_luminance,

195 

val_ac_luminance);

196 

build_huffman_codes(m>huff_size_ac_chrominance,

197 

m>huff_code_ac_chrominance,

198 

bits_ac_chrominance,

199 

val_ac_chrominance);

200 


201 

s>mjpeg_ctx = m;

202 

return 0;

203 

}

204 


205 

void mjpeg_close(MpegEncContext *s)

206 

{

207 

av_free(s>mjpeg_ctx);

208 

}

209 

#endif //CONFIG_ENCODERS

210 


211 

#define PREDICT(ret, topleft, top, left, predictor)\

212 

switch(predictor){\

213 

case 1: ret= left; break;\

214 

case 2: ret= top; break;\

215 

case 3: ret= topleft; break;\

216 

case 4: ret= left + top  topleft; break;\

217 

case 5: ret= left + ((top  topleft)>>1); break;\

218 

case 6: ret= top + ((left  topleft)>>1); break;\

219 

default:\

220 

case 7: ret= (left + top)>>1; break;\

221 

}

222 


223 

#ifdef CONFIG_ENCODERS

224 

/* table_class: 0 = DC coef, 1 = AC coefs */

225 

static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,

226 

const uint8_t *bits_table, const uint8_t *value_table)

227 

{

228 

PutBitContext *p = &s>pb;

229 

int n, i;

230 


231 

put_bits(p, 4, table_class);

232 

put_bits(p, 4, table_id);

233 


234 

n = 0;

235 

for(i=1;i<=16;i++) {

236 

n += bits_table[i];

237 

put_bits(p, 8, bits_table[i]);

238 

}

239 


240 

for(i=0;i<n;i++)

241 

put_bits(p, 8, value_table[i]);

242 


243 

return n + 17;

244 

}

245 


246 

static void jpeg_table_header(MpegEncContext *s)

247 

{

248 

PutBitContext *p = &s>pb;

249 

int i, j, size;

250 

uint8_t *ptr;

251 


252 

/* quant matrixes */

253 

put_marker(p, DQT);

254 

#ifdef TWOMATRIXES

255 

put_bits(p, 16, 2 + 2 * (1 + 64));

256 

#else

257 

put_bits(p, 16, 2 + 1 * (1 + 64));

258 

#endif

259 

put_bits(p, 4, 0); /* 8 bit precision */

260 

put_bits(p, 4, 0); /* table 0 */

261 

for(i=0;i<64;i++) {

262 

j = s>intra_scantable.permutated[i];

263 

put_bits(p, 8, s>intra_matrix[j]);

264 

}

265 

#ifdef TWOMATRIXES

266 

put_bits(p, 4, 0); /* 8 bit precision */

267 

put_bits(p, 4, 1); /* table 1 */

268 

for(i=0;i<64;i++) {

269 

j = s>intra_scantable.permutated[i];

270 

put_bits(p, 8, s>chroma_intra_matrix[j]);

271 

}

272 

#endif

273 


274 

/* huffman table */

275 

put_marker(p, DHT);

276 

flush_put_bits(p);

277 

ptr = pbBufPtr(p);

278 

put_bits(p, 16, 0); /* patched later */

279 

size = 2;

280 

size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);

281 

size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);

282 


283 

size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);

284 

size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);

285 

ptr[0] = size >> 8;

286 

ptr[1] = size;

287 

}

288 


289 

static void jpeg_put_comments(MpegEncContext *s)

290 

{

291 

PutBitContext *p = &s>pb;

292 

int size;

293 

uint8_t *ptr;

294 


295 

if (s>aspect_ratio_info /* && !lossless */)

296 

{

297 

/* JFIF header */

298 

put_marker(p, APP0);

299 

put_bits(p, 16, 16);

300 

ff_put_string(p, "JFIF", 1); /* this puts the trailing zerobyte too */

301 

put_bits(p, 16, 0x0201); /* v 1.02 */

302 

put_bits(p, 8, 0); /* units type: 0  aspect ratio */

303 

put_bits(p, 16, s>avctx>sample_aspect_ratio.num);

304 

put_bits(p, 16, s>avctx>sample_aspect_ratio.den);

305 

put_bits(p, 8, 0); /* thumbnail width */

306 

put_bits(p, 8, 0); /* thumbnail height */

307 

}

308 


309 

/* comment */

310 

if(!(s>flags & CODEC_FLAG_BITEXACT)){

311 

put_marker(p, COM);

312 

flush_put_bits(p);

313 

ptr = pbBufPtr(p);

314 

put_bits(p, 16, 0); /* patched later */

315 

ff_put_string(p, LIBAVCODEC_IDENT, 1);

316 

size = strlen(LIBAVCODEC_IDENT)+3;

317 

ptr[0] = size >> 8;

318 

ptr[1] = size;

319 

}

320 


321 

if( s>avctx>pix_fmt == PIX_FMT_YUV420P

322 

s>avctx>pix_fmt == PIX_FMT_YUV422P

323 

s>avctx>pix_fmt == PIX_FMT_YUV444P){

324 

put_marker(p, COM);

325 

flush_put_bits(p);

326 

ptr = pbBufPtr(p);

327 

put_bits(p, 16, 0); /* patched later */

328 

ff_put_string(p, "CS=ITU601", 1);

329 

size = strlen("CS=ITU601")+3;

330 

ptr[0] = size >> 8;

331 

ptr[1] = size;

332 

}

333 

}

334 


335 

void mjpeg_picture_header(MpegEncContext *s)

336 

{

337 

const int lossless= s>avctx>codec_id != CODEC_ID_MJPEG;

338 


339 

put_marker(&s>pb, SOI);

340 


341 

jpeg_put_comments(s);

342 


343 

jpeg_table_header(s);

344 


345 

switch(s>avctx>codec_id){

346 

case CODEC_ID_MJPEG: put_marker(&s>pb, SOF0 ); break;

347 

case CODEC_ID_LJPEG: put_marker(&s>pb, SOF3 ); break;

348 

default: assert(0);

349 

}

350 


351 

put_bits(&s>pb, 16, 17);

352 

if(lossless && s>avctx>pix_fmt == PIX_FMT_RGB32)

353 

put_bits(&s>pb, 8, 9); /* 9 bits/component RCT */

354 

else

355 

put_bits(&s>pb, 8, 8); /* 8 bits/component */

356 

put_bits(&s>pb, 16, s>height);

357 

put_bits(&s>pb, 16, s>width);

358 

put_bits(&s>pb, 8, 3); /* 3 components */

359 


360 

/* Y component */

361 

put_bits(&s>pb, 8, 1); /* component number */

362 

put_bits(&s>pb, 4, s>mjpeg_hsample[0]); /* H factor */

363 

put_bits(&s>pb, 4, s>mjpeg_vsample[0]); /* V factor */

364 

put_bits(&s>pb, 8, 0); /* select matrix */

365 


366 

/* Cb component */

367 

put_bits(&s>pb, 8, 2); /* component number */

368 

put_bits(&s>pb, 4, s>mjpeg_hsample[1]); /* H factor */

369 

put_bits(&s>pb, 4, s>mjpeg_vsample[1]); /* V factor */

370 

#ifdef TWOMATRIXES

371 

put_bits(&s>pb, 8, lossless ? 0 : 1); /* select matrix */

372 

#else

373 

put_bits(&s>pb, 8, 0); /* select matrix */

374 

#endif

375 


376 

/* Cr component */

377 

put_bits(&s>pb, 8, 3); /* component number */

378 

put_bits(&s>pb, 4, s>mjpeg_hsample[2]); /* H factor */

379 

put_bits(&s>pb, 4, s>mjpeg_vsample[2]); /* V factor */

380 

#ifdef TWOMATRIXES

381 

put_bits(&s>pb, 8, lossless ? 0 : 1); /* select matrix */

382 

#else

383 

put_bits(&s>pb, 8, 0); /* select matrix */

384 

#endif

385 


386 

/* scan header */

387 

put_marker(&s>pb, SOS);

388 

put_bits(&s>pb, 16, 12); /* length */

389 

put_bits(&s>pb, 8, 3); /* 3 components */

390 


391 

/* Y component */

392 

put_bits(&s>pb, 8, 1); /* index */

393 

put_bits(&s>pb, 4, 0); /* DC huffman table index */

394 

put_bits(&s>pb, 4, 0); /* AC huffman table index */

395 


396 

/* Cb component */

397 

put_bits(&s>pb, 8, 2); /* index */

398 

put_bits(&s>pb, 4, 1); /* DC huffman table index */

399 

put_bits(&s>pb, 4, lossless ? 0 : 1); /* AC huffman table index */

400 


401 

/* Cr component */

402 

put_bits(&s>pb, 8, 3); /* index */

403 

put_bits(&s>pb, 4, 1); /* DC huffman table index */

404 

put_bits(&s>pb, 4, lossless ? 0 : 1); /* AC huffman table index */

405 


406 

put_bits(&s>pb, 8, lossless ? s>avctx>prediction_method+1 : 0); /* Ss (not used) */

407 


408 

switch(s>avctx>codec_id){

409 

case CODEC_ID_MJPEG: put_bits(&s>pb, 8, 63); break; /* Se (not used) */

410 

case CODEC_ID_LJPEG: put_bits(&s>pb, 8, 0); break; /* not used */

411 

default: assert(0);

412 

}

413 


414 

put_bits(&s>pb, 8, 0); /* Ah/Al (not used) */

415 

}

416 


417 

static void escape_FF(MpegEncContext *s, int start)

418 

{

419 

int size= put_bits_count(&s>pb)  start*8;

420 

int i, ff_count;

421 

uint8_t *buf= s>pb.buf + start;

422 

int align= ((size_t)(buf))&3;

423 


424 

assert((size&7) == 0);

425 

size >>= 3;

426 


427 

ff_count=0;

428 

for(i=0; i<size && i<align; i++){

429 

if(buf[i]==0xFF) ff_count++;

430 

}

431 

for(; i<size15; i+=16){

432 

int acc, v;

433 


434 

v= *(uint32_t*)(&buf[i]);

435 

acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

436 

v= *(uint32_t*)(&buf[i+4]);

437 

acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

438 

v= *(uint32_t*)(&buf[i+8]);

439 

acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

440 

v= *(uint32_t*)(&buf[i+12]);

441 

acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;

442 


443 

acc>>=4;

444 

acc+= (acc>>16);

445 

acc+= (acc>>8);

446 

ff_count+= acc&0xFF;

447 

}

448 

for(; i<size; i++){

449 

if(buf[i]==0xFF) ff_count++;

450 

}

451 


452 

if(ff_count==0) return;

453 


454 

/* skip put bits */

455 

for(i=0; i<ff_count3; i+=4)

456 

put_bits(&s>pb, 32, 0);

457 

put_bits(&s>pb, (ff_counti)*8, 0);

458 

flush_put_bits(&s>pb);

459 


460 

for(i=size1; ff_count; i){

461 

int v= buf[i];

462 


463 

if(v==0xFF){

464 

//printf("%d %d\n", i, ff_count);

465 

buf[i+ff_count]= 0;

466 

ff_count;

467 

}

468 


469 

buf[i+ff_count]= v;

470 

}

471 

}

472 


473 

void ff_mjpeg_stuffing(PutBitContext * pbc)

474 

{

475 

int length;

476 

length= (put_bits_count(pbc))&7;

477 

if(length) put_bits(pbc, length, (1<<length)1);

478 

}

479 


480 

void mjpeg_picture_trailer(MpegEncContext *s)

481 

{

482 

ff_mjpeg_stuffing(&s>pb);

483 

flush_put_bits(&s>pb);

484 


485 

assert((s>header_bits&7)==0);

486 


487 

escape_FF(s, s>header_bits>>3);

488 


489 

put_marker(&s>pb, EOI);

490 

}

491 


492 

static inline void mjpeg_encode_dc(MpegEncContext *s, int val,

493 

uint8_t *huff_size, uint16_t *huff_code)

494 

{

495 

int mant, nbits;

496 


497 

if (val == 0) {

498 

put_bits(&s>pb, huff_size[0], huff_code[0]);

499 

} else {

500 

mant = val;

501 

if (val < 0) {

502 

val = val;

503 

mant;

504 

}

505 


506 

nbits= av_log2_16bit(val) + 1;

507 


508 

put_bits(&s>pb, huff_size[nbits], huff_code[nbits]);

509 


510 

put_bits(&s>pb, nbits, mant & ((1 << nbits)  1));

511 

}

512 

}

513 


514 

static void encode_block(MpegEncContext *s, DCTELEM *block, int n)

515 

{

516 

int mant, nbits, code, i, j;

517 

int component, dc, run, last_index, val;

518 

MJpegContext *m = s>mjpeg_ctx;

519 

uint8_t *huff_size_ac;

520 

uint16_t *huff_code_ac;

521 


522 

/* DC coef */

523 

component = (n <= 3 ? 0 : (n&1) + 1);

524 

dc = block[0]; /* overflow is impossible */

525 

val = dc  s>last_dc[component];

526 

if (n < 4) {

527 

mjpeg_encode_dc(s, val, m>huff_size_dc_luminance, m>huff_code_dc_luminance);

528 

huff_size_ac = m>huff_size_ac_luminance;

529 

huff_code_ac = m>huff_code_ac_luminance;

530 

} else {

531 

mjpeg_encode_dc(s, val, m>huff_size_dc_chrominance, m>huff_code_dc_chrominance);

532 

huff_size_ac = m>huff_size_ac_chrominance;

533 

huff_code_ac = m>huff_code_ac_chrominance;

534 

}

535 

s>last_dc[component] = dc;

536 


537 

/* AC coefs */

538 


539 

run = 0;

540 

last_index = s>block_last_index[n];

541 

for(i=1;i<=last_index;i++) {

542 

j = s>intra_scantable.permutated[i];

543 

val = block[j];

544 

if (val == 0) {

545 

run++;

546 

} else {

547 

while (run >= 16) {

548 

put_bits(&s>pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);

549 

run = 16;

550 

}

551 

mant = val;

552 

if (val < 0) {

553 

val = val;

554 

mant;

555 

}

556 


557 

nbits= av_log2(val) + 1;

558 

code = (run << 4)  nbits;

559 


560 

put_bits(&s>pb, huff_size_ac[code], huff_code_ac[code]);

561 


562 

put_bits(&s>pb, nbits, mant & ((1 << nbits)  1));

563 

run = 0;

564 

}

565 

}

566 


567 

/* output EOB only if not already 64 values */

568 

if (last_index < 63  run != 0)

569 

put_bits(&s>pb, huff_size_ac[0], huff_code_ac[0]);

570 

}

571 


572 

void mjpeg_encode_mb(MpegEncContext *s,

573 

DCTELEM block[6][64])

574 

{

575 

int i;

576 

for(i=0;i<5;i++) {

577 

encode_block(s, block[i], i);

578 

}

579 

if (s>chroma_format == CHROMA_420) {

580 

encode_block(s, block[5], 5);

581 

} else {

582 

encode_block(s, block[6], 6);

583 

encode_block(s, block[5], 5);

584 

encode_block(s, block[7], 7);

585 

}

586 

}

587 


588 

static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

589 

MpegEncContext * const s = avctx>priv_data;

590 

MJpegContext * const m = s>mjpeg_ctx;

591 

AVFrame *pict = data;

592 

const int width= s>width;

593 

const int height= s>height;

594 

AVFrame * const p= (AVFrame*)&s>current_picture;

595 

const int predictor= avctx>prediction_method+1;

596 


597 

init_put_bits(&s>pb, buf, buf_size);

598 


599 

*p = *pict;

600 

p>pict_type= FF_I_TYPE;

601 

p>key_frame= 1;

602 


603 

mjpeg_picture_header(s);

604 


605 

s>header_bits= put_bits_count(&s>pb);

606 


607 

if(avctx>pix_fmt == PIX_FMT_RGB32){

608 

int x, y, i;

609 

const int linesize= p>linesize[0];

610 

uint16_t (*buffer)[4]= (void *) s>rd_scratchpad;

611 

int left[3], top[3], topleft[3];

612 


613 

for(i=0; i<3; i++){

614 

buffer[0][i]= 1 << (9  1);

615 

}

616 


617 

for(y = 0; y < height; y++) {

618 

const int modified_predictor= y ? predictor : 1;

619 

uint8_t *ptr = p>data[0] + (linesize * y);

620 


621 

if(s>pb.buf_end  s>pb.buf  (put_bits_count(&s>pb)>>3) < width*3*4){

622 

av_log(s>avctx, AV_LOG_ERROR, "encoded frame too large\n");

623 

return 1;

624 

}

625 


626 

for(i=0; i<3; i++){

627 

top[i]= left[i]= topleft[i]= buffer[0][i];

628 

}

629 

for(x = 0; x < width; x++) {

630 

buffer[x][1] = ptr[4*x+0]  ptr[4*x+1] + 0x100;

631 

buffer[x][2] = ptr[4*x+2]  ptr[4*x+1] + 0x100;

632 

buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;

633 


634 

for(i=0;i<3;i++) {

635 

int pred, diff;

636 


637 

PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);

638 


639 

topleft[i]= top[i];

640 

top[i]= buffer[x+1][i];

641 


642 

left[i]= buffer[x][i];

643 


644 

diff= ((left[i]  pred + 0x100)&0x1FF)  0x100;

645 


646 

if(i==0)

647 

mjpeg_encode_dc(s, diff, m>huff_size_dc_luminance, m>huff_code_dc_luminance); //FIXME ugly

648 

else

649 

mjpeg_encode_dc(s, diff, m>huff_size_dc_chrominance, m>huff_code_dc_chrominance);

650 

}

651 

}

652 

}

653 

}else{

654 

int mb_x, mb_y, i;

655 

const int mb_width = (width + s>mjpeg_hsample[0]  1) / s>mjpeg_hsample[0];

656 

const int mb_height = (height + s>mjpeg_vsample[0]  1) / s>mjpeg_vsample[0];

657 


658 

for(mb_y = 0; mb_y < mb_height; mb_y++) {

659 

if(s>pb.buf_end  s>pb.buf  (put_bits_count(&s>pb)>>3) < mb_width * 4 * 3 * s>mjpeg_hsample[0] * s>mjpeg_vsample[0]){

660 

av_log(s>avctx, AV_LOG_ERROR, "encoded frame too large\n");

661 

return 1;

662 

}

663 

for(mb_x = 0; mb_x < mb_width; mb_x++) {

664 

if(mb_x==0  mb_y==0){

665 

for(i=0;i<3;i++) {

666 

uint8_t *ptr;

667 

int x, y, h, v, linesize;

668 

h = s>mjpeg_hsample[i];

669 

v = s>mjpeg_vsample[i];

670 

linesize= p>linesize[i];

671 


672 

for(y=0; y<v; y++){

673 

for(x=0; x<h; x++){

674 

int pred;

675 


676 

ptr = p>data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

677 

if(y==0 && mb_y==0){

678 

if(x==0 && mb_x==0){

679 

pred= 128;

680 

}else{

681 

pred= ptr[1];

682 

}

683 

}else{

684 

if(x==0 && mb_x==0){

685 

pred= ptr[linesize];

686 

}else{

687 

PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor);

688 

}

689 

}

690 


691 

if(i==0)

692 

mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_luminance, m>huff_code_dc_luminance); //FIXME ugly

693 

else

694 

mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_chrominance, m>huff_code_dc_chrominance);

695 

}

696 

}

697 

}

698 

}else{

699 

for(i=0;i<3;i++) {

700 

uint8_t *ptr;

701 

int x, y, h, v, linesize;

702 

h = s>mjpeg_hsample[i];

703 

v = s>mjpeg_vsample[i];

704 

linesize= p>linesize[i];

705 


706 

for(y=0; y<v; y++){

707 

for(x=0; x<h; x++){

708 

int pred;

709 


710 

ptr = p>data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

711 

//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);

712 

PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor);

713 


714 

if(i==0)

715 

mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_luminance, m>huff_code_dc_luminance); //FIXME ugly

716 

else

717 

mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_chrominance, m>huff_code_dc_chrominance);

718 

}

719 

}

720 

}

721 

}

722 

}

723 

}

724 

}

725 


726 

emms_c();

727 


728 

mjpeg_picture_trailer(s);

729 

s>picture_number++;

730 


731 

flush_put_bits(&s>pb);

732 

return pbBufPtr(&s>pb)  s>pb.buf;

733 

// return (put_bits_count(&f>pb)+7)/8;

734 

}

735 


736 

#endif //CONFIG_ENCODERS

737 


738 

/******************************************/

739 

/* decoding */

740 


741 

static int mjpeg_decode_dht(MJpegDecodeContext *s);

742 


743 

static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,

744 

int nb_codes, int use_static, int is_ac)

745 

{

746 

uint8_t huff_size[256+16];

747 

uint16_t huff_code[256+16];

748 


749 

assert(nb_codes <= 256);

750 


751 

memset(huff_size, 0, sizeof(huff_size));

752 

build_huffman_codes(huff_size, huff_code, bits_table, val_table);

753 


754 

if(is_ac){

755 

memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);

756 

memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);

757 

memset(huff_size, 0, sizeof(uint8_t)*16);

758 

memset(huff_code, 0, sizeof(uint16_t)*16);

759 

nb_codes += 16;

760 

}

761 


762 

return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);

763 

}

764 


765 

static int mjpeg_decode_init(AVCodecContext *avctx)

766 

{

767 

MJpegDecodeContext *s = avctx>priv_data;

768 


769 

s>avctx = avctx;

770 

dsputil_init(&s>dsp, avctx);

771 

ff_init_scantable(s>dsp.idct_permutation, &s>scantable, ff_zigzag_direct);

772 

s>buffer_size = 0;

773 

s>buffer = NULL;

774 

s>start_code = 1;

775 

s>first_picture = 1;

776 

s>org_height = avctx>coded_height;

777 


778 

build_vlc(&s>vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);

779 

build_vlc(&s>vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);

780 

build_vlc(&s>vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);

781 

build_vlc(&s>vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);

782 


783 

if (avctx>flags & CODEC_FLAG_EXTERN_HUFF)

784 

{

785 

av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");

786 

init_get_bits(&s>gb, avctx>extradata, avctx>extradata_size*8);

787 

mjpeg_decode_dht(s);

788 

/* should check for error  but dunno */

789 

}

790 

if (avctx>extradata_size > 9 &&

791 

AV_RL32(avctx>extradata + 4) == MKTAG('f','i','e','l')) {

792 

if (avctx>extradata[9] == 6) { /* quicktime icefloe 019 */

793 

s>interlace_polarity = 1; /* bottom field first */

794 

av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");

795 

}

796 

}

797 


798 

return 0;

799 

}

800 


801 


802 

/* quantize tables */

803 

static int mjpeg_decode_dqt(MJpegDecodeContext *s)

804 

{

805 

int len, index, i, j;

806 


807 

len = get_bits(&s>gb, 16)  2;

808 


809 

while (len >= 65) {

810 

/* only 8 bit precision handled */

811 

if (get_bits(&s>gb, 4) != 0)

812 

{

813 

av_log(s>avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");

814 

return 1;

815 

}

816 

index = get_bits(&s>gb, 4);

817 

if (index >= 4)

818 

return 1;

819 

av_log(s>avctx, AV_LOG_DEBUG, "index=%d\n", index);

820 

/* read quant table */

821 

for(i=0;i<64;i++) {

822 

j = s>scantable.permutated[i];

823 

s>quant_matrixes[index][j] = get_bits(&s>gb, 8);

824 

}

825 


826 

//XXX FIXME finetune, and perhaps add dc too

827 

s>qscale[index]= FFMAX(

828 

s>quant_matrixes[index][s>scantable.permutated[1]],

829 

s>quant_matrixes[index][s>scantable.permutated[8]]) >> 1;

830 

av_log(s>avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s>qscale[index]);

831 

len = 65;

832 

}

833 


834 

return 0;

835 

}

836 


837 

/* decode huffman tables and build VLC decoders */

838 

static int mjpeg_decode_dht(MJpegDecodeContext *s)

839 

{

840 

int len, index, i, class, n, v, code_max;

841 

uint8_t bits_table[17];

842 

uint8_t val_table[256];

843 


844 

len = get_bits(&s>gb, 16)  2;

845 


846 

while (len > 0) {

847 

if (len < 17)

848 

return 1;

849 

class = get_bits(&s>gb, 4);

850 

if (class >= 2)

851 

return 1;

852 

index = get_bits(&s>gb, 4);

853 

if (index >= 4)

854 

return 1;

855 

n = 0;

856 

for(i=1;i<=16;i++) {

857 

bits_table[i] = get_bits(&s>gb, 8);

858 

n += bits_table[i];

859 

}

860 

len = 17;

861 

if (len < n  n > 256)

862 

return 1;

863 


864 

code_max = 0;

865 

for(i=0;i<n;i++) {

866 

v = get_bits(&s>gb, 8);

867 

if (v > code_max)

868 

code_max = v;

869 

val_table[i] = v;

870 

}

871 

len = n;

872 


873 

/* build VLC and flush previous vlc if present */

874 

free_vlc(&s>vlcs[class][index]);

875 

av_log(s>avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",

876 

class, index, code_max + 1);

877 

if(build_vlc(&s>vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){

878 

return 1;

879 

}

880 

}

881 

return 0;

882 

}

883 


884 

static int mjpeg_decode_sof(MJpegDecodeContext *s)

885 

{

886 

int len, nb_components, i, width, height, pix_fmt_id;

887 


888 

/* XXX: verify len field validity */

889 

len = get_bits(&s>gb, 16);

890 

s>bits= get_bits(&s>gb, 8);

891 


892 

if(s>pegasus_rct) s>bits=9;

893 

if(s>bits==9 && !s>pegasus_rct) s>rct=1; //FIXME ugly

894 


895 

if (s>bits != 8 && !s>lossless){

896 

av_log(s>avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");

897 

return 1;

898 

}

899 


900 

height = get_bits(&s>gb, 16);

901 

width = get_bits(&s>gb, 16);

902 


903 

//HACK for odd_height.mov

904 

if(s>interlaced && s>width == width && s>height == height + 1)

905 

height= s>height;

906 


907 

av_log(s>avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);

908 

if(avcodec_check_dimensions(s>avctx, width, height))

909 

return 1;

910 


911 

nb_components = get_bits(&s>gb, 8);

912 

if (nb_components <= 0 

913 

nb_components > MAX_COMPONENTS)

914 

return 1;

915 

if (s>ls && !(s>bits <= 8  nb_components == 1)){

916 

av_log(s>avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16bit gray accepted for JPEGLS\n");

917 

return 1;

918 

}

919 

s>nb_components = nb_components;

920 

s>h_max = 1;

921 

s>v_max = 1;

922 

for(i=0;i<nb_components;i++) {

923 

/* component id */

924 

s>component_id[i] = get_bits(&s>gb, 8)  1;

925 

s>h_count[i] = get_bits(&s>gb, 4);

926 

s>v_count[i] = get_bits(&s>gb, 4);

927 

/* compute hmax and vmax (only used in interleaved case) */

928 

if (s>h_count[i] > s>h_max)

929 

s>h_max = s>h_count[i];

930 

if (s>v_count[i] > s>v_max)

931 

s>v_max = s>v_count[i];

932 

s>quant_index[i] = get_bits(&s>gb, 8);

933 

if (s>quant_index[i] >= 4)

934 

return 1;

935 

av_log(s>avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s>h_count[i],

936 

s>v_count[i], s>component_id[i], s>quant_index[i]);

937 

}

938 


939 

if(s>ls && (s>h_max > 1  s>v_max > 1)) {

940 

av_log(s>avctx, AV_LOG_ERROR, "Subsampling in JPEGLS is not supported.\n");

941 

return 1;

942 

}

943 


944 

if(s>v_max==1 && s>h_max==1 && s>lossless==1) s>rgb=1;

945 


946 

/* if different size, realloc/alloc picture */

947 

/* XXX: also check h_count and v_count */

948 

if (width != s>width  height != s>height) {

949 

av_freep(&s>qscale_table);

950 


951 

s>width = width;

952 

s>height = height;

953 

s>interlaced = 0;

954 


955 

/* test interlaced mode */

956 

if (s>first_picture &&

957 

s>org_height != 0 &&

958 

s>height < ((s>org_height * 3) / 4)) {

959 

s>interlaced = 1;

960 

s>bottom_field = s>interlace_polarity;

961 

s>picture.interlaced_frame = 1;

962 

s>picture.top_field_first = !s>interlace_polarity;

963 

height *= 2;

964 

}

965 


966 

avcodec_set_dimensions(s>avctx, width, height);

967 


968 

s>qscale_table= av_mallocz((s>width+15)/16);

969 


970 

s>first_picture = 0;

971 

}

972 


973 

if(s>interlaced && (s>bottom_field == !s>interlace_polarity))

974 

return 0;

975 


976 

/* XXX: not complete test ! */

977 

pix_fmt_id = (s>h_count[0] << 20)  (s>v_count[0] << 16) 

978 

(s>h_count[1] << 12)  (s>v_count[1] << 8) 

979 

(s>h_count[2] << 4)  s>v_count[2];

980 

av_log(s>avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);

981 

switch(pix_fmt_id){

982 

case 0x222222:

983 

case 0x111111:

984 

if(s>rgb){

985 

s>avctx>pix_fmt = PIX_FMT_RGB32;

986 

}else if(s>nb_components==3)

987 

s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;

988 

else

989 

s>avctx>pix_fmt = PIX_FMT_GRAY8;

990 

break;

991 

case 0x211111:

992 

case 0x221212:

993 

s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;

994 

break;

995 

default:

996 

case 0x221111:

997 

s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;

998 

break;

999 

}

1000 

if(s>ls){

1001 

if(s>nb_components > 1)

1002 

s>avctx>pix_fmt = PIX_FMT_RGB24;

1003 

else if(s>bits <= 8)

1004 

s>avctx>pix_fmt = PIX_FMT_GRAY8;

1005 

else

1006 

s>avctx>pix_fmt = PIX_FMT_GRAY16;

1007 

}

1008 


1009 

if(s>picture.data[0])

1010 

s>avctx>release_buffer(s>avctx, &s>picture);

1011 


1012 

s>picture.reference= 0;

1013 

if(s>avctx>get_buffer(s>avctx, &s>picture) < 0){

1014 

av_log(s>avctx, AV_LOG_ERROR, "get_buffer() failed\n");

1015 

return 1;

1016 

}

1017 

s>picture.pict_type= I_TYPE;

1018 

s>picture.key_frame= 1;

1019 


1020 

for(i=0; i<3; i++){

1021 

s>linesize[i]= s>picture.linesize[i] << s>interlaced;

1022 

}

1023 


1024 

// printf("%d %d %d %d %d %d\n", s>width, s>height, s>linesize[0], s>linesize[1], s>interlaced, s>avctx>height);

1025 


1026 

if (len != (8+(3*nb_components)))

1027 

{

1028 

av_log(s>avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);

1029 

}

1030 


1031 

/* totally blank picture as progressive JPEG will only add details to it */

1032 

if(s>progressive){

1033 

memset(s>picture.data[0], 0, s>picture.linesize[0] * s>height);

1034 

memset(s>picture.data[1], 0, s>picture.linesize[1] * s>height >> (s>v_max  s>v_count[1]));

1035 

memset(s>picture.data[2], 0, s>picture.linesize[2] * s>height >> (s>v_max  s>v_count[2]));

1036 

}

1037 

return 0;

1038 

}

1039 


1040 

static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)

1041 

{

1042 

int code;

1043 

code = get_vlc2(&s>gb, s>vlcs[0][dc_index].table, 9, 2);

1044 

if (code < 0)

1045 

{

1046 

av_log(s>avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,

1047 

&s>vlcs[0][dc_index]);

1048 

return 0xffff;

1049 

}

1050 


1051 

if(code)

1052 

return get_xbits(&s>gb, code);

1053 

else

1054 

return 0;

1055 

}

1056 


1057 

/* decode block and dequantize */

1058 

static int decode_block(MJpegDecodeContext *s, DCTELEM *block,

1059 

int component, int dc_index, int ac_index, int16_t *quant_matrix)

1060 

{

1061 

int code, i, j, level, val;

1062 


1063 

/* DC coef */

1064 

val = mjpeg_decode_dc(s, dc_index);

1065 

if (val == 0xffff) {

1066 

av_log(s>avctx, AV_LOG_ERROR, "error dc\n");

1067 

return 1;

1068 

}

1069 

val = val * quant_matrix[0] + s>last_dc[component];

1070 

s>last_dc[component] = val;

1071 

block[0] = val;

1072 

/* AC coefs */

1073 

i = 0;

1074 

{OPEN_READER(re, &s>gb)

1075 

for(;;) {

1076 

UPDATE_CACHE(re, &s>gb);

1077 

GET_VLC(code, re, &s>gb, s>vlcs[1][ac_index].table, 9, 2)

1078 


1079 

/* EOB */

1080 

if (code == 0x10)

1081 

break;

1082 

i += ((unsigned)code) >> 4;

1083 

if(code != 0x100){

1084 

code &= 0xf;

1085 

if(code > MIN_CACHE_BITS  16){

1086 

UPDATE_CACHE(re, &s>gb)

1087 

}

1088 

{

1089 

int cache=GET_CACHE(re,&s>gb);

1090 

int sign=(~cache)>>31;

1091 

level = (NEG_USR32(sign ^ cache,code) ^ sign)  sign;

1092 

}

1093 


1094 

LAST_SKIP_BITS(re, &s>gb, code)

1095 


1096 

if (i >= 63) {

1097 

if(i == 63){

1098 

j = s>scantable.permutated[63];

1099 

block[j] = level * quant_matrix[j];

1100 

break;

1101 

}

1102 

av_log(s>avctx, AV_LOG_ERROR, "error count: %d\n", i);

1103 

return 1;

1104 

}

1105 

j = s>scantable.permutated[i];

1106 

block[j] = level * quant_matrix[j];

1107 

}

1108 

}

1109 

CLOSE_READER(re, &s>gb)}

1110 


1111 

return 0;

1112 

}

1113 


1114 

/* decode block and dequantize  progressive JPEG version */

1115 

static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,

1116 

int component, int dc_index, int ac_index, int16_t *quant_matrix,

1117 

int ss, int se, int Ah, int Al, int *EOBRUN)

1118 

{

1119 

int code, i, j, level, val, run;

1120 


1121 

/* DC coef */

1122 

if(!ss){

1123 

val = mjpeg_decode_dc(s, dc_index);

1124 

if (val == 0xffff) {

1125 

av_log(s>avctx, AV_LOG_ERROR, "error dc\n");

1126 

return 1;

1127 

}

1128 

val = (val * quant_matrix[0] << Al) + s>last_dc[component];

1129 

}else

1130 

val = 0;

1131 

s>last_dc[component] = val;

1132 

block[0] = val;

1133 

if(!se) return 0;

1134 

/* AC coefs */

1135 

if(*EOBRUN){

1136 

(*EOBRUN);

1137 

return 0;

1138 

}

1139 

{OPEN_READER(re, &s>gb)

1140 

for(i=ss;;i++) {

1141 

UPDATE_CACHE(re, &s>gb);

1142 

GET_VLC(code, re, &s>gb, s>vlcs[1][ac_index].table, 9, 2)

1143 

/* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */

1144 

code = 16;

1145 

if(code & 0xF) {

1146 

i += ((unsigned) code) >> 4;

1147 

code &= 0xf;

1148 

if(code > MIN_CACHE_BITS  16){

1149 

UPDATE_CACHE(re, &s>gb)

1150 

}

1151 

{

1152 

int cache=GET_CACHE(re,&s>gb);

1153 

int sign=(~cache)>>31;

1154 

level = (NEG_USR32(sign ^ cache,code) ^ sign)  sign;

1155 

}

1156 


1157 

LAST_SKIP_BITS(re, &s>gb, code)

1158 


1159 

if (i >= se) {

1160 

if(i == se){

1161 

j = s>scantable.permutated[se];

1162 

block[j] = level * quant_matrix[j] << Al;

1163 

break;

1164 

}

1165 

av_log(s>avctx, AV_LOG_ERROR, "error count: %d\n", i);

1166 

return 1;

1167 

}

1168 

j = s>scantable.permutated[i];

1169 

block[j] = level * quant_matrix[j] << Al;

1170 

}else{

1171 

run = ((unsigned) code) >> 4;

1172 

if(run == 0xF){// ZRL  skip 15 coefficients

1173 

i += 15;

1174 

}else{

1175 

val = run;

1176 

run = (1 << run);

1177 

UPDATE_CACHE(re, &s>gb);

1178 

run += (GET_CACHE(re, &s>gb) >> (32  val)) & (run  1);

1179 

if(val)

1180 

LAST_SKIP_BITS(re, &s>gb, val);

1181 

*EOBRUN = run  1;

1182 

break;

1183 

}

1184 

}

1185 

}

1186 

CLOSE_READER(re, &s>gb)}

1187 


1188 

return 0;

1189 

}

1190 


1191 

static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){

1192 

int i, mb_x, mb_y;

1193 

uint16_t buffer[32768][4];

1194 

int left[3], top[3], topleft[3];

1195 

const int linesize= s>linesize[0];

1196 

const int mask= (1<<s>bits)1;

1197 


1198 

if((unsigned)s>mb_width > 32768) //dynamic alloc

1199 

return 1;

1200 


1201 

for(i=0; i<3; i++){

1202 

buffer[0][i]= 1 << (s>bits + point_transform  1);

1203 

}

1204 

for(mb_y = 0; mb_y < s>mb_height; mb_y++) {

1205 

const int modified_predictor= mb_y ? predictor : 1;

1206 

uint8_t *ptr = s>picture.data[0] + (linesize * mb_y);

1207 


1208 

if (s>interlaced && s>bottom_field)

1209 

ptr += linesize >> 1;

1210 


1211 

for(i=0; i<3; i++){

1212 

top[i]= left[i]= topleft[i]= buffer[0][i];

1213 

}

1214 

for(mb_x = 0; mb_x < s>mb_width; mb_x++) {

1215 

if (s>restart_interval && !s>restart_count)

1216 

s>restart_count = s>restart_interval;

1217 


1218 

for(i=0;i<3;i++) {

1219 

int pred;

1220 


1221 

topleft[i]= top[i];

1222 

top[i]= buffer[mb_x][i];

1223 


1224 

PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);

1225 


1226 

left[i]=

1227 

buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform));

1228 

}

1229 


1230 

if (s>restart_interval && !s>restart_count) {

1231 

align_get_bits(&s>gb);

1232 

skip_bits(&s>gb, 16); /* skip RSTn */

1233 

}

1234 

}

1235 


1236 

if(s>rct){

1237 

for(mb_x = 0; mb_x < s>mb_width; mb_x++) {

1238 

ptr[4*mb_x+1] = buffer[mb_x][0]  ((buffer[mb_x][1] + buffer[mb_x][2]  0x200)>>2);

1239 

ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];

1240 

ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];

1241 

}

1242 

}else if(s>pegasus_rct){

1243 

for(mb_x = 0; mb_x < s>mb_width; mb_x++) {

1244 

ptr[4*mb_x+1] = buffer[mb_x][0]  ((buffer[mb_x][1] + buffer[mb_x][2])>>2);

1245 

ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];

1246 

ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];

1247 

}

1248 

}else{

1249 

for(mb_x = 0; mb_x < s>mb_width; mb_x++) {

1250 

ptr[4*mb_x+0] = buffer[mb_x][0];

1251 

ptr[4*mb_x+1] = buffer[mb_x][1];

1252 

ptr[4*mb_x+2] = buffer[mb_x][2];

1253 

}

1254 

}

1255 

}

1256 

return 0;

1257 

}

1258 


1259 

static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){

1260 

int i, mb_x, mb_y;

1261 

const int nb_components=3;

1262 


1263 

for(mb_y = 0; mb_y < s>mb_height; mb_y++) {

1264 

for(mb_x = 0; mb_x < s>mb_width; mb_x++) {

1265 

if (s>restart_interval && !s>restart_count)

1266 

s>restart_count = s>restart_interval;

1267 


1268 

if(mb_x==0  mb_y==0  s>interlaced){

1269 

for(i=0;i<nb_components;i++) {

1270 

uint8_t *ptr;

1271 

int n, h, v, x, y, c, j, linesize;

1272 

n = s>nb_blocks[i];

1273 

c = s>comp_index[i];

1274 

h = s>h_scount[i];

1275 

v = s>v_scount[i];

1276 

x = 0;

1277 

y = 0;

1278 

linesize= s>linesize[c];

1279 


1280 

for(j=0; j<n; j++) {

1281 

int pred;

1282 


1283 

ptr = s>picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

1284 

if(y==0 && mb_y==0){

1285 

if(x==0 && mb_x==0){

1286 

pred= 128 << point_transform;

1287 

}else{

1288 

pred= ptr[1];

1289 

}

1290 

}else{

1291 

if(x==0 && mb_x==0){

1292 

pred= ptr[linesize];

1293 

}else{

1294 

PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor);

1295 

}

1296 

}

1297 


1298 

if (s>interlaced && s>bottom_field)

1299 

ptr += linesize >> 1;

1300 

*ptr= pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform);

1301 


1302 

if (++x == h) {

1303 

x = 0;

1304 

y++;

1305 

}

1306 

}

1307 

}

1308 

}else{

1309 

for(i=0;i<nb_components;i++) {

1310 

uint8_t *ptr;

1311 

int n, h, v, x, y, c, j, linesize;

1312 

n = s>nb_blocks[i];

1313 

c = s>comp_index[i];

1314 

h = s>h_scount[i];

1315 

v = s>v_scount[i];

1316 

x = 0;

1317 

y = 0;

1318 

linesize= s>linesize[c];

1319 


1320 

for(j=0; j<n; j++) {

1321 

int pred;

1322 


1323 

ptr = s>picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

1324 

PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor);

1325 

*ptr= pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform);

1326 

if (++x == h) {

1327 

x = 0;

1328 

y++;

1329 

}

1330 

}

1331 

}

1332 

}

1333 

if (s>restart_interval && !s>restart_count) {

1334 

align_get_bits(&s>gb);

1335 

skip_bits(&s>gb, 16); /* skip RSTn */

1336 

}

1337 

}

1338 

}

1339 

return 0;

1340 

}

1341 


1342 

static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){

1343 

int i, mb_x, mb_y;

1344 

int EOBRUN = 0;

1345 


1346 

if(Ah) return 0; /* TODO decode refinement planes too */

1347 

for(mb_y = 0; mb_y < s>mb_height; mb_y++) {

1348 

for(mb_x = 0; mb_x < s>mb_width; mb_x++) {

1349 

if (s>restart_interval && !s>restart_count)

1350 

s>restart_count = s>restart_interval;

1351 


1352 

for(i=0;i<nb_components;i++) {

1353 

uint8_t *ptr;

1354 

int n, h, v, x, y, c, j;

1355 

n = s>nb_blocks[i];

1356 

c = s>comp_index[i];

1357 

h = s>h_scount[i];

1358 

v = s>v_scount[i];

1359 

x = 0;

1360 

y = 0;

1361 

for(j=0;j<n;j++) {

1362 

memset(s>block, 0, sizeof(s>block));

1363 

if (!s>progressive && decode_block(s, s>block, i,

1364 

s>dc_index[i], s>ac_index[i],

1365 

s>quant_matrixes[ s>quant_index[c] ]) < 0) {

1366 

av_log(s>avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);

1367 

return 1;

1368 

}

1369 

if (s>progressive && decode_block_progressive(s, s>block, i,

1370 

s>dc_index[i], s>ac_index[i],

1371 

s>quant_matrixes[ s>quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {

1372 

av_log(s>avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);

1373 

return 1;

1374 

}

1375 

// av_log(s>avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);

1376 

ptr = s>picture.data[c] +

1377 

(((s>linesize[c] * (v * mb_y + y) * 8) +

1378 

(h * mb_x + x) * 8) >> s>avctx>lowres);

1379 

if (s>interlaced && s>bottom_field)

1380 

ptr += s>linesize[c] >> 1;

1381 

//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s>bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);

1382 

if(!s>progressive)

1383 

s>dsp.idct_put(ptr, s>linesize[c], s>block);

1384 

else

1385 

s>dsp.idct_add(ptr, s>linesize[c], s>block);

1386 

if (++x == h) {

1387 

x = 0;

1388 

y++;

1389 

}

1390 

}

1391 

}

1392 

/* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */

1393 

if (s>restart_interval && (s>restart_interval < 1350) &&

1394 

!s>restart_count) {

1395 

align_get_bits(&s>gb);

1396 

skip_bits(&s>gb, 16); /* skip RSTn */

1397 

for (i=0; i<nb_components; i++) /* reset dc */

1398 

s>last_dc[i] = 1024;

1399 

}

1400 

}

1401 

}

1402 

return 0;

1403 

}

1404 


1405 

static int mjpeg_decode_sos(MJpegDecodeContext *s)

1406 

{

1407 

int len, nb_components, i, h, v, predictor, point_transform;

1408 

int vmax, hmax, index, id;

1409 

const int block_size= s>lossless ? 1 : 8;

1410 

int ilv, prev_shift;

1411 


1412 

/* XXX: verify len field validity */

1413 

len = get_bits(&s>gb, 16);

1414 

nb_components = get_bits(&s>gb, 8);

1415 

if (len != 6+2*nb_components)

1416 

{

1417 

av_log(s>avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);

1418 

return 1;

1419 

}

1420 

vmax = 0;

1421 

hmax = 0;

1422 

for(i=0;i<nb_components;i++) {

1423 

id = get_bits(&s>gb, 8)  1;

1424 

av_log(s>avctx, AV_LOG_DEBUG, "component: %d\n", id);

1425 

/* find component index */

1426 

for(index=0;index<s>nb_components;index++)

1427 

if (id == s>component_id[index])

1428 

break;

1429 

if (index == s>nb_components)

1430 

{

1431 

av_log(s>avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);

1432 

return 1;

1433 

}

1434 


1435 

s>comp_index[i] = index;

1436 


1437 

s>nb_blocks[i] = s>h_count[index] * s>v_count[index];

1438 

s>h_scount[i] = s>h_count[index];

1439 

s>v_scount[i] = s>v_count[index];

1440 


1441 

s>dc_index[i] = get_bits(&s>gb, 4);

1442 

s>ac_index[i] = get_bits(&s>gb, 4);

1443 


1444 

if (s>dc_index[i] < 0  s>ac_index[i] < 0 

1445 

s>dc_index[i] >= 4  s>ac_index[i] >= 4)

1446 

goto out_of_range;

1447 

#if 0 //buggy

1448 

switch(s>start_code)

1449 

{

1450 

case SOF0:

1451 

if (dc_index[i] > 1  ac_index[i] > 1)

1452 

goto out_of_range;

1453 

break;

1454 

case SOF1:

1455 

case SOF2:

1456 

if (dc_index[i] > 3  ac_index[i] > 3)

1457 

goto out_of_range;

1458 

break;

1459 

case SOF3:

1460 

if (dc_index[i] > 3  ac_index[i] != 0)

1461 

goto out_of_range;

1462 

break;

1463 

}

1464 

#endif

1465 

}

1466 


1467 

predictor= get_bits(&s>gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEGLS NEAR */

1468 

ilv= get_bits(&s>gb, 8); /* JPEG Se / JPEGLS ILV */

1469 

prev_shift = get_bits(&s>gb, 4); /* Ah */

1470 

point_transform= get_bits(&s>gb, 4); /* Al */

1471 


1472 

for(i=0;i<nb_components;i++)

1473 

s>last_dc[i] = 1024;

1474 


1475 

if (nb_components > 1) {

1476 

/* interleaved stream */

1477 

s>mb_width = (s>width + s>h_max * block_size  1) / (s>h_max * block_size);

1478 

s>mb_height = (s>height + s>v_max * block_size  1) / (s>v_max * block_size);

1479 

} else if(!s>ls) { /* skip this for JPEGLS */

1480 

h = s>h_max / s>h_scount[0];

1481 

v = s>v_max / s>v_scount[0];

1482 

s>mb_width = (s>width + h * block_size  1) / (h * block_size);

1483 

s>mb_height = (s>height + v * block_size  1) / (v * block_size);

1484 

s>nb_blocks[0] = 1;

1485 

s>h_scount[0] = 1;

1486 

s>v_scount[0] = 1;

1487 

}

1488 


1489 

if(s>avctx>debug & FF_DEBUG_PICT_INFO)

1490 

av_log(s>avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s>lossless ? "lossless" : "sequencial DCT", s>rgb ? "RGB" : "",

1491 

predictor, point_transform, ilv, s>bits,

1492 

s>pegasus_rct ? "PRCT" : (s>rct ? "RCT" : ""));

1493 


1494 


1495 

/* mjpegb can have padding bytes between sos and image data, skip them */

1496 

for (i = s>mjpb_skiptosod; i > 0; i)

1497 

skip_bits(&s>gb, 8);

1498 


1499 

if(s>lossless){

1500 

if(s>ls){

1501 

// for(){

1502 

// reset_ls_coding_parameters(s, 0);

1503 


1504 

ff_jpegls_decode_picture(s, predictor, point_transform, ilv);

1505 

}else{

1506 

if(s>rgb){

1507 

if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)

1508 

return 1;

1509 

}else{
