~ubuntu-branches/ubuntu/quantal/tiff/quantal : revision 15

1

/* $Id: tif_jpeg.c,v 1.50.2.9 2010-06-14 02:47:16 fwarmerdam Exp $ */

2

3

/*

4

5

6

*

7

* Permission to use, copy, modify, distribute, and sell this software and

8

* its documentation for any purpose is hereby granted without fee, provided

9

* that (i) the above copyright notices and this permission notice appear in

10

* all copies of the software and related documentation, and (ii) the names of

11

* Sam Leffler and Silicon Graphics may not be used in any advertising or

12

* publicity relating to the software without the specific, prior written

13

* permission of Sam Leffler and Silicon Graphics.

14

*

15

* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

16

* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

17

* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

18

*

19

* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR

20

* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

21

* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

22

* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

23

* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

24

* OF THIS SOFTWARE.

25

*/

26

27

#define WIN32_LEAN_AND_MEAN

28

#define VC_EXTRALEAN

29

30

#include "tiffiop.h"

31

#ifdef JPEG_SUPPORT

32

33

/*

34

* TIFF Library

35

*

36

* JPEG Compression support per TIFF Technical Note #2

37

* (*not* per the original TIFF 6.0 spec).

38

*

39

* This file is simply an interface to the libjpeg library written by

40

* the Independent JPEG Group. You need release 5 or later of the IJG

41

* code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/.

42

*

43

* Contributed by Tom Lane <tgl@sss.pgh.pa.us>.

44

*/

45

#include <setjmp.h>

46

47

int TIFFFillStrip(TIFF*, tstrip_t);

48

int TIFFFillTile(TIFF*, ttile_t);

49

50

/* We undefine FAR to avoid conflict with JPEG definition */

51

52

#ifdef FAR

53

#undef FAR

54

#endif

55

56

/*

57

Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is

58

not defined. Unfortunately, the MinGW and Borland compilers include

59

a typedef for INT32, which causes a conflict. MSVC does not include

60

a conficting typedef given the headers which are included.

61

*/

62

#if defined(__BORLANDC__) || defined(__MINGW32__)

63

# define XMD_H 1

64

#endif

65

66

/*

67

The windows RPCNDR.H file defines boolean, but defines it with the

68

unsigned char size. You should compile JPEG library using appropriate

69

definitions in jconfig.h header, but many users compile library in wrong

70

way. That causes errors of the following type:

71

72

"JPEGLib: JPEG parameter struct mismatch: library thinks size is 432,

73

caller expects 464"

74

75

For such users we wil fix the problem here. See install.doc file from

76

the JPEG library distribution for details.

77

*/

78

79

/* Define "boolean" as unsigned char, not int, per Windows custom. */

80

#if defined(WIN32) && !defined(__MINGW32__)

81

# ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */

82

typedef unsigned char boolean;

83

# endif

84

# define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */

85

#endif

86

87

#include "jpeglib.h"

88

#include "jerror.h"

89

90

/*

91

* We are using width_in_blocks which is supposed to be private to

92

* libjpeg. Unfortunately, the libjpeg delivered with Cygwin has

93

* renamed this member to width_in_data_units. Since the header has

94

* also renamed a define, use that unique define name in order to

95

* detect the problem header and adjust to suit.

96

*/

97

#if defined(D_MAX_DATA_UNITS_IN_MCU)

98

#define width_in_blocks width_in_data_units

99

#endif

100

101

/*

102

* On some machines it may be worthwhile to use _setjmp or sigsetjmp

103

* in place of plain setjmp. These macros will make it easier.

104

*/

105

#define SETJMP(jbuf) setjmp(jbuf)

106

#define LONGJMP(jbuf,code) longjmp(jbuf,code)

107

#define JMP_BUF jmp_buf

108

109

typedef struct jpeg_destination_mgr jpeg_destination_mgr;

110

typedef struct jpeg_source_mgr jpeg_source_mgr;

111

typedef struct jpeg_error_mgr jpeg_error_mgr;

112

113

/*

114

* State block for each open TIFF file using

115

* libjpeg to do JPEG compression/decompression.

116

*

117

* libjpeg's visible state is either a jpeg_compress_struct

118

* or jpeg_decompress_struct depending on which way we

119

* are going. comm can be used to refer to the fields

120

* which are common to both.

121

*

122

* NB: cinfo is required to be the first member of JPEGState,

123

* so we can safely cast JPEGState* -> jpeg_xxx_struct*

124

* and vice versa!

125

*/

126

typedef struct {

127

union {

128

struct jpeg_compress_struct c;

129

struct jpeg_decompress_struct d;

130

struct jpeg_common_struct comm;

131

} cinfo; /* NB: must be first */

132

int cinfo_initialized;

133

134

jpeg_error_mgr err; /* libjpeg error manager */

135

JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */

136

/*

137

* The following two members could be a union, but

138

* they're small enough that it's not worth the effort.

139

*/

140

jpeg_destination_mgr dest; /* data dest for compression */

141

jpeg_source_mgr src; /* data source for decompression */

142

/* private state */

143

TIFF* tif; /* back link needed by some code */

144

uint16 photometric; /* copy of PhotometricInterpretation */

145

uint16 h_sampling; /* luminance sampling factors */

146

uint16 v_sampling;

147

tsize_t bytesperline; /* decompressed bytes per scanline */

148

/* pointers to intermediate buffers when processing downsampled data */

149

JSAMPARRAY ds_buffer[MAX_COMPONENTS];

150

int scancount; /* number of "scanlines" accumulated */

151

int samplesperclump;

152

153

TIFFVGetMethod vgetparent; /* super-class method */

154

TIFFVSetMethod vsetparent; /* super-class method */

155

TIFFPrintMethod printdir; /* super-class method */

156

TIFFStripMethod defsparent; /* super-class method */

157

TIFFTileMethod deftparent; /* super-class method */

158

/* pseudo-tag fields */

159

void* jpegtables; /* JPEGTables tag value, or NULL */

160

uint32 jpegtables_length; /* number of bytes in same */

161

int jpegquality; /* Compression quality level */

162

int jpegcolormode; /* Auto RGB<=>YCbCr convert? */

163

int jpegtablesmode; /* What to put in JPEGTables */

164

165

int ycbcrsampling_fetched;

166

uint32 recvparams; /* encoded Class 2 session params */

167

char* subaddress; /* subaddress string */

168

uint32 recvtime; /* time spent receiving (secs) */

169

char* faxdcs; /* encoded fax parameters (DCS, Table 2/T.30) */

170

} JPEGState;

171

172

#define JState(tif) ((JPEGState*)(tif)->tif_data)

173

174

static int JPEGDecode(TIFF*, tidata_t, tsize_t, tsample_t);

175

static int JPEGDecodeRaw(TIFF*, tidata_t, tsize_t, tsample_t);

176

static int JPEGEncode(TIFF*, tidata_t, tsize_t, tsample_t);

177

static int JPEGEncodeRaw(TIFF*, tidata_t, tsize_t, tsample_t);

178

static int JPEGInitializeLibJPEG( TIFF * tif,

179

int force_encode, int force_decode );

180

181

#define FIELD_JPEGTABLES (FIELD_CODEC+0)

182

#define FIELD_RECVPARAMS (FIELD_CODEC+1)

183

#define FIELD_SUBADDRESS (FIELD_CODEC+2)

184

#define FIELD_RECVTIME (FIELD_CODEC+3)

185

#define FIELD_FAXDCS (FIELD_CODEC+4)

186

187

static const TIFFFieldInfo jpegFieldInfo[] = {

188

{ TIFFTAG_JPEGTABLES, -3,-3, TIFF_UNDEFINED, FIELD_JPEGTABLES,

189

FALSE, TRUE, "JPEGTables" },

190

{ TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO,

191

TRUE, FALSE, "" },

192

{ TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,

193

FALSE, FALSE, "" },

194

{ TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,

195

FALSE, FALSE, "" },

196

/* Specific for JPEG in faxes */

197

{ TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS,

198

TRUE, FALSE, "FaxRecvParams" },

199

{ TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS,

200

TRUE, FALSE, "FaxSubAddress" },

201

{ TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME,

202

TRUE, FALSE, "FaxRecvTime" },

203

{ TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, FIELD_FAXDCS,

204

TRUE, FALSE, "FaxDcs" },

205

};

206

#define N(a) (sizeof (a) / sizeof (a[0]))

207

208

/*

209

* libjpeg interface layer.

210

*

211

* We use setjmp/longjmp to return control to libtiff

212

* when a fatal error is encountered within the JPEG

213

* library. We also direct libjpeg error and warning

214

* messages through the appropriate libtiff handlers.

215

*/

216

217

/*

218

* Error handling routines (these replace corresponding

219

* IJG routines from jerror.c). These are used for both

220

* compression and decompression.

221

*/

222

static void

223

TIFFjpeg_error_exit(j_common_ptr cinfo)

224

{

225

JPEGState *sp = (JPEGState *) cinfo; /* NB: cinfo assumed first */

226

char buffer[JMSG_LENGTH_MAX];

227

228

(*cinfo->err->format_message) (cinfo, buffer);

229

TIFFErrorExt(sp->tif->tif_clientdata, "JPEGLib", "%s", buffer); /* display the error message */

230

jpeg_abort(cinfo); /* clean up libjpeg state */

231

LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */

232

}

233

234

/*

235

* This routine is invoked only for warning messages,

236

* since error_exit does its own thing and trace_level

237

* is never set > 0.

238

*/

239

static void

240

TIFFjpeg_output_message(j_common_ptr cinfo)

241

{

242

char buffer[JMSG_LENGTH_MAX];

243

244

(*cinfo->err->format_message) (cinfo, buffer);

245

TIFFWarningExt(((JPEGState *) cinfo)->tif->tif_clientdata, "JPEGLib", "%s", buffer);

246

}

247

248

/*

249

* Interface routines. This layer of routines exists

250

* primarily to limit side-effects from using setjmp.

251

* Also, normal/error returns are converted into return

252

* values per libtiff practice.

253

*/

254

#define CALLJPEG(sp, fail, op) (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op))

255

#define CALLVJPEG(sp, op) CALLJPEG(sp, 0, ((op),1))

256

257

static int

258

TIFFjpeg_create_compress(JPEGState* sp)

259

{

260

/* initialize JPEG error handling */

261

sp->cinfo.c.err = jpeg_std_error(&sp->err);

262

sp->err.error_exit = TIFFjpeg_error_exit;

263

sp->err.output_message = TIFFjpeg_output_message;

264

265

return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c));

266

}

267

268

static int

269

TIFFjpeg_create_decompress(JPEGState* sp)

270

{

271

/* initialize JPEG error handling */

272

sp->cinfo.d.err = jpeg_std_error(&sp->err);

273

sp->err.error_exit = TIFFjpeg_error_exit;

274

sp->err.output_message = TIFFjpeg_output_message;

275

276

return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d));

277

}

278

279

static int

280

TIFFjpeg_set_defaults(JPEGState* sp)

281

{

282

return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c));

283

}

284

285

static int

286

TIFFjpeg_set_colorspace(JPEGState* sp, J_COLOR_SPACE colorspace)

287

{

288

return CALLVJPEG(sp, jpeg_set_colorspace(&sp->cinfo.c, colorspace));

289

}

290

291

static int

292

TIFFjpeg_set_quality(JPEGState* sp, int quality, boolean force_baseline)

293

{

294

return CALLVJPEG(sp,

295

jpeg_set_quality(&sp->cinfo.c, quality, force_baseline));

296

}

297

298

static int

299

TIFFjpeg_suppress_tables(JPEGState* sp, boolean suppress)

300

{

301

return CALLVJPEG(sp, jpeg_suppress_tables(&sp->cinfo.c, suppress));

302

}

303

304

static int

305

TIFFjpeg_start_compress(JPEGState* sp, boolean write_all_tables)

306

{

307

return CALLVJPEG(sp,

308

jpeg_start_compress(&sp->cinfo.c, write_all_tables));

309

}

310

311

static int

312

TIFFjpeg_write_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int num_lines)

313

{

314

return CALLJPEG(sp, -1, (int) jpeg_write_scanlines(&sp->cinfo.c,

315

scanlines, (JDIMENSION) num_lines));

316

}

317

318

static int

319

TIFFjpeg_write_raw_data(JPEGState* sp, JSAMPIMAGE data, int num_lines)

320

{

321

return CALLJPEG(sp, -1, (int) jpeg_write_raw_data(&sp->cinfo.c,

322

data, (JDIMENSION) num_lines));

323

}

324

325

static int

326

TIFFjpeg_finish_compress(JPEGState* sp)

327

{

328

return CALLVJPEG(sp, jpeg_finish_compress(&sp->cinfo.c));

329

}

330

331

static int

332

TIFFjpeg_write_tables(JPEGState* sp)

333

{

334

return CALLVJPEG(sp, jpeg_write_tables(&sp->cinfo.c));

335

}

336

337

static int

338

TIFFjpeg_read_header(JPEGState* sp, boolean require_image)

339

{

340

return CALLJPEG(sp, -1, jpeg_read_header(&sp->cinfo.d, require_image));

341

}

342

343

static int

344

TIFFjpeg_start_decompress(JPEGState* sp)

345

{

346

return CALLVJPEG(sp, jpeg_start_decompress(&sp->cinfo.d));

347

}

348

349

static int

350

TIFFjpeg_read_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int max_lines)

351

{

352

return CALLJPEG(sp, -1, (int) jpeg_read_scanlines(&sp->cinfo.d,

353

scanlines, (JDIMENSION) max_lines));

354

}

355

356

static int

357

TIFFjpeg_read_raw_data(JPEGState* sp, JSAMPIMAGE data, int max_lines)

358

{

359

return CALLJPEG(sp, -1, (int) jpeg_read_raw_data(&sp->cinfo.d,

360

data, (JDIMENSION) max_lines));

361

}

362

363

static int

364

TIFFjpeg_finish_decompress(JPEGState* sp)

365

{

366

return CALLJPEG(sp, -1, (int) jpeg_finish_decompress(&sp->cinfo.d));

367

}

368

369

static int

370

TIFFjpeg_abort(JPEGState* sp)

371

{

372

return CALLVJPEG(sp, jpeg_abort(&sp->cinfo.comm));

373

}

374

375

static int

376

TIFFjpeg_destroy(JPEGState* sp)

377

{

378

return CALLVJPEG(sp, jpeg_destroy(&sp->cinfo.comm));

379

}

380

381

static JSAMPARRAY

382

TIFFjpeg_alloc_sarray(JPEGState* sp, int pool_id,

383

JDIMENSION samplesperrow, JDIMENSION numrows)

384

{

385

return CALLJPEG(sp, (JSAMPARRAY) NULL,

386

(*sp->cinfo.comm.mem->alloc_sarray)

387

(&sp->cinfo.comm, pool_id, samplesperrow, numrows));

388

}

389

390

/*

391

* JPEG library destination data manager.

392

* These routines direct compressed data from libjpeg into the

393

* libtiff output buffer.

394

*/

395

396

static void

397

std_init_destination(j_compress_ptr cinfo)

398

{

399

JPEGState* sp = (JPEGState*) cinfo;

400

TIFF* tif = sp->tif;

401

402

sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;

403

sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;

404

}

405

406

static boolean

407

std_empty_output_buffer(j_compress_ptr cinfo)

408

{

409

JPEGState* sp = (JPEGState*) cinfo;

410

TIFF* tif = sp->tif;

411

412

/* the entire buffer has been filled */

413

tif->tif_rawcc = tif->tif_rawdatasize;

414

TIFFFlushData1(tif);

415

sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;

416

sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;

417

418

return (TRUE);

419

}

420

421

static void

422

std_term_destination(j_compress_ptr cinfo)

423

{

424

JPEGState* sp = (JPEGState*) cinfo;

425

TIFF* tif = sp->tif;

426

427

tif->tif_rawcp = (tidata_t) sp->dest.next_output_byte;

428

tif->tif_rawcc =

429

tif->tif_rawdatasize - (tsize_t) sp->dest.free_in_buffer;

430

/* NB: libtiff does the final buffer flush */

431

}

432

433

static void

434

TIFFjpeg_data_dest(JPEGState* sp, TIFF* tif)

435

{

436

(void) tif;

437

sp->cinfo.c.dest = &sp->dest;

438

sp->dest.init_destination = std_init_destination;

439

sp->dest.empty_output_buffer = std_empty_output_buffer;

440

sp->dest.term_destination = std_term_destination;

441

}

442

443

/*

444

* Alternate destination manager for outputting to JPEGTables field.

445

*/

446

447

static void

448

tables_init_destination(j_compress_ptr cinfo)

449

{

450

JPEGState* sp = (JPEGState*) cinfo;

451

452

/* while building, jpegtables_length is allocated buffer size */

453

sp->dest.next_output_byte = (JOCTET*) sp->jpegtables;

454

sp->dest.free_in_buffer = (size_t) sp->jpegtables_length;

455

}

456

457

static boolean

458

tables_empty_output_buffer(j_compress_ptr cinfo)

459

{

460

JPEGState* sp = (JPEGState*) cinfo;

461

void* newbuf;

462

463

/* the entire buffer has been filled; enlarge it by 1000 bytes */

464

newbuf = _TIFFrealloc((tdata_t) sp->jpegtables,

465

(tsize_t) (sp->jpegtables_length + 1000));

466

if (newbuf == NULL)

467

ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100);

468

sp->dest.next_output_byte = (JOCTET*) newbuf + sp->jpegtables_length;

469

sp->dest.free_in_buffer = (size_t) 1000;

470

sp->jpegtables = newbuf;

471

sp->jpegtables_length += 1000;

472

return (TRUE);

473

}

474

475

static void

476

tables_term_destination(j_compress_ptr cinfo)

477

{

478

JPEGState* sp = (JPEGState*) cinfo;

479

480

/* set tables length to number of bytes actually emitted */

481

sp->jpegtables_length -= sp->dest.free_in_buffer;

482

}

483

484

static int

485

TIFFjpeg_tables_dest(JPEGState* sp, TIFF* tif)

486

{

487

(void) tif;

488

/*

489

* Allocate a working buffer for building tables.

490

* Initial size is 1000 bytes, which is usually adequate.

491

*/

492

if (sp->jpegtables)

493

_TIFFfree(sp->jpegtables);

494

sp->jpegtables_length = 1000;

495

sp->jpegtables = (void*) _TIFFmalloc((tsize_t) sp->jpegtables_length);

496

if (sp->jpegtables == NULL) {

497

sp->jpegtables_length = 0;

498

TIFFErrorExt(sp->tif->tif_clientdata, "TIFFjpeg_tables_dest", "No space for JPEGTables");

499

return (0);

500

}

501

sp->cinfo.c.dest = &sp->dest;

502

sp->dest.init_destination = tables_init_destination;

503

sp->dest.empty_output_buffer = tables_empty_output_buffer;

504

sp->dest.term_destination = tables_term_destination;

505

return (1);

506

}

507

508

/*

509

* JPEG library source data manager.

510

* These routines supply compressed data to libjpeg.

511

*/

512

513

static void

514

std_init_source(j_decompress_ptr cinfo)

515

