文档格式转换服务

# Check all required libraries at once
pkg-config --modversion libtiff-4 libopenjp2 libjpeg libturbojpeg zlib

# Expected output (each on separate line):
# 4.1.0        (libtiff-4)
# 2.3.1        (libopenjp2)
# 9.4.0        (libjpeg - provided by libjpeg-turbo)
# 3.0.0        (libturbojpeg - SIMD-accelerated API ⚡)
# 1.2.11       (zlib)

sudo apt-get update
sudo apt-get install -y \
  libtiff-dev \
  libopenjp2-7-dev \
  libjpeg-turbo8-dev \
  zlib1g-dev

# ⚡ libjpeg-turbo provides SIMD-accelerated JPEG processing
# AVX2/SSE2 support is automatically enabled on compatible CPUs

# Check library versions
pkg-config --modversion libtiff-4 libopenjp2 libjpeg libturbojpeg zlib

# Verify libjpeg-turbo is installed (not legacy libjpeg)
dpkg -l | grep libjpeg-turbo
# Should show: libjpeg-turbo8-dev (SIMD-enabled version)

# Check CPU SIMD capabilities
cat /proc/cpuinfo | grep -E "sse2|avx|avx2|avx512"
# Look for: avx2 (best), avx512f (server CPUs), or sse2 (minimum)

# Expected output (versions may vary):
# libtiff-4: 4.1.0+
# libopenjp2: 2.3.1+
# libjpeg: 9.4.0+ (legacy API, provided by libjpeg-turbo8-dev)
# libturbojpeg: 3.0.0+ (TurboJPEG API with SIMD ⚡)
# zlib: 1.2.11+

# Install dependencies via Homebrew
brew install libtiff openjpeg jpeg-turbo

# ⚡ jpeg-turbo includes NEON SIMD support for Apple Silicon
# Automatically optimized for M1/M2/M3 processors

sysctl hw.optional.neon
# Output: hw.optional.neon: 1 (✅ SIMD enabled)

npm install @janus-mcp/converter

git clone https://github.com/edwardkim/janus-mcp.git
cd mcp-janus-converter
npm install
npm run build

{
  "mcpServers": {
    "janus-converter": {
      "command": "npx",
      "args": ["-y", "@janus-mcp/converter"]
    }
  }
}

{
  "pdf_path": "/path/to/input.pdf",
  "tiff_path": "/path/to/output.tif",
  "verbose": false
}

{
  "success": true,
  "message": "Conversion successful",
  "input": {
    "path": "/path/to/input.pdf",
    "size": 1048576,
    "sizeFormatted": "1.00 MB"
  },
  "output": {
    "path": "/path/to/output.tif",
    "size": 2097152,
    "sizeFormatted": "2.00 MB",
    "exists": true
  },
  "conversion": {
    "pageCount": 9,
    "elapsedMs": 4,
    "avgMsPerPage": "0.44"
  }
}

{
  "tiff_path": "/path/to/input.tif",
  "pdf_path": "/path/to/output.pdf",
  "verbose": false
}

{
  "pdf_path": "/path/to/file.pdf"
}

{
  "success": true,
  "path": "/path/to/file.pdf",
  "exists": true,
  "size": 1048576,
  "sizeFormatted": "1.00 MB",
  "isFile": true,
  "isDirectory": false,
  "error": null
}

{
  success: boolean,
  pageCount: number,
  message: string
}

{
  success: boolean,
  pageCount: number,
  message: string
}

First Page:      [SOI][DQT][DHT][SOF][SOS]...image data...[EOI]  ← Complete JPEG
                  └─────────────────────────────────────────┘
                              Stored in Strip

Subsequent Pages: [SOI][DQT][DHT]  +  [SOS]...image data...[EOI]  ← Split storage
                  └──────────────┘    └─────────────────────┘
                   JPEGTABLES tag         Strip data only

Detection → Is JPEGTABLES present?
    │
    ├─ No  → Single-strip: Direct Zero-Copy (0.8ms/page)
    │
    └─ Yes → Multi-strip: Smart reconstruction
              │
              ├─ First page: Use strip directly (already complete)
              │
              └─ Subsequent pages: JPEGTABLES + Strip → Decode → FlateDecode
                                   (91.2ms/page, but correct output)

// Enable JPEG2000 normalization
const result = await tiff2pdf.ConvertAsync(tiffPath, pdfPath, {
  normalizeJpeg2000: true,    // 33004, 34713 → 34712
  normalizeFallback: 1        // 0=error, 1=keep original, 2=uncompressed
});

// Result includes normalization statistics
console.log(result.normalizeSuccessCount);  // Pages normalized
console.log(result.normalizeFailedCount);   // Fallback used

