typedef struct DataStrAgent {
  char const *(*Close)(DataStr *, unsigned);

  int (*GetPos)(DataStr *);
  unsigned (*SetPos)(DataStr *, unsigned long);
 
 This is an optional method. It is not used in the Rapid Deployment API.
  int (*GetLen)(DataStr *); 

  int (*Read)(DataStr *, void *, unsigned long);
  int (*Write)(DataStr *,  void *, unsigned long);
 
 This is an optional method.
  void (*OnErrorChange)(DataStr *);
}DataStrAgent;

struct DataStr {
    DataStrAgent const *agent; 
    unsigned char normalizeValues, 
      exceptionsEnabled, errorIsHard;
    char const *error;
};

static void SetError(DataStr *str, char const *dfltMsg) 
{ 
  FILE *fp = SubClass(str)->fp; 
  if(ferror(fp) && errno < sys_nerr) {
    dfltMsg = sys_errlist[errno];
  }
  strSetError(str, dfltMsg, 0);
}

static int GetPos_File(DataStr *str) 
{ 
  return ftell(SubClass(str)->fp);
}

static unsigned 
SetPos_File(DataStr *str, unsigned long pos)
{
  FILE *fp = SubClass(str)->fp;
  unsigned worked = !fseek(fp, pos, SEEK_SET);
  if(!worked) { SetError(str, "Seek error"); }
  return worked;
}

static int 
Read_File(DataStr *str, void *buf, unsigned long cnt)
{
 
 fread returns a short count on an error or end-of-file.
  We use ferror to disambiguate the two cases.
  FILE *fp = SubClass(str)->fp;
  size_t numRead = fread(buf, 1, cnt, fp);
  if(numRead==cnt || !ferror(fp)) { 
    return numRead; 
  }
 
 Set the error state of the stream.
  SetError(str, "fread error");
  return -1;
}

static int 
Write_File(DataStr *str, void *buf, unsigned long cnt)
{
 
 We always consider a short write to be an error.
  FILE *fp = SubClass(str)->fp;
  size_t numWritten = fwrite(buf, 1, cnt, fp);
  if(numWritten == cnt) { 
    return numWritten; 
  }
 
 Set the error state of the stream.
  SetError(str, "fwrite error");
  return  -1;
}

static char const *
Close_File(DataStr *str, unsigned closeFp)
{
 
 Flush the file and latch any final error.
  char const *err;
  FILE *fp = SubClass(str)->fp;
  if(fflush(fp)) { SetError(str, "fflush error"); }
 
 Close the file if requested.
  if(closeFp) { fclose(fp); }
 
 Deallocate the str (which we allocated in fileStr_open).
  err = strGetError(str);
  free(str);
  return err;
}

static const DataStrAgent Agent_File = { 
  Close_File, GetPos_File, SetPos_File,
  0, // Optional method: GetLen
  Read_File, Write_File,
  0, // Optional method: OnErrorChange
};

DataStr *fileStr_open(FILE *fp)
{       
  FileStr *str;
 
 Fail if the file is invalid.
  if(!fp) { return 0; }
 
 Allocate a new FileStr.
  str = malloc(sizeof(*str));
  if(!str) { return 0; }
 
 Initialize the generic portion.
  strInit(&str->gen, &Agent_File);
 
 Attach it to the file and return the generic pointer.
  str->fp = fp;
  return &str->gen;
}

static CpcDecoder *OpenDecoder(char const *name)
{
 
 Open the source file and attach it to a File Stream. If
  we are unable to open the Stream, give up.
  CpcDecoder *cpc;
  DataStr *str = fileStr_open(fopen(name, "rb"));
  if(!str) { 
    fprintf(stderr, "Unable to open <%s>\n", name); 
    return 0; 
  }
 
 Check for a CPC signature. (This is not really necessary, since the
    CpcDecoder would detect the error.)
  if(!cpcDec_checkSignature(str)) { 
    fprintf(stderr, "<%s> does not contain CPC data\n", 
      name);
    strClose(str, 1/*closeInput*/);
    return 0;
  }
 
 Create the CPC decoder, using the File Stream as
  the data source.
  cpc = cpcDec_createFromStream(str, 1 /*sequential*/);
  if(!cpc) { 
    fprintf(stderr, "Unable to create CPC decoder\n"); 
    strClose(str, 1/*closeInput*/);
    return 0;
  }
  return cpc;
}

static CpcEncoder *OpenEncoder(char const *name)
{
 
 Create the output file and attach it to a File Stream. If
  we are unable to open the Stream, give up.
  CpcEncoder *cpc;
  DataStr *str = fileStr_open(fopen(name, "wb"));
  if(!str) { 
    fprintf(stderr, "Unable to create <%s>\n", name); 
    return 0; 
  }
 
 Create the CPC encoder, using the File Stream as the data sink.
  cpc = cpcEnc_createFromStream(str, 1/*CPC-Progressive*/);
  if(!cpc) { 
    fprintf(stderr, "Unable to create CPC encoder\n"); 
    strClose(str, 1/*closeOutput*/);
    return 0;
  }
  return cpc;
}

int main(int argc, char **argv)
{
  CpcEncoder *encoder; CpcDecoder *decoder; 
  char const *err; unsigned long i;
 
 There must be exactly two arguments.
  if(argc != 3) { 
    fprintf(stderr, 
      "Usage: %s <inCpcFile> <outCpcFile>\n", 
      argv[0]); 
    return -1; 
  }
 
 Open the encoder and decoder. If either fails, give up.
  decoder = OpenDecoder(argv[1]);
  encoder = OpenEncoder(argv[2]);
  if(!decoder || !encoder) { return -1; }
 
 Iterate over the pages in the input document.
  for(i=0; i<cpcDec_getPageCount(decoder); i++) {
   
 Retrieve the page from the decoder.
    ImBitMap *ibm = cpcDec_getPage(decoder, i);
    if(!ibm) { 
      fprintf(stderr, "Get Page %ld failed (%s)\n", 
        i+1, cpcDec_getError(decoder)); 
      return -1; 
    }
   
 Add the page to the encoder.
    cpcEnc_addPage(encoder, ibm);
   
 Destroy the page.
    ibm_destroy(ibm);
  }
 
 Destroy the decoder, checking for errors.
  err = cpcDec_destroy(decoder, 1/*close stream*/);
  if(err) { 
    fprintf(stderr, "Cpc decoder error: <%s>\n", err); 
    return -1; 
  }
 
 Destroy the encoder, checking for errors.
  err = cpcEnc_destroy(encoder, 1/*close stream*/);
  if(err) { 
    fprintf(stderr, "Cpc encoder error: <%s>\n", err); 
    return -1; 
  }
  return 0;
}