{

516

JPEGState* sp = (JPEGState*) cinfo;

517

TIFF* tif = sp->tif;

518

519

sp->src.next_input_byte = (const JOCTET*) tif->tif_rawdata;

520

sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;

521

}

522

523

static boolean

524

std_fill_input_buffer(j_decompress_ptr cinfo)

525

{

526

JPEGState* sp = (JPEGState* ) cinfo;

527

static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI };

528

529

/*

530

* Should never get here since entire strip/tile is

531

* read into memory before the decompressor is called,

532

* and thus was supplied by init_source.

533

*/

534

WARNMS(cinfo, JWRN_JPEG_EOF);

535

/* insert a fake EOI marker */

536

sp->src.next_input_byte = dummy_EOI;

537

sp->src.bytes_in_buffer = 2;

538

return (TRUE);

539

}

540

541

static void

542

std_skip_input_data(j_decompress_ptr cinfo, long num_bytes)

543

{

544

JPEGState* sp = (JPEGState*) cinfo;

545

546

if (num_bytes > 0) {

547

if (num_bytes > (long) sp->src.bytes_in_buffer) {

548

/* oops, buffer overrun */

549

(void) std_fill_input_buffer(cinfo);

550

} else {

551

sp->src.next_input_byte += (size_t) num_bytes;

552

sp->src.bytes_in_buffer -= (size_t) num_bytes;

553

}

554

}

555

}

556

557

static void

558

std_term_source(j_decompress_ptr cinfo)

559

{

560

/* No work necessary here */

561

/* Or must we update tif->tif_rawcp, tif->tif_rawcc ??? */

562

/* (if so, need empty tables_term_source!) */

563

(void) cinfo;

564

}

565

566

static void

567

TIFFjpeg_data_src(JPEGState* sp, TIFF* tif)

568

{

569

(void) tif;

570

sp->cinfo.d.src = &sp->src;

571

sp->src.init_source = std_init_source;

572

sp->src.fill_input_buffer = std_fill_input_buffer;

573

sp->src.skip_input_data = std_skip_input_data;

574

sp->src.resync_to_restart = jpeg_resync_to_restart;

575

sp->src.term_source = std_term_source;

576

sp->src.bytes_in_buffer = 0; /* for safety */

577

sp->src.next_input_byte = NULL;

578

}

579

580

/*

581

* Alternate source manager for reading from JPEGTables.

582

* We can share all the code except for the init routine.

583

*/

584

585

static void

586

tables_init_source(j_decompress_ptr cinfo)

587

{

588

JPEGState* sp = (JPEGState*) cinfo;

589

590

sp->src.next_input_byte = (const JOCTET*) sp->jpegtables;

591

sp->src.bytes_in_buffer = (size_t) sp->jpegtables_length;

592

}

593

594

static void

595

TIFFjpeg_tables_src(JPEGState* sp, TIFF* tif)

596

{

597

TIFFjpeg_data_src(sp, tif);

598

sp->src.init_source = tables_init_source;

599

}

600

601

/*

602

* Allocate downsampled-data buffers needed for downsampled I/O.

603

* We use values computed in jpeg_start_compress or jpeg_start_decompress.

604

* We use libjpeg's allocator so that buffers will be released automatically

605

* when done with strip/tile.

606

* This is also a handy place to compute samplesperclump, bytesperline.

607

*/

608

static int

609

alloc_downsampled_buffers(TIFF* tif, jpeg_component_info* comp_info,

610

int num_components)

611

{

612

JPEGState* sp = JState(tif);

613

int ci;

614

jpeg_component_info* compptr;

615

JSAMPARRAY buf;

616

int samples_per_clump = 0;

617

618

for (ci = 0, compptr = comp_info; ci < num_components;

619

ci++, compptr++) {

620

samples_per_clump += compptr->h_samp_factor *

621

compptr->v_samp_factor;

622

buf = TIFFjpeg_alloc_sarray(sp, JPOOL_IMAGE,

623

compptr->width_in_blocks * DCTSIZE,

624

(JDIMENSION) (compptr->v_samp_factor*DCTSIZE));

625

if (buf == NULL)

626

return (0);

627

sp->ds_buffer[ci] = buf;

628

}

629

sp->samplesperclump = samples_per_clump;

630

return (1);

631

}

632

633

634

/*

635

* JPEG Decoding.

636

*/

637

638

static int

639

JPEGSetupDecode(TIFF* tif)

640

{

641

JPEGState* sp = JState(tif);

642

TIFFDirectory *td = &tif->tif_dir;

643

644

JPEGInitializeLibJPEG( tif, 0, 1 );

645

646

assert(sp != NULL);

647

assert(sp->cinfo.comm.is_decompressor);

648

649

/* Read JPEGTables if it is present */

650

if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) {

651

TIFFjpeg_tables_src(sp, tif);

652

if(TIFFjpeg_read_header(sp,FALSE) != JPEG_HEADER_TABLES_ONLY) {

653

TIFFErrorExt(tif->tif_clientdata, "JPEGSetupDecode", "Bogus JPEGTables field");

654

return (0);

655

}

656

}

657

658

/* Grab parameters that are same for all strips/tiles */

659

sp->photometric = td->td_photometric;

660

switch (sp->photometric) {

661

case PHOTOMETRIC_YCBCR:

662

sp->h_sampling = td->td_ycbcrsubsampling[0];

663

sp->v_sampling = td->td_ycbcrsubsampling[1];

664

break;

665

default:

666

/* TIFF 6.0 forbids subsampling of all other color spaces */

667

sp->h_sampling = 1;

668

sp->v_sampling = 1;

669

break;

670

}

671

672

/* Set up for reading normal data */

673

TIFFjpeg_data_src(sp, tif);

674

tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */

675

return (1);

676

}

677

678

/*

679

* Set up for decoding a strip or tile.

680

*/

681

static int

682

JPEGPreDecode(TIFF* tif, tsample_t s)

683

{

684

JPEGState *sp = JState(tif);

685

TIFFDirectory *td = &tif->tif_dir;

686

static const char module[] = "JPEGPreDecode";

687

uint32 segment_width, segment_height;

688

int downsampled_output;

689

int ci;

690

691

assert(sp != NULL);

692

assert(sp->cinfo.comm.is_decompressor);

693

/*

694

* Reset decoder state from any previous strip/tile,

695

* in case application didn't read the whole strip.

696

*/

697

if (!TIFFjpeg_abort(sp))

698

return (0);

699

/*

700

* Read the header for this strip/tile.

701

*/

702

if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK)

703

return (0);

704

/*

705

* Check image parameters and set decompression parameters.

706

*/

707

segment_width = td->td_imagewidth;

708

segment_height = td->td_imagelength - tif->tif_row;

709

if (isTiled(tif)) {

710

segment_width = td->td_tilewidth;

711

segment_height = td->td_tilelength;

712

sp->bytesperline = TIFFTileRowSize(tif);

713

} else {

714

if (segment_height > td->td_rowsperstrip)

715

segment_height = td->td_rowsperstrip;

716

sp->bytesperline = TIFFOldScanlineSize(tif);

717

}

718

if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {

719

/*

720

* For PC 2, scale down the expected strip/tile size

721

* to match a downsampled component

722

*/

723

segment_width = TIFFhowmany(segment_width, sp->h_sampling);

724

segment_height = TIFFhowmany(segment_height, sp->v_sampling);

725

}

726

if (sp->cinfo.d.image_width < segment_width ||

727

sp->cinfo.d.image_height < segment_height) {

728

TIFFWarningExt(tif->tif_clientdata, module,

729

"Improper JPEG strip/tile size, "

730

"expected %dx%d, got %dx%d",

731

segment_width, segment_height,

732

sp->cinfo.d.image_width,

733

sp->cinfo.d.image_height);

734

}

735

if (sp->cinfo.d.image_width > segment_width ||

736

sp->cinfo.d.image_height > segment_height) {

737

/*

738

* This case could be dangerous, if the strip or tile size has

739

* been reported as less than the amount of data jpeg will

740

* return, some potential security issues arise. Catch this

741

* case and error out.

742

*/

743

TIFFErrorExt(tif->tif_clientdata, module,

744

"JPEG strip/tile size exceeds expected dimensions,"

745

" expected %dx%d, got %dx%d",

746

segment_width, segment_height,

747

sp->cinfo.d.image_width, sp->cinfo.d.image_height);

748

return (0);

749

}

750

if (sp->cinfo.d.num_components !=

751

(td->td_planarconfig == PLANARCONFIG_CONTIG ?

752

td->td_samplesperpixel : 1)) {

753

TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG component count");

754

return (0);

755

}

756

#ifdef JPEG_LIB_MK1

757

if (12 != td->td_bitspersample && 8 != td->td_bitspersample) {

758

TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision");

759

return (0);

760

}

761

sp->cinfo.d.data_precision = td->td_bitspersample;

762

sp->cinfo.d.bits_in_jsample = td->td_bitspersample;

763

#else

764

if (sp->cinfo.d.data_precision != td->td_bitspersample) {

765

TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision");

766

return (0);

767

}

768

#endif

769

if (td->td_planarconfig == PLANARCONFIG_CONTIG) {

770

/* Component 0 should have expected sampling factors */

771

if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling ||

772

sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) {

773

TIFFWarningExt(tif->tif_clientdata, module,

774

"Improper JPEG sampling factors %d,%d\n"

775

"Apparently should be %d,%d.",

776

sp->cinfo.d.comp_info[0].h_samp_factor,

777

sp->cinfo.d.comp_info[0].v_samp_factor,

778

sp->h_sampling, sp->v_sampling);

779

780

/*

781

* There are potential security issues here

782

* for decoders that have already allocated

783

* buffers based on the expected sampling

784

* factors. Lets check the sampling factors

785

* dont exceed what we were expecting.

786

*/

787

if (sp->cinfo.d.comp_info[0].h_samp_factor

788

> sp->h_sampling

789

|| sp->cinfo.d.comp_info[0].v_samp_factor

790

> sp->v_sampling) {

791

TIFFErrorExt(tif->tif_clientdata,

792

module,

793

"Cannot honour JPEG sampling factors"

794

" that exceed those specified.");

795

return (0);

796

}

797

798

/*

799

* XXX: Files written by the Intergraph software

800

* has different sampling factors stored in the

801

* TIFF tags and in the JPEG structures. We will

802

* try to deduce Intergraph files by the presense

803

* of the tag 33918.

804

*/

805

if (!_TIFFFindFieldInfo(tif, 33918, TIFF_ANY)) {

806

TIFFWarningExt(tif->tif_clientdata, module,

807

"Decompressor will try reading with "

808

"sampling %d,%d.",

809

sp->cinfo.d.comp_info[0].h_samp_factor,

810

sp->cinfo.d.comp_info[0].v_samp_factor);

811

812

sp->h_sampling = (uint16)

813

sp->cinfo.d.comp_info[0].h_samp_factor;

814

sp->v_sampling = (uint16)

815

sp->cinfo.d.comp_info[0].v_samp_factor;

816

}

817

}

818

/* Rest should have sampling factors 1,1 */

819

for (ci = 1; ci < sp->cinfo.d.num_components; ci++) {

820

if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 ||

821

sp->cinfo.d.comp_info[ci].v_samp_factor != 1) {

822

TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG sampling factors");

823

return (0);

824

}

825

}

826

} else {

827

/* PC 2's single component should have sampling factors 1,1 */

828

if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 ||

829

sp->cinfo.d.comp_info[0].v_samp_factor != 1) {

830

TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG sampling factors");

831

return (0);

832

}

833

}

834

downsampled_output = FALSE;

835

if (td->td_planarconfig == PLANARCONFIG_CONTIG &&

836

sp->photometric == PHOTOMETRIC_YCBCR &&

837

sp->jpegcolormode == JPEGCOLORMODE_RGB) {

838

/* Convert YCbCr to RGB */

839

sp->cinfo.d.jpeg_color_space = JCS_YCbCr;

840

sp->cinfo.d.out_color_space = JCS_RGB;

841

} else {

842

/* Suppress colorspace handling */

843

sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;

844

sp->cinfo.d.out_color_space = JCS_UNKNOWN;

845

if (td->td_planarconfig == PLANARCONFIG_CONTIG &&

846

(sp->h_sampling != 1 || sp->v_sampling != 1))

847

downsampled_output = TRUE;

848

/* XXX what about up-sampling? */

849

}

850

if (downsampled_output) {

851

/* Need to use raw-data interface to libjpeg */

852

sp->cinfo.d.raw_data_out = TRUE;

853

tif->tif_decoderow = JPEGDecodeRaw;

854

tif->tif_decodestrip = JPEGDecodeRaw;

855

tif->tif_decodetile = JPEGDecodeRaw;

856

} else {

857

/* Use normal interface to libjpeg */

858

sp->cinfo.d.raw_data_out = FALSE;

859

tif->tif_decoderow = JPEGDecode;

860

tif->tif_decodestrip = JPEGDecode;

861

tif->tif_decodetile = JPEGDecode;

862

}

863

/* Start JPEG decompressor */

864

if (!TIFFjpeg_start_decompress(sp))

865

return (0);

866

/* Allocate downsampled-data buffers if needed */

867

if (downsampled_output) {

868

if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info,

869

sp->cinfo.d.num_components))

870

return (0);

871

sp->scancount = DCTSIZE; /* mark buffer empty */

872

}

873

return (1);

874

}

875

876

/*

877

* Decode a chunk of pixels.

878

* "Standard" case: returned data is not downsampled.

879

*/

880

/*ARGSUSED*/ static int

881

JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)

882

{

883

JPEGState *sp = JState(tif);

884

tsize_t nrows;

885

(void) s;

886

887

nrows = cc / sp->bytesperline;

888

if (cc % sp->bytesperline)

889

TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline not read");

890

891

if( nrows > (int) sp->cinfo.d.image_height )

892

nrows = sp->cinfo.d.image_height;

893

894

/* data is expected to be read in multiples of a scanline */

895

if (nrows)

896

{

897

JSAMPROW line_work_buf = NULL;

898

899

/*

900

** For 6B, only use temporary buffer for 12 bit imagery.

901

** For Mk1 always use it.

902

*/

903

#if !defined(JPEG_LIB_MK1)

904

if( sp->cinfo.d.data_precision == 12 )

905

#endif

906

{

907

line_work_buf = (JSAMPROW)

908

_TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width

909

* sp->cinfo.d.num_components );

910

}

911

912

do {

913

if( line_work_buf != NULL )

914

{

915

/*

916

** In the MK1 case, we aways read into a 16bit buffer, and then

917

** pack down to 12bit or 8bit. In 6B case we only read into 16

918

** bit buffer for 12bit data, which we need to repack.

919

*/

920

if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)

921

return (0);

922

923

if( sp->cinfo.d.data_precision == 12 )

924

{

925

int value_pairs = (sp->cinfo.d.output_width

926

* sp->cinfo.d.num_components) / 2;

927

int iPair;

928

929

for( iPair = 0; iPair < value_pairs; iPair++ )

930

{

931

unsigned char *out_ptr =

932

((unsigned char *) buf) + iPair * 3;

933

JSAMPLE *in_ptr = line_work_buf + iPair * 2;

934

935

out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;

936

out_ptr[1] = ((in_ptr[0] & 0xf) << 4)

937

| ((in_ptr[1] & 0xf00) >> 8);

938

out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);

939

}

940

}

941

else if( sp->cinfo.d.data_precision == 8 )

942

{

943

int value_count = (sp->cinfo.d.output_width

944

* sp->cinfo.d.num_components);

945

int iValue;

946

947

for( iValue = 0; iValue < value_count; iValue++ )

948

{

949

((unsigned char *) buf)[iValue] =

950

line_work_buf[iValue] & 0xff;

951

}

952

}

953

}

954

else

955

{

956

/*

957

** In the libjpeg6b 8bit case. We read directly into the

958

** TIFF buffer.

959

*/

960

JSAMPROW bufptr = (JSAMPROW)buf;

961

962

if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)

963

return (0);

964

}

965

966

++tif->tif_row;

967

buf += sp->bytesperline;

968

cc -= sp->bytesperline;

969

} while (--nrows > 0);

970

971

if( line_work_buf != NULL )

972

_TIFFfree( line_work_buf );

973

}

974

975

/* Close down the decompressor if we've finished the strip or tile. */

976

return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height

977

|| TIFFjpeg_finish_decompress(sp);

978

}

979

980

/*

981

* Decode a chunk of pixels.

982

* Returned data is downsampled per sampling factors.

983

*/

984

/*ARGSUSED*/ static int

985

JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)

986

{

987

JPEGState *sp = JState(tif);

988

tsize_t nrows;

989

(void) s;

990

991

/* data is expected to be read in multiples of a scanline */

992

if ( (nrows = sp->cinfo.d.image_height) ) {

993

/* Cb,Cr both have sampling factors 1, so this is correct */

994

JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;

995

int samples_per_clump = sp->samplesperclump;

996

997

#ifdef JPEG_LIB_MK1

998

unsigned short* tmpbuf = _TIFFmalloc(sizeof(unsigned short) *

999

sp->cinfo.d.output_width *

1000

sp->cinfo.d.num_components);

1001

#endif

1002

1003

do {

1004

jpeg_component_info *compptr;

1005

int ci, clumpoffset;

1006

1007

/* Reload downsampled-data buffer if needed */

1008

if (sp->scancount >= DCTSIZE) {

1009

int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;

1010

if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n)

1011

return (0);

1012

sp->scancount = 0;

1013

}

1014

/*

1015

* Fastest way to unseparate data is to make one pass

1016

* over the scanline for each row of each component.

1017

*/

1018

clumpoffset = 0; /* first sample in clump */

1019

for (ci = 0, compptr = sp->cinfo.d.comp_info;

1020

ci < sp->cinfo.d.num_components;

1021

ci++, compptr++) {

1022

int hsamp = compptr->h_samp_factor;

1023

int vsamp = compptr->v_samp_factor;

1024

int ypos;

1025

1026

for (ypos = 0; ypos < vsamp; ypos++) {

1027

JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];

1028

#ifdef JPEG_LIB_MK1

1029

JSAMPLE *outptr = (JSAMPLE*)tmpbuf + clumpoffset;

1030

#else

1031

JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset;

1032

#endif

1033

JDIMENSION nclump;

1034

1035

if (hsamp == 1) {

1036

/* fast path for at least Cb and Cr */

1037

for (nclump = clumps_per_line; nclump-- > 0; ) {

1038

outptr[0] = *inptr++;

1039

outptr += samples_per_clump;

1040

}

1041

} else {

1042

int xpos;

1043

1044

/* general case */

1045

for (nclump = clumps_per_line; nclump-- > 0; ) {

1046

for (xpos = 0; xpos < hsamp; xpos++)

1047

outptr[xpos] = *inptr++;

1048

outptr += samples_per_clump;

1049

}

1050

}

1051

clumpoffset += hsamp;

1052

}

1053

}

1054

1055

#ifdef JPEG_LIB_MK1

1056

{

1057

if (sp->cinfo.d.data_precision == 8)

1058

{

1059

int i=0;

1060

int len = sp->cinfo.d.output_width * sp->cinfo.d.num_components;

1061

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

1062

{

1063

((unsigned char*)buf)[i] = tmpbuf[i] & 0xff;

1064

}

1065

}

1066

else

1067

{ // 12-bit

1068

int value_pairs = (sp->cinfo.d.output_width

1069

* sp->cinfo.d.num_components) / 2;

1070

int iPair;

1071

for( iPair = 0; iPair < value_pairs; iPair++ )

1072

{

1073

unsigned char *out_ptr = ((unsigned char *) buf) + iPair * 3;

1074

JSAMPLE *in_ptr = tmpbuf + iPair * 2;

1075

out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;

1076

out_ptr[1] = ((in_ptr[0] & 0xf) << 4)

1077

| ((in_ptr[1] & 0xf00) >> 8);

1078

out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);

1079

}

1080

}

1081

}