# JPEG2000 J2K format (recommended)
vips tiffsave input.jpg output.tif \
  --compression=j2k-minervasoft \
  --Q=85 \
  --tile=false

# JPEG2000 JP2 format
vips tiffsave input.jpg output.tif \
  --compression=jp2-inzisoft \
  --Q=85 \
  --tile=false

import pyvips

image = pyvips.Image.new_from_file('input.jpg')
image.tiffsave('output.tif',
    compression='j2k-minervasoft',  # or 'jp2-inzisoft'
    Q=85,
    tile=False,                      # Force strip-based
    pyramid=False)

#include <tiffio.h>

TIFF *tif = TIFFOpen("output.tif", "w");
TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(tif, TIFFTAG_COMPRESSION, 34713);  // J2K
TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, height);  // Full-height strip
// ... write data
TIFFClose(tif);

tiffinfo your-file.tif | grep -E "(Tile|Rows/Strip)"

# Optimal (strip-based):
#   Rows/Strip: 1056  (equals image height)

# Slow (tiled):
#   Tile Width: 128 Tile Length: 128

sysctl hw.optional.neon
# Output: hw.optional.neon: 1  (✅ NEON supported)

cat /proc/cpuinfo | grep -E "sse2|avx|avx2|avx512"
# Look for: avx2, avx512f

wmic cpu get name
# Then check CPU specs on Intel/AMD website

Total Conversion Time = TIFF Decoding + JPEG Recompression + PDF Writing

JPEG Recompression (with SIMD):
  - AVX2:      ~30ms per page
  - NEON:      ~40ms per page
  - SSE2:      ~50ms per page
  - No SIMD:   ~140ms per page  (4.6× slower!)

→ SIMD directly affects 24-40% of total conversion time

mcp-janus-converter/
├── package.json
├── README.md
├── LICENSE (MPL 2.0)
├── NOTICE
├── index.js (Unified MCP Server)
├── binding.gyp (Multi-target build)
├── src/
│   ├── pdf2tiff/
│   │   ├── addon.c (N-API wrapper)
│   │   ├── pdf_parser.c (Custom PDF parser)
│   │   ├── pdf_parser.h
│   │   ├── pdf2tiff.c (TIFF generation)
│   │   └── pdf2tiff.h
│   └── tiff2pdf/
│       ├── addon.c (N-API wrapper)
│       ├── tiff_parser.c (TIFF metadata parser)
│       ├── tiff2pdf.c (PDF generation)
│       └── tiff2pdf.h
└── build/Release/
    ├── pdf2tiff.node
    └── tiff2pdf.node

typedef struct {
  napi_async_work work;
  napi_deferred deferred;

  /* Input parameters */
  char source_path[4096];
  char target_path[4096];
  int verbose;

  /* Output results */
  int result_code;
  int page_count;
  char error_message[256];
} ConvertAsyncData;

# Clean build
npm run clean

# Build native addons
npm run build

# Rebuild (clean + build)
npm install

# Test PDF → TIFF conversion
node -e "
const pdf2tiff = require('./build/Release/pdf2tiff.node');
(async () => {
  const result = await pdf2tiff.ConvertAsync('input.pdf', 'output.tif', false);
  console.log(result);
})();
"

# Test TIFF → PDF conversion
node -e "
const tiff2pdf = require('./build/Release/tiff2pdf.node');
(async () => {
  const result = await tiff2pdf.ConvertAsync('input.tif', 'output.pdf', 0);
  console.log(result);
})();
"

# Enable verbose output
node index.js --verbose

# Check native addon loading
node -e "
const pdf2tiff = require('./build/Release/pdf2tiff.node');
const tiff2pdf = require('./build/Release/tiff2pdf.node');
console.log('pdf2tiff version:', pdf2tiff.GetVersion());
console.log('tiff2pdf version:', tiff2pdf.GetVersion());
"

npm run build

# 1. Install libtiff if not already installed
sudo apt-get install libtiff-dev  # Ubuntu/Debian
# or
sudo dnf install libtiff-devel    # RHEL/Fedora

# 2. Find libtiff.so.6 location
find /usr -name "libtiff.so.6*" 2>/dev/null
# Example output: /usr/lib/x86_64-linux-gnu/libtiff.so.6

# 3. Create symlink for libtiff.so.5
sudo ln -s /usr/lib/x86_64-linux-gnu/libtiff.so.6 /usr/lib/x86_64-linux-gnu/libtiff.so.5

# 4. Update library cache
sudo ldconfig

# 5. Verify symlink
ls -la /usr/lib/x86_64-linux-gnu/libtiff.so.5
# Should show: libtiff.so.5 -> libtiff.so.6

# Set library path without creating system symlink
export LD_LIBRARY_PATH=/usr/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH