shithub: jbig2

ref: 678523a15572456b68612fafc422d4dee29ca59c
dir: /jbig2dec.c/

View raw version
/*
    jbig2dec
    
    Copyright (c) 2001 artofcode LLC.
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    $Id: jbig2dec.c,v 1.9 2001/06/26 00:30:00 giles Exp $
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "jbig2dec.h"

typedef struct _Jbig2SegmentHeader Jbig2SegmentHeader;
typedef struct _Jbig2SymbolDictionary Jbig2SymbolDictionary;
typedef struct _Jbig2PageInfo Jbig2PageInfo;

/* our main 'context' structure for decoding a jbig2 bitstream */
struct _Jbig2Ctx {
  FILE *f;
  int offset;
  
  int32 n_pages;
  byte flags;
};

/* useful masks for parsing the flags field */
#define JBIG2_FILE_FLAGS_SEQUENTIAL_ACCESS	0x01
#define JBIG2_FILE_FLAGS_PAGECOUNT_UNKNOWN	0x02


struct _Jbig2SegmentHeader {
  int32 segment_number;
  byte flags;
  int referred_to_segment_count;
  int32 page_association;
  int data_length;
};

struct _Jbig2SymbolDictionary {
  int16 flags;
  int8 SDAT_flags[8];
  byte SDRAT_flags[4];
  int32 SDNUMEXSYMS;
  int32 SDNUMNEWSYMS;
};

struct _Jbig2PageInfo {
	int32	height, width;	/* in pixels */
	int32	x_resolution,
			y_resolution;	/* in pixels per meter */
	int16	stripe_size;
	bool	striped;
	byte	flags;
};

int32
get_bytes (Jbig2Ctx *ctx, byte *buf, int size, int off)
{
  fseek (ctx->f, off, SEEK_SET);
  return fread (buf, 1, size, ctx->f);
}

int16
get_int16 (Jbig2Ctx *ctx, int off)
{
  byte buf[2];

  get_bytes (ctx, buf, 2, off);
  return (buf[0] << 8) | buf[1];
}

byte
get_byte (Jbig2Ctx *ctx, int off)
{
  byte buf;
  
  get_bytes (ctx, &buf, 1, off);
  return buf;
}

int32
get_int32 (Jbig2Ctx *ctx, int off)
{
  byte buf[4];

  get_bytes (ctx, buf, 4, off);
  return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}

static Jbig2Ctx *
jbig2_open (FILE *f)
{
  byte buf[9];
  const byte header[8] = { 0x97, 0x4a, 0x42, 0x32, 0x0d, 0x0a, 0x1a, 0x0a };
  Jbig2Ctx *ctx;

  /* Annex D.4 */
  ctx = (Jbig2Ctx *)malloc (sizeof(Jbig2Ctx));
  ctx->f = f;
  get_bytes (ctx, buf, 9, 0);
  if (memcmp (buf, header, 8))
    {
      printf ("not a JBIG2 file\n");
      return NULL;
    }
  ctx->flags = buf[8];
  if (ctx->flags & JBIG2_FILE_FLAGS_PAGECOUNT_UNKNOWN)
    {
      ctx->offset = 9;	/* number of pages unknown */
	  ctx->n_pages = 0;
    }
  else
    {
      ctx->offset = 13;
      ctx->n_pages = get_int32 (ctx, 9);
	}
  
  if(!ctx->flags & JBIG2_FILE_FLAGS_SEQUENTIAL_ACCESS) {
	printf("warning: random access header organization.\n");
	printf("we don't handle that yet.\n");
	free(ctx);
	return NULL;
  }
	
  return ctx;
}

static Jbig2SegmentHeader *
jbig2_read_segment_header (Jbig2Ctx *ctx)
{
  Jbig2SegmentHeader *result = (Jbig2SegmentHeader *)malloc(sizeof(Jbig2SegmentHeader));
  int	offset = ctx->offset;
  byte	rtscarf;
  int32	rtscarf_long;
  int	referred_to_segment_count;

  /* 7.2.2 */
  result->segment_number = get_int32 (ctx, offset);

  /* 7.2.3 */
  get_bytes (ctx, &result->flags, 1, offset + 4);

  /* 7.2.4 */
  get_bytes (ctx, &rtscarf, 1, offset + 5);
  if ((rtscarf & 0xe0) == 0xe0)
    {
		/* FIXME: we break on non-seekable streams with this,
		   but for now it's shorter */
		rtscarf_long = get_int32(ctx, offset + 5);
		referred_to_segment_count = (rtscarf_long & 0x1ffffffc) >> 2;
		offset += 5 + 4 + (referred_to_segment_count + 1)/8;
	}
  else
    {
      referred_to_segment_count = (rtscarf >> 5);
      offset += 6 + referred_to_segment_count;
    }
  result->referred_to_segment_count = referred_to_segment_count;
  /* todo: read referred to segment numbers */

  /* 7.2.6 */
  if (result->flags & 0x40) {
	result->page_association = get_int32(ctx, offset);
	offset += 4;
  } else {
	byte spa;
	get_bytes (ctx, &spa, 1, offset);
	result->page_association = spa;
	offset += 1;
  }
  
  /* 7.2.7 */
  result->data_length = get_int32 (ctx, offset);
  ctx->offset = offset + 4;

  return result;
}

/* parse the symbol dictionary starting at ctx->offset
   a pointer to a new Jbig2SymbolDictionary struct is returned

   the ctx->offset pointer is not advanced; the caller must
   take care of that, using the data_length field of the
   segment header.
*/
static Jbig2SymbolDictionary *
jbig2_read_symbol_dictionary (Jbig2Ctx *ctx)
{
  Jbig2SymbolDictionary *result = (Jbig2SymbolDictionary *)malloc(sizeof(Jbig2SymbolDictionary));
  int offset = ctx->offset;
  bool SDHUFF, SDREFAGG, SDRTEMPLATE;
  int sdat_bytes;

  /* 7.4.2.1.1 */
  result->flags = get_int16 (ctx, offset);
  offset += 2;

  SDHUFF = result->flags & 1;
  SDREFAGG = (result->flags >> 1) & 1;
  SDRTEMPLATE = (result->flags >> 12) & 1;

  /* FIXME: there are quite a few of these conditions to check */
  /* maybe #ifdef CONFORMANCE and a separate routine */
  if(!SDHUFF && !(result->flags & 0x0006)) {
	printf("warning: SDHUFF is zero, but contrary to spec SDHUFFDH is not.\n");
  }
  if(!SDHUFF && !(result->flags & 0x0018)) {
	printf("warning: SDHUFF is zero, but contrary to spec SDHUFFDW is not.\n");
  }

  /* 7.4.2.1.2 - Symbol dictionary AT flags */
  if (!SDHUFF)
    {
      int SDTEMPLATE = (result->flags >> 10) & 3;
      if (SDTEMPLATE == 0)
	sdat_bytes = 8;
      else
	sdat_bytes = 2;
    }
  else
    sdat_bytes = 0;
  get_bytes (ctx, result->SDAT_flags, sdat_bytes, offset);
  memset (&result->SDAT_flags + sdat_bytes, 0, 8 - sdat_bytes);
  offset += sdat_bytes;

  /* 7.4.2.1.3 - Symbol dictionary refinement AT flags */
  if (SDREFAGG && !SDRTEMPLATE)
    {
      get_bytes (ctx, result->SDRAT_flags, 4, offset);
      offset += 4;
    }

  /* 7.4.2.1.4 */
  result->SDNUMEXSYMS = get_int32 (ctx, offset);

  /* 7.4.2.1.5 */
  result->SDNUMNEWSYMS = get_int32 (ctx, offset + 4);
  offset += 8;

  /* hardwire for the first annex-h example */
  
  return result;
}

/* parse the page info segment data starting at ctx->offset
   a pointer to a new Jbig2PageInfo struct is returned

   the ctx->offset pointer is not advanced; the caller must
   take care of that, using the data_length field of the
   segment header.
*/
static Jbig2PageInfo *
jbig2_read_page_info (Jbig2Ctx *ctx) {
  Jbig2PageInfo *info = (Jbig2PageInfo *)malloc(sizeof(Jbig2PageInfo));
  int offset = ctx->offset;

	if (info == NULL) {
		printf("unable to allocate memory to parse page info segment\n");
		return NULL;
	}
	
	info->width = get_int32(ctx, offset);
	info->height = get_int32(ctx, offset + 4);
	offset += 8;
	
	info->x_resolution = get_int32(ctx, offset);
	info->y_resolution = get_int32(ctx, offset);
	offset += 8;
	
	get_bytes(ctx, &(info->flags), 1, offset++);
	
	{
	int16 striping = get_int16(ctx, offset);
	if (striping & 0x8000) {
		info->striped = TRUE;
		info->stripe_size = striping & 0x7FFF;
	} else {
		info->striped = FALSE;
		info->stripe_size = 0;	/* would info->height be better? */
	}
	offset += 2;
	}
	
	return info;
}

static void
dump_symbol_dictionary (Jbig2SymbolDictionary *sd)
{
  printf ("symbol dictionary: flags = %04x, %d new symbols, %d exported\n",
	  sd->flags, sd->SDNUMNEWSYMS, sd->SDNUMEXSYMS);
}

static void
dump_page_info(Jbig2PageInfo *info)
{
	printf("image is %dx%d ", info->width, info->height);
	if (info->x_resolution == 0) {
		printf("(unknown res) ");
	} else if (info->x_resolution == info->y_resolution) {
		printf("(%d ppm) ", info->x_resolution);
	} else {
		printf("(%dx%d ppm) ", info->x_resolution, info->y_resolution);
	}
	if (info->striped) {
		printf("\tmaximum stripe size: %d\n", info->stripe_size);
	} else {
		printf("\tno striping\n");
	}
}

static bool
dump_segment (Jbig2Ctx *ctx)
{
  Jbig2SegmentHeader *sh;
  Jbig2SymbolDictionary *sd;
  Jbig2PageInfo	*page_info;

  sh = jbig2_read_segment_header (ctx);
  
  printf("segment %d (%d bytes)\t", sh->segment_number, sh->data_length);
  switch (sh->flags & 63)
    {
    case 0:
      sd = jbig2_read_symbol_dictionary (ctx);
	  printf("\n");
      dump_symbol_dictionary (sd);
      break;
	case 4:
		printf("intermediate text region:");
		break;
	case 6:
		printf("immediate text region:");
		break;
	case 7:
		printf("immediate lossless text region:");
		break;
	case 16:
		printf("pattern dictionary:");
		break;
	case 20:
		printf("intermediate halftone region:");
		break;
	case 22:
		printf("immediate halftone region:");
		break;
	case 23:
		printf("immediate lossless halftone region:");
		break;
	case 36:
		printf("intermediate generic region:");
		break;
	case 38:
		printf("immediate generic region:");
		break;
	case 39:
		printf("immediate lossless generic region:");
		break;
	case 40:
		printf("intermediate generic refinement region:");
		break;
	case 42:
		printf("immediate generic refinement region:");
		break;
	case 43:
		printf("immediate lossless generic refinement region:");
		break;
	case 48:
		page_info = jbig2_read_page_info(ctx);
		printf("page info:\n");
		if (page_info) dump_page_info(page_info);
		break;
	case 49:
		printf("end of page");
		break;
	case 50:
		printf("end of stripe");
		break;
    case 51:
      printf ("end of file\n");
      return TRUE;
	  break;
	case 52:
		printf("profiles:");
		break;
	case 53:
		printf("tables:");
		break;
	case 62:
		printf("extension:");
		break;
	default:
		printf("UNKNOWN SEGMENT TYPE!!!");
    }
	printf ("\tflags = %02x, page %d\n",
	  sh->flags, sh->page_association);

  ctx->offset += sh->data_length;
  return FALSE;
}

static void
dump_jbig2 (FILE *f)
{
  Jbig2Ctx *ctx;
  bool last;

  ctx = jbig2_open (f);
  if (!ctx) return;
  
  printf ("Number of pages = %d\n", ctx->n_pages);
  for (;;)
    {
      last = dump_segment (ctx);
      if (last)
	break;
    }
}

int
main (int argc, char **argv)
{
  FILE *f;

  if (argc < 2)
    return -1;
  f = fopen (argv[1], "rb");
  if (f == NULL)
    return -1;

  dump_jbig2 (f);
  fclose (f);
  return 0;
}