1082

#endif

1083

1084

sp->scancount ++;

1085

tif->tif_row += sp->v_sampling;

1086

/* increment/decrement of buf and cc is still incorrect, but should not matter

1087

* TODO: resolve this */

1088

buf += sp->bytesperline;

1089

cc -= sp->bytesperline;

1090

nrows -= sp->v_sampling;

1091

} while (nrows > 0);

1092

1093

#ifdef JPEG_LIB_MK1

1094

_TIFFfree(tmpbuf);

1095

#endif

1096

1097

}

1098

1099

/* Close down the decompressor if done. */

1100

return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height

1101

|| TIFFjpeg_finish_decompress(sp);

1102

}

1103

1104

1105

/*

1106

* JPEG Encoding.

1107

*/

1108

1109

static void

1110

unsuppress_quant_table (JPEGState* sp, int tblno)

1111

{

1112

JQUANT_TBL* qtbl;

1113

1114

if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)

1115

qtbl->sent_table = FALSE;

1116

}

1117

1118

static void

1119

unsuppress_huff_table (JPEGState* sp, int tblno)

1120

{

1121

JHUFF_TBL* htbl;

1122

1123

if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)

1124

htbl->sent_table = FALSE;

1125

if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)

1126

htbl->sent_table = FALSE;

1127

}

1128

1129

static int

1130

prepare_JPEGTables(TIFF* tif)

1131

{

1132

JPEGState* sp = JState(tif);

1133

1134

JPEGInitializeLibJPEG( tif, 0, 0 );

1135

1136

/* Initialize quant tables for current quality setting */

1137

if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))

1138

return (0);

1139

/* Mark only the tables we want for output */

1140

/* NB: chrominance tables are currently used only with YCbCr */

1141

if (!TIFFjpeg_suppress_tables(sp, TRUE))

1142

return (0);

1143

if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) {

1144

unsuppress_quant_table(sp, 0);

1145

if (sp->photometric == PHOTOMETRIC_YCBCR)

1146

unsuppress_quant_table(sp, 1);

1147

}

1148

if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) {

1149

unsuppress_huff_table(sp, 0);

1150

if (sp->photometric == PHOTOMETRIC_YCBCR)

1151

unsuppress_huff_table(sp, 1);

1152

}

1153

/* Direct libjpeg output into jpegtables */

1154

if (!TIFFjpeg_tables_dest(sp, tif))

1155

return (0);

1156

/* Emit tables-only datastream */

1157

if (!TIFFjpeg_write_tables(sp))

1158

return (0);

1159

1160

return (1);

1161

}

1162

1163

static int

1164

JPEGSetupEncode(TIFF* tif)

1165

{

1166

JPEGState* sp = JState(tif);

1167

TIFFDirectory *td = &tif->tif_dir;

1168

static const char module[] = "JPEGSetupEncode";

1169

1170

JPEGInitializeLibJPEG( tif, 1, 0 );

1171

1172

assert(sp != NULL);

1173

assert(!sp->cinfo.comm.is_decompressor);

1174

1175

/*

1176

* Initialize all JPEG parameters to default values.

1177

* Note that jpeg_set_defaults needs legal values for

1178

* in_color_space and input_components.

1179

*/

1180

sp->cinfo.c.in_color_space = JCS_UNKNOWN;

1181

sp->cinfo.c.input_components = 1;

1182

if (!TIFFjpeg_set_defaults(sp))

1183

return (0);

1184

/* Set per-file parameters */

1185

sp->photometric = td->td_photometric;

1186

switch (sp->photometric) {

1187

case PHOTOMETRIC_YCBCR:

1188

sp->h_sampling = td->td_ycbcrsubsampling[0];

1189

sp->v_sampling = td->td_ycbcrsubsampling[1];

1190

/*

1191

* A ReferenceBlackWhite field *must* be present since the

1192

* default value is inappropriate for YCbCr. Fill in the

1193

* proper value if application didn't set it.

1194

*/

1195

{

1196

float *ref;

1197

if (!TIFFGetField(tif, TIFFTAG_REFERENCEBLACKWHITE,

1198

&ref)) {

1199

float refbw[6];

1200

long top = 1L << td->td_bitspersample;

1201

refbw[0] = 0;

1202

refbw[1] = (float)(top-1L);

1203

refbw[2] = (float)(top>>1);

1204

refbw[3] = refbw[1];

1205

refbw[4] = refbw[2];

1206

refbw[5] = refbw[1];

1207

TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE,

1208

refbw);

1209

}

1210

}

1211

break;

1212

case PHOTOMETRIC_PALETTE: /* disallowed by Tech Note */

1213

case PHOTOMETRIC_MASK:

1214

TIFFErrorExt(tif->tif_clientdata, module,

1215

"PhotometricInterpretation %d not allowed for JPEG",

1216

(int) sp->photometric);

1217

return (0);

1218

default:

1219

/* TIFF 6.0 forbids subsampling of all other color spaces */

1220

sp->h_sampling = 1;

1221

sp->v_sampling = 1;

1222

break;

1223

}

1224

1225

/* Verify miscellaneous parameters */

1226

1227

/*

1228

* This would need work if libtiff ever supports different

1229

* depths for different components, or if libjpeg ever supports

1230

* run-time selection of depth. Neither is imminent.

1231

*/

1232

#ifdef JPEG_LIB_MK1

1233

/* BITS_IN_JSAMPLE now permits 8 and 12 --- dgilbert */

1234

if (td->td_bitspersample != 8 && td->td_bitspersample != 12)

1235

#else

1236

if (td->td_bitspersample != BITS_IN_JSAMPLE )

1237

#endif

1238

{

1239

TIFFErrorExt(tif->tif_clientdata, module, "BitsPerSample %d not allowed for JPEG",

1240

(int) td->td_bitspersample);

1241

return (0);

1242

}

1243

sp->cinfo.c.data_precision = td->td_bitspersample;

1244

#ifdef JPEG_LIB_MK1

1245

sp->cinfo.c.bits_in_jsample = td->td_bitspersample;

1246

#endif

1247

if (isTiled(tif)) {

1248

if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0) {

1249

TIFFErrorExt(tif->tif_clientdata, module,

1250

"JPEG tile height must be multiple of %d",

1251

sp->v_sampling * DCTSIZE);

1252

return (0);

1253

}

1254

if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0) {

1255

TIFFErrorExt(tif->tif_clientdata, module,

1256

"JPEG tile width must be multiple of %d",

1257

sp->h_sampling * DCTSIZE);

1258

return (0);

1259

}

1260

} else {

1261

if (td->td_rowsperstrip < td->td_imagelength &&

1262

(td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0) {

1263

TIFFErrorExt(tif->tif_clientdata, module,

1264

"RowsPerStrip must be multiple of %d for JPEG",

1265

sp->v_sampling * DCTSIZE);

1266

return (0);

1267

}

1268

}

1269

1270

/* Create a JPEGTables field if appropriate */

1271

if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) {

1272

if( sp->jpegtables == NULL

1273

|| memcmp(sp->jpegtables,"\0\0\0\0\0\0\0\0\0",8) == 0 )

1274

{

1275

if (!prepare_JPEGTables(tif))

1276

return (0);

1277

/* Mark the field present */

1278

/* Can't use TIFFSetField since BEENWRITING is already set! */

1279

tif->tif_flags |= TIFF_DIRTYDIRECT;

1280

TIFFSetFieldBit(tif, FIELD_JPEGTABLES);

1281

}

1282

} else {

1283

/* We do not support application-supplied JPEGTables, */

1284

/* so mark the field not present */

1285

TIFFClrFieldBit(tif, FIELD_JPEGTABLES);

1286

}

1287

1288

/* Direct libjpeg output to libtiff's output buffer */

1289

TIFFjpeg_data_dest(sp, tif);

1290

1291

return (1);

1292

}

1293

1294

/*

1295

* Set encoding state at the start of a strip or tile.

1296

*/

1297

static int

1298

JPEGPreEncode(TIFF* tif, tsample_t s)

1299

{

1300

JPEGState *sp = JState(tif);

1301

TIFFDirectory *td = &tif->tif_dir;

1302

static const char module[] = "JPEGPreEncode";

1303

uint32 segment_width, segment_height;

1304

int downsampled_input;

1305

1306

assert(sp != NULL);

1307

assert(!sp->cinfo.comm.is_decompressor);

1308

/*

1309

* Set encoding parameters for this strip/tile.

1310

*/

1311

if (isTiled(tif)) {

1312

segment_width = td->td_tilewidth;

1313

segment_height = td->td_tilelength;

1314

sp->bytesperline = TIFFTileRowSize(tif);

1315

} else {

1316

segment_width = td->td_imagewidth;

1317

segment_height = td->td_imagelength - tif->tif_row;

1318

if (segment_height > td->td_rowsperstrip)

1319

segment_height = td->td_rowsperstrip;

1320

sp->bytesperline = TIFFOldScanlineSize(tif);

1321

}

1322

if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {

1323

/* for PC 2, scale down the strip/tile size

1324

* to match a downsampled component

1325

*/

1326

segment_width = TIFFhowmany(segment_width, sp->h_sampling);

1327

segment_height = TIFFhowmany(segment_height, sp->v_sampling);

1328

}

1329

if (segment_width > 65535 || segment_height > 65535) {

1330

TIFFErrorExt(tif->tif_clientdata, module, "Strip/tile too large for JPEG");

1331

return (0);

1332

}

1333

sp->cinfo.c.image_width = segment_width;

1334

sp->cinfo.c.image_height = segment_height;

1335

downsampled_input = FALSE;

1336

if (td->td_planarconfig == PLANARCONFIG_CONTIG) {

1337

sp->cinfo.c.input_components = td->td_samplesperpixel;

1338

if (sp->photometric == PHOTOMETRIC_YCBCR) {

1339

if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {

1340

sp->cinfo.c.in_color_space = JCS_RGB;

1341

} else {

1342

sp->cinfo.c.in_color_space = JCS_YCbCr;

1343

if (sp->h_sampling != 1 || sp->v_sampling != 1)

1344

downsampled_input = TRUE;

1345

}

1346

if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))

1347

return (0);

1348

/*

1349

* Set Y sampling factors;

1350

* we assume jpeg_set_colorspace() set the rest to 1

1351

*/

1352

sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;

1353

sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;

1354

} else {

1355

sp->cinfo.c.in_color_space = JCS_UNKNOWN;

1356

if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))

1357

return (0);

1358

/* jpeg_set_colorspace set all sampling factors to 1 */

1359

}

1360

} else {

1361

sp->cinfo.c.input_components = 1;

1362

sp->cinfo.c.in_color_space = JCS_UNKNOWN;

1363

if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))

1364

return (0);

1365

sp->cinfo.c.comp_info[0].component_id = s;

1366

/* jpeg_set_colorspace() set sampling factors to 1 */

1367

if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) {

1368

sp->cinfo.c.comp_info[0].quant_tbl_no = 1;

1369

sp->cinfo.c.comp_info[0].dc_tbl_no = 1;

1370

sp->cinfo.c.comp_info[0].ac_tbl_no = 1;

1371

}

1372

}

1373

/* ensure libjpeg won't write any extraneous markers */

1374

sp->cinfo.c.write_JFIF_header = FALSE;

1375

sp->cinfo.c.write_Adobe_marker = FALSE;

1376

/* set up table handling correctly */

1377

if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))

1378

return (0);

1379

if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) {

1380

unsuppress_quant_table(sp, 0);

1381

unsuppress_quant_table(sp, 1);

1382

}

1383

if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF)

1384

sp->cinfo.c.optimize_coding = FALSE;

1385

else

1386

sp->cinfo.c.optimize_coding = TRUE;

1387

if (downsampled_input) {

1388

/* Need to use raw-data interface to libjpeg */

1389

sp->cinfo.c.raw_data_in = TRUE;

1390

tif->tif_encoderow = JPEGEncodeRaw;

1391

tif->tif_encodestrip = JPEGEncodeRaw;

1392

tif->tif_encodetile = JPEGEncodeRaw;

1393

} else {

1394

/* Use normal interface to libjpeg */

1395

sp->cinfo.c.raw_data_in = FALSE;

1396

tif->tif_encoderow = JPEGEncode;

1397

tif->tif_encodestrip = JPEGEncode;

1398

tif->tif_encodetile = JPEGEncode;

1399

}

1400

/* Start JPEG compressor */

1401

if (!TIFFjpeg_start_compress(sp, FALSE))

1402

return (0);

1403

/* Allocate downsampled-data buffers if needed */

1404

if (downsampled_input) {

1405

if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info,

1406

sp->cinfo.c.num_components))

1407

return (0);

1408

}

1409

sp->scancount = 0;

1410

1411

return (1);

1412

}

1413

1414

/*

1415

* Encode a chunk of pixels.

1416

* "Standard" case: incoming data is not downsampled.

1417

*/

1418

static int

1419

JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)

1420

{

1421

JPEGState *sp = JState(tif);

1422

tsize_t nrows;

1423

JSAMPROW bufptr[1];

1424

1425

(void) s;

1426

assert(sp != NULL);

1427

/* data is expected to be supplied in multiples of a scanline */

1428

nrows = cc / sp->bytesperline;

1429

if (cc % sp->bytesperline)

1430

TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");

1431

1432

/* The last strip will be limited to image size */

1433

if( !isTiled(tif) && tif->tif_row+nrows > tif->tif_dir.td_imagelength )

1434

nrows = tif->tif_dir.td_imagelength - tif->tif_row;

1435

1436

while (nrows-- > 0) {

1437

bufptr[0] = (JSAMPROW) buf;

1438

if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)

1439

return (0);

1440

if (nrows > 0)

1441

tif->tif_row++;

1442

buf += sp->bytesperline;

1443

}

1444

return (1);

1445

}

1446

1447

/*

1448

* Encode a chunk of pixels.

1449

* Incoming data is expected to be downsampled per sampling factors.

1450

*/

1451

static int

1452

JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)

1453

{

1454

JPEGState *sp = JState(tif);

1455

JSAMPLE* inptr;

1456

JSAMPLE* outptr;

1457

tsize_t nrows;

1458

JDIMENSION clumps_per_line, nclump;

1459

int clumpoffset, ci, xpos, ypos;

1460

jpeg_component_info* compptr;

1461

int samples_per_clump = sp->samplesperclump;

1462

tsize_t bytesperclumpline;

1463

1464

(void) s;

1465

assert(sp != NULL);

1466

/* data is expected to be supplied in multiples of a clumpline */

1467

/* a clumpline is equivalent to v_sampling desubsampled scanlines */

1468

/* TODO: the following calculation of bytesperclumpline, should substitute calculation of sp->bytesperline, except that it is per v_sampling lines */

1469

bytesperclumpline = (((sp->cinfo.c.image_width+sp->h_sampling-1)/sp->h_sampling)

1470

*(sp->h_sampling*sp->v_sampling+2)*sp->cinfo.c.data_precision+7)

1471

/8;

1472

1473

nrows = ( cc / bytesperclumpline ) * sp->v_sampling;

1474

if (cc % bytesperclumpline)

1475

TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");

1476

1477

/* Cb,Cr both have sampling factors 1, so this is correct */

1478

clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;

1479

1480

while (nrows > 0) {

1481

/*

1482

* Fastest way to separate the data is to make one pass

1483

* over the scanline for each row of each component.

1484

*/

1485

clumpoffset = 0; /* first sample in clump */

1486

for (ci = 0, compptr = sp->cinfo.c.comp_info;

1487

ci < sp->cinfo.c.num_components;

1488

ci++, compptr++) {

1489

int hsamp = compptr->h_samp_factor;

1490

int vsamp = compptr->v_samp_factor;

1491

int padding = (int) (compptr->width_in_blocks * DCTSIZE -

1492

clumps_per_line * hsamp);

1493

for (ypos = 0; ypos < vsamp; ypos++) {

1494

inptr = ((JSAMPLE*) buf) + clumpoffset;

1495

outptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];

1496

if (hsamp == 1) {

1497

/* fast path for at least Cb and Cr */

1498

for (nclump = clumps_per_line; nclump-- > 0; ) {

1499

*outptr++ = inptr[0];

1500

inptr += samples_per_clump;

1501

}

1502

} else {

1503

/* general case */

1504

for (nclump = clumps_per_line; nclump-- > 0; ) {

1505

for (xpos = 0; xpos < hsamp; xpos++)

1506

*outptr++ = inptr[xpos];

1507

inptr += samples_per_clump;

1508

}

1509

}

1510

/* pad each scanline as needed */

1511

for (xpos = 0; xpos < padding; xpos++) {

1512

*outptr = outptr[-1];

1513

outptr++;

1514

}

1515

clumpoffset += hsamp;

1516

}

1517

}

1518

sp->scancount++;

1519

if (sp->scancount >= DCTSIZE) {

1520

int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;

1521

if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)

1522

return (0);

1523

sp->scancount = 0;

1524

}

1525

tif->tif_row += sp->v_sampling;

1526

buf += sp->bytesperline;

1527

nrows -= sp->v_sampling;

1528

}

1529

return (1);

1530

}

1531

1532

/*

1533

* Finish up at the end of a strip or tile.

1534

*/

1535

static int

1536

JPEGPostEncode(TIFF* tif)

1537

{

1538

JPEGState *sp = JState(tif);

1539

1540

if (sp->scancount > 0) {

1541

/*

1542

* Need to emit a partial bufferload of downsampled data.

1543

* Pad the data vertically.

1544

*/

1545

int ci, ypos, n;

1546

jpeg_component_info* compptr;

1547

1548

for (ci = 0, compptr = sp->cinfo.c.comp_info;

1549

ci < sp->cinfo.c.num_components;

1550

ci++, compptr++) {

1551

int vsamp = compptr->v_samp_factor;

1552

tsize_t row_width = compptr->width_in_blocks * DCTSIZE

1553

* sizeof(JSAMPLE);

1554

for (ypos = sp->scancount * vsamp;

1555

ypos < DCTSIZE * vsamp; ypos++) {

1556

_TIFFmemcpy((tdata_t)sp->ds_buffer[ci][ypos],

1557

(tdata_t)sp->ds_buffer[ci][ypos-1],

1558

row_width);

1559

1560

}

1561

}

1562

n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;

1563

if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)

1564

return (0);

1565

}

1566

1567

return (TIFFjpeg_finish_compress(JState(tif)));

1568

}

1569

1570

static void

1571

JPEGCleanup(TIFF* tif)

1572

{

1573

JPEGState *sp = JState(tif);

1574

1575

assert(sp != 0);

1576

1577

tif->tif_tagmethods.vgetfield = sp->vgetparent;

1578

tif->tif_tagmethods.vsetfield = sp->vsetparent;

1579

tif->tif_tagmethods.printdir = sp->printdir;

1580

1581

if( sp->cinfo_initialized )

1582

TIFFjpeg_destroy(sp); /* release libjpeg resources */

1583

if (sp->jpegtables) /* tag value */

1584

_TIFFfree(sp->jpegtables);

1585

_TIFFfree(tif->tif_data); /* release local state */

1586

tif->tif_data = NULL;

1587

1588

_TIFFSetDefaultCompressionState(tif);

1589

}

1590

1591

static void

1592

JPEGResetUpsampled( TIFF* tif )

1593

{

1594

JPEGState* sp = JState(tif);

1595

TIFFDirectory* td = &tif->tif_dir;

1596

1597

/*

1598

* Mark whether returned data is up-sampled or not so TIFFStripSize

1599

* and TIFFTileSize return values that reflect the true amount of

1600

* data.

1601

*/

1602

tif->tif_flags &= ~TIFF_UPSAMPLED;

1603

if (td->td_planarconfig == PLANARCONFIG_CONTIG) {

1604

if (td->td_photometric == PHOTOMETRIC_YCBCR &&

1605

sp->jpegcolormode == JPEGCOLORMODE_RGB) {

1606

tif->tif_flags |= TIFF_UPSAMPLED;

1607

} else {

1608

#ifdef notdef

1609

if (td->td_ycbcrsubsampling[0] != 1 ||

1610

td->td_ycbcrsubsampling[1] != 1)

1611

; /* XXX what about up-sampling? */

1612

#endif

1613

}

1614

}

1615

1616

/*

1617

* Must recalculate cached tile size in case sampling state changed.

1618

* Should we really be doing this now if image size isn't set?

1619

*/

1620

if( tif->tif_tilesize > 0 )

1621

tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;

1622

1623

if(tif->tif_scanlinesize > 0 )

1624

tif->tif_scanlinesize = TIFFScanlineSize(tif);

1625

}

1626

1627

static int

1628

JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)

1629

{

1630

JPEGState* sp = JState(tif);

1631

const TIFFFieldInfo* fip;

1632

uint32 v32;

1633

1634

assert(sp != NULL);

1635

1636

switch (tag) {

1637

case TIFFTAG_JPEGTABLES:

1638

v32 = va_arg(ap, uint32);

1639

if (v32 == 0) {

1640

/* XXX */

1641

return (0);

1642

}

1643

_TIFFsetByteArray(&sp->jpegtables, va_arg(ap, void*),

1644

(long) v32);

1645

sp->jpegtables_length = v32;

1646

TIFFSetFieldBit(tif, FIELD_JPEGTABLES);

1647

break;

1648

case TIFFTAG_JPEGQUALITY:

1649

sp->jpegquality = va_arg(ap, int);

1650

return (1); /* pseudo tag */

1651

case TIFFTAG_JPEGCOLORMODE:

1652

sp->jpegcolormode = va_arg(ap, int);

1653

JPEGResetUpsampled( tif );

1654

return (1); /* pseudo tag */

1655

case TIFFTAG_PHOTOMETRIC:

1656

{

1657

int ret_value = (*sp->vsetparent)(tif, tag, ap);

1658

JPEGResetUpsampled( tif );

1659

return ret_value;

1660

}

1661

case TIFFTAG_JPEGTABLESMODE:

1662

sp->jpegtablesmode = va_arg(ap, int);

1663

return (1); /* pseudo tag */

1664

case TIFFTAG_YCBCRSUBSAMPLING:

1665

/* mark the fact that we have a real ycbcrsubsampling! */

1666

sp->ycbcrsampling_fetched = 1;

1667

/* should we be recomputing upsampling info here? */

1668

return (*sp->vsetparent)(tif, tag, ap);

1669

case TIFFTAG_FAXRECVPARAMS:

1670

sp->recvparams = va_arg(ap, uint32);

1671

break;

1672

case TIFFTAG_FAXSUBADDRESS:

1673

_TIFFsetString(&sp->subaddress, va_arg(ap, char*));

1674

break;

1675

case TIFFTAG_FAXRECVTIME:

1676

sp->recvtime = va_arg(ap, uint32);

1677

break;

1678

case TIFFTAG_FAXDCS:

1679

_TIFFsetString(&sp->faxdcs, va_arg(ap, char*));

1680

break;

1681

default:

1682

return (*sp->vsetparent)(tif, tag, ap);

1683

}

1684

1685

if ((fip = _TIFFFieldWithTag(tif, tag))) {

1686

TIFFSetFieldBit(tif, fip->field_bit);

1687

} else {

1688

return (0);

1689

}

1690

1691

tif->tif_flags |= TIFF_DIRTYDIRECT;

1692

return (1);

1693

}

1694

1695

/*

1696

* Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in

1697

* the TIFF tags, but still use non-default (2,2) values within the jpeg

1698

* data stream itself. In order for TIFF applications to work properly

1699

* - for instance to get the strip buffer size right - it is imperative

1700

* that the subsampling be available before we start reading the image

1701

* data normally. This function will attempt to load the first strip in

1702

* order to get the sampling values from the jpeg data stream. Various

1703

* hacks are various places are done to ensure this function gets called

1704

* before the td_ycbcrsubsampling values are used from the directory structure,

1705

* including calling TIFFGetField() for the YCBCRSUBSAMPLING field from

1706

* TIFFStripSize(), and the printing code in tif_print.c.

1707

*

1708

* Note that JPEGPreDeocode() will produce a fairly loud warning when the

1709

* discovered sampling does not match the default sampling (2,2) or whatever

1710

* was actually in the tiff tags.

1711

*

1712

* Problems:

1713

* o This code will cause one whole strip/tile of compressed data to be

1714

* loaded just to get the tags right, even if the imagery is never read.

1715

* It would be more efficient to just load a bit of the header, and

1716

* initialize things from that.

1717

*

1718

* See the bug in bugzilla for details:

1719

*

1720

* http://bugzilla.remotesensing.org/show_bug.cgi?id=168

1721

*

1722

* Frank Warmerdam, July 2002

1723

*/

1724

1725

static void

1726

JPEGFixupTestSubsampling( TIFF * tif )

1727

{

1728

#ifdef CHECK_JPEG_YCBCR_SUBSAMPLING

1729

JPEGState *sp = JState(tif);

1730

TIFFDirectory *td = &tif->tif_dir;

1731

1732

JPEGInitializeLibJPEG( tif, 0, 0 );

1733

1734

/*

1735

* Some JPEG-in-TIFF files don't provide the ycbcrsampling tags,

1736

* and use a sampling schema other than the default 2,2. To handle

1737

* this we actually have to scan the header of a strip or tile of

1738

* jpeg data to get the sampling.

1739

*/

1740

if( !sp->cinfo.comm.is_decompressor

1741

|| sp->ycbcrsampling_fetched

1742

|| td->td_photometric != PHOTOMETRIC_YCBCR )

1743

return;

1744

1745

sp->ycbcrsampling_fetched = 1;

1746

if( TIFFIsTiled( tif ) )

1747

{

1748

if( !TIFFFillTile( tif, 0 ) )

1749

return;

1750

}

1751

else

1752

{

1753

if( !TIFFFillStrip( tif, 0 ) )

1754

return;

1755

}

1756

1757

TIFFSetField( tif, TIFFTAG_YCBCRSUBSAMPLING,

1758

(uint16) sp->h_sampling, (uint16) sp->v_sampling );

1759

1760

/*

1761

** We want to clear the loaded strip so the application has time

1762

** to set JPEGCOLORMODE or other behavior modifiers. This essentially

1763

** undoes the JPEGPreDecode triggers by TIFFFileStrip(). (#1936)

1764

*/

1765

tif->tif_curstrip = -1;

1766

1767

#endif /* CHECK_JPEG_YCBCR_SUBSAMPLING */

1768

}

1769

1770

static int

1771

JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)

1772

{

1773

JPEGState* sp = JState(tif);

1774

1775

assert(sp != NULL);

1776

1777

switch (tag) {

1778

case TIFFTAG_JPEGTABLES:

1779

*va_arg(ap, uint32*) = sp->jpegtables_length;

1780

*va_arg(ap, void**) = sp->jpegtables;

1781

break;

1782

case TIFFTAG_JPEGQUALITY:

1783

*va_arg(ap, int*) = sp->jpegquality;

1784

break;

1785

case TIFFTAG_JPEGCOLORMODE:

1786

*va_arg(ap, int*) = sp->jpegcolormode;

1787

break;

1788

case TIFFTAG_JPEGTABLESMODE:

1789

*va_arg(ap, int*) = sp->jpegtablesmode;

1790

break;

1791

case TIFFTAG_YCBCRSUBSAMPLING:

1792

JPEGFixupTestSubsampling( tif );

1793

return (*sp->vgetparent)(tif, tag, ap);

1794

case TIFFTAG_FAXRECVPARAMS:

1795

*va_arg(ap, uint32*) = sp->recvparams;

1796

break;

1797

case TIFFTAG_FAXSUBADDRESS:

1798

*va_arg(ap, char**) = sp->subaddress;

1799

break;

1800

case TIFFTAG_FAXRECVTIME:

1801

*va_arg(ap, uint32*) = sp->recvtime;

1802

break;

1803

case TIFFTAG_FAXDCS:

1804

*va_arg(ap, char**) = sp->faxdcs;

1805

break;

1806

default:

1807

return (*sp->vgetparent)(tif, tag, ap);

1808

}

1809

return (1);

1810

}

1811

1812

static void

1813

JPEGPrintDir(TIFF* tif, FILE* fd, long flags)

1814

{

1815

JPEGState* sp = JState(tif);

1816

1817

assert(sp != NULL);

1818

1819

(void) flags;

1820

if (TIFFFieldSet(tif,FIELD_JPEGTABLES))

1821

fprintf(fd, " JPEG Tables: (%lu bytes)\n",

1822

(unsigned long) sp->jpegtables_length);

1823

if (TIFFFieldSet(tif,FIELD_RECVPARAMS))

1824

fprintf(fd, " Fax Receive Parameters: %08lx\n",

1825

(unsigned long) sp->recvparams);

1826

if (TIFFFieldSet(tif,FIELD_SUBADDRESS))

1827

fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress);

1828

if (TIFFFieldSet(tif,FIELD_RECVTIME))

1829

fprintf(fd, " Fax Receive Time: %lu secs\n",

1830

(unsigned long) sp->recvtime);

1831

if (TIFFFieldSet(tif,FIELD_FAXDCS))

1832

fprintf(fd, " Fax DCS: %s\n", sp->faxdcs);

1833

}

1834

1835

static uint32

1836

JPEGDefaultStripSize(TIFF* tif, uint32 s)

1837

{

1838

JPEGState* sp = JState(tif);

1839

TIFFDirectory *td = &tif->tif_dir;

1840

1841

s = (*sp->defsparent)(tif, s);

1842

if (s < td->td_imagelength)

1843

s = TIFFroundup(s, td->td_ycbcrsubsampling[1] * DCTSIZE);

1844

return (s);

1845

}

1846

1847

static void

1848

JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)

1849

{

1850

JPEGState* sp = JState(tif);

1851

TIFFDirectory *td = &tif->tif_dir;

1852

1853

(*sp->deftparent)(tif, tw, th);

1854

*tw = TIFFroundup(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE);

1855

*th = TIFFroundup(*th, td->td_ycbcrsubsampling[1] * DCTSIZE);

1856

}

1857

1858

/*

1859

* The JPEG library initialized used to be done in TIFFInitJPEG(), but

1860

* now that we allow a TIFF file to be opened in update mode it is necessary

1861

* to have some way of deciding whether compression or decompression is

1862

* desired other than looking at tif->tif_mode. We accomplish this by

1863

* examining {TILE/STRIP}BYTECOUNTS to see if there is a non-zero entry.

1864

* If so, we assume decompression is desired.

1865

*

1866

* This is tricky, because TIFFInitJPEG() is called while the directory is

1867

* being read, and generally speaking the BYTECOUNTS tag won't have been read

1868

* at that point. So we try to defer jpeg library initialization till we

1869

* do have that tag ... basically any access that might require the compressor

1870

* or decompressor that occurs after the reading of the directory.

1871

*

1872

* In an ideal world compressors or decompressors would be setup

1873

* at the point where a single tile or strip was accessed (for read or write)

1874

* so that stuff like update of missing tiles, or replacement of tiles could

1875

* be done. However, we aren't trying to crack that nut just yet ...

1876

*

1877

* NFW, Feb 3rd, 2003.

1878

*/

1879

1880

static int JPEGInitializeLibJPEG( TIFF * tif, int force_encode, int force_decode )

1881

{

1882

JPEGState* sp = JState(tif);

1883

uint32 *byte_counts = NULL;

1884

int data_is_empty = TRUE;

1885

int decompress;

1886

1887

1888

if(sp->cinfo_initialized)

1889

{

1890

if( force_encode && sp->cinfo.comm.is_decompressor )

1891

TIFFjpeg_destroy( sp );

1892

else if( force_decode && !sp->cinfo.comm.is_decompressor )

1893

TIFFjpeg_destroy( sp );

1894

else

1895

return 1;

1896

1897

sp->cinfo_initialized = 0;

1898

}

1899

1900

/*

1901

* Do we have tile data already? Make sure we initialize the

1902

* the state in decompressor mode if we have tile data, even if we

1903

* are not in read-only file access mode.

1904

*/

1905

if( TIFFIsTiled( tif )

1906

&& TIFFGetField( tif, TIFFTAG_TILEBYTECOUNTS, &byte_counts )

1907

&& byte_counts != NULL )

1908

{

1909

data_is_empty = byte_counts[0] == 0;

1910

}

1911

if( !TIFFIsTiled( tif )

1912

&& TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &byte_counts)

1913

&& byte_counts != NULL )

1914

{

1915

data_is_empty = byte_counts[0] == 0;

1916

}

1917

1918

if( force_decode )

1919

decompress = 1;

1920

else if( force_encode )

1921

decompress = 0;

1922

else if( tif->tif_mode == O_RDONLY )

1923

decompress = 1;

1924

else if( data_is_empty )

1925

decompress = 0;

1926

else

1927

decompress = 1;

1928

1929

/*

1930

* Initialize libjpeg.

1931

*/

1932

if ( decompress ) {

1933

if (!TIFFjpeg_create_decompress(sp))

1934

return (0);

1935

1936

} else {

1937

if (!TIFFjpeg_create_compress(sp))

1938

return (0);

1939

}

1940

1941

sp->cinfo_initialized = TRUE;

1942

1943

return 1;

1944

}

1945

1946

int

1947

TIFFInitJPEG(TIFF* tif, int scheme)

1948

{

1949

JPEGState* sp;

1950

1951

assert(scheme == COMPRESSION_JPEG);

1952

1953

/*

1954

* Merge codec-specific tag information.

1955

*/

1956

if (!_TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo))) {

1957

TIFFErrorExt(tif->tif_clientdata,

1958

"TIFFInitJPEG",

1959

"Merging JPEG codec-specific tags failed");

1960

return 0;

1961

}

1962

1963

/*

1964

* Allocate state block so tag methods have storage to record values.

1965

*/

1966

tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (JPEGState));

1967

1968

if (tif->tif_data == NULL) {

1969

TIFFErrorExt(tif->tif_clientdata,

1970

"TIFFInitJPEG", "No space for JPEG state block");

1971

return 0;

1972

}

1973

_TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));

1974

1975

sp = JState(tif);

1976

sp->tif = tif; /* back link */

1977

1978

/*

1979

* Override parent get/set field methods.

1980

*/

1981

sp->vgetparent = tif->tif_tagmethods.vgetfield;

1982

tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */

1983

sp->vsetparent = tif->tif_tagmethods.vsetfield;

1984

tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */

1985

sp->printdir = tif->tif_tagmethods.printdir;

1986

tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */

1987

1988

/* Default values for codec-specific fields */

1989

sp->jpegtables = NULL;

1990

sp->jpegtables_length = 0;

1991

sp->jpegquality = 75; /* Default IJG quality */

1992

sp->jpegcolormode = JPEGCOLORMODE_RAW;

1993

sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF;

1994

1995

sp->recvparams = 0;

1996

sp->subaddress = NULL;

1997

sp->faxdcs = NULL;

1998

1999

sp->ycbcrsampling_fetched = 0;

2000

2001

/*

2002

* Install codec methods.

2003

*/

2004

tif->tif_setupdecode = JPEGSetupDecode;

2005

tif->tif_predecode = JPEGPreDecode;

2006

tif->tif_decoderow = JPEGDecode;

2007

tif->tif_decodestrip = JPEGDecode;

2008

tif->tif_decodetile = JPEGDecode;

2009

tif->tif_setupencode = JPEGSetupEncode;

2010

tif->tif_preencode = JPEGPreEncode;

2011

tif->tif_postencode = JPEGPostEncode;

2012

tif->tif_encoderow = JPEGEncode;

2013

tif->tif_encodestrip = JPEGEncode;

2014

tif->tif_encodetile = JPEGEncode;

2015

tif->tif_cleanup = JPEGCleanup;

2016

sp->defsparent = tif->tif_defstripsize;

2017

tif->tif_defstripsize = JPEGDefaultStripSize;

2018

sp->deftparent = tif->tif_deftilesize;

2019

tif->tif_deftilesize = JPEGDefaultTileSize;

2020

tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */

2021

2022

sp->cinfo_initialized = FALSE;

2023

2024

/*

2025

** Create a JPEGTables field if no directory has yet been created.

2026

** We do this just to ensure that sufficient space is reserved for

2027

** the JPEGTables field. It will be properly created the right

2028

** size later.

2029

*/

2030

if( tif->tif_diroff == 0 )

2031

{

2032

#define SIZE_OF_JPEGTABLES 2000

2033

/*

2034

The following line assumes incorrectly that all JPEG-in-TIFF files will have

2035

a JPEGTABLES tag generated and causes null-filled JPEGTABLES tags to be written

2036

when the JPEG data is placed with TIFFWriteRawStrip. The field bit should be

2037

set, anyway, later when actual JPEGTABLES header is generated, so removing it

2038

here hopefully is harmless.

2039

TIFFSetFieldBit(tif, FIELD_JPEGTABLES);

2040

*/

2041

sp->jpegtables_length = SIZE_OF_JPEGTABLES;

2042

sp->jpegtables = (void *) _TIFFmalloc(sp->jpegtables_length);

2043

_TIFFmemset(sp->jpegtables, 0, SIZE_OF_JPEGTABLES);

2044

#undef SIZE_OF_JPEGTABLES

2045

}

2046

2047

/*

2048

* Mark the TIFFTAG_YCBCRSAMPLES as present even if it is not

2049

* see: JPEGFixupTestSubsampling().

2050

*/

2051

TIFFSetFieldBit( tif, FIELD_YCBCRSUBSAMPLING );

2052

2053

return 1;

2054

}

2055

#endif /* JPEG_SUPPORT */

2056

2057

/* vim: set ts=8 sts=8 sw=8 noet: */

2058

2059

/*

2060

* Local Variables:

2061

* mode: c

2062

* c-basic-offset: 8

2063

* fill-column: 78

2064

* End:

2065

*/