/*
* testfax_main.c -- CCITTFax(En|De)code usage sample
* by [email protected] at Sat Jul  6 20:03:35 CEST 2002
* Sun Jul  7 22:25:55 CEST 2002
*
* Note that this sample is incomplete since the parameters (such as /K)
* cannot be set from the command line.
*/

#include "pts_fax.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>

#ifdef __GNUC__
#ifndef __clang__
#pragma implementation
#endif
#endif

#if OBJDEP
#  warning PROVIDES: testfax_main
#endif

static void* gsfax_xalloc(unsigned n) {
 void *ret;
 if ((ret=malloc(n))==0) abort();
 return ret;
}
static void gsfax_free(void *ptr) {
 free(ptr);
}
static void gsfax_memset(void *s, int c, unsigned n) {
 /*return*/ memset(s,c,n);
}
static void gsfax_memcpy(void *dest, const void *src, unsigned n) {
 /*return*/ memcpy(dest, src, n);
}



#if 0
CCITTFaxEncode:

bool Uncompressed=false;
int  K=0;
bool EndOfLine=false;
bool EncodedByteAlign=false;
int  Columns=1728;
int  Rows=0; // Decode only
bool EndOfBlock=true;
bool BlackIs1=false;
int  DamagedRowsBeforeError=0; // Decode only
bool FirstBitLowOrder=false; // GS only
int  DecodedByteAlign=1; // GS only
bool CloseSource;
bool CloseTarget;
#endif

/* GS expected
* min_left=0
* bits_left=32
*
*/

static void work(FILE *f, stream_template const*template_, stream_state *state) {
 unsigned got, pog;
 stream_cursor_read r;
 stream_cursor_write w;
 unsigned char rbuf[4096], wbuf[1000], *hard, *rlimit;
 bool last;

 #if __CHECKER__
   memset(&r, 0, sizeof(r));
   memset(&w, 0, sizeof(w));
 #endif

 template_->init(state);

 r.ptr=rlimit=rbuf-1;
 hard=rbuf+sizeof(rbuf)-1;
 assert(hard-r.ptr>=(int)template_->min_in_size);
 last=false;


 while (1) {
   assert(r.ptr==rbuf-1);
   if (last==false) {
     if (0==(got=fread(rlimit+1, 1, hard-rlimit, f))) last=true;
     rlimit+=got;
   }
   /* if (r.ptr==rlimit) break; */
   w.ptr=wbuf-1;
   w.limit=wbuf+sizeof(wbuf)-1;
   assert(w.limit-w.ptr>=(int)template_->min_out_size);
   r.limit=rlimit;
   pog=template_->process(state, &r, &w, last);
   fprintf(stderr, "pog=%d write=%d last=%d\n", pog, w.ptr-(wbuf-1), last);
   if ((int)pog==PTSFAX_ERRC) {
     fprintf(stderr, "syntax error!\n");
     abort();
   }
   /* assert(last || r.ptr>=rbuf); */
   fwrite(wbuf, 1, w.ptr-(wbuf-1), stdout);
   if (last && (pog==0 || (int)pog==PTSFAX_EOFC)) break;
   if (r.ptr!=rbuf-1) {
     fprintf(stderr, "limit=%d\n", rlimit-r.ptr);
     memmove(rbuf, r.ptr+1, rlimit-r.ptr);
     rlimit=rbuf-1+(rlimit-r.ptr);
     r.ptr=rbuf-1;
   }
 }

 template_->release(state);
}

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

 (void)argc;
 (void)argv;
/*
-* Define a limit on the Rows parameter, close to max_int. *-
#define cf_max_height 32000
   if (code >= 0 &&
       (state.K < -cf_max_height || state.K > cf_max_height ||
        state.Columns < 0 || state.Columns > cfe_max_width ||
        state.Rows < 0 || state.Rows > cf_max_height ||
        state.DamagedRowsBeforeError < 0 ||
        state.DamagedRowsBeforeError > cf_max_height ||
        state.DecodedByteAlign < 1 || state.DecodedByteAlign > 16 ||
        (state.DecodedByteAlign & (state.DecodedByteAlign - 1)) != 0)
       )
*/

 f=stdin;
 /* f=fopen("stdpre.x","rb"); */
 /* f=fopen("216","rb"); */
 assert(f!=0);

 if (0) {
 #if USE_BUILTIN_FAXE
 #if OBJDEP
 #  warning REQUIRES: pts_faxe
 #endif
 } else if (argc==2 && 0==strcmp(argv[1], "encode")) {
   stream_CFE_state sCFEs;
   sCFEs.memset_=gsfax_memset;
   sCFEs.xalloc_=gsfax_xalloc;
   sCFEs.free_=gsfax_free;
   sCFEs.memcpy_=gsfax_memcpy;
   s_CFE_template.set_defaults((stream_state*)&sCFEs);
   /* sCFEs.K=-1; ... */
   work(f, (stream_template const*)&s_CFE_template, (stream_state*)&sCFEs);
 #endif
 #if USE_BUILTIN_FAXD
 #if OBJDEP
 #  warning REQUIRES: pts_faxd
 #endif
 } else if (argc==2 && 0==strcmp(argv[1], "decode")) {
   stream_CFD_state sCFDs;
   sCFDs.memset_=gsfax_memset;
   sCFDs.xalloc_=gsfax_xalloc;
   sCFDs.free_=gsfax_free;
   sCFDs.memcpy_=gsfax_memcpy;
   s_CFD_template.set_defaults((stream_state*)&sCFDs);
   /* sCFEs.K=-1; ... */
   work(f, (stream_template const*)&s_CFD_template, (stream_state*)&sCFDs);
 #endif
 } else {
   fprintf(stderr, "Usage: %s encode|decode <INFILE >OUTFILE\n", argv[0]);
   return 2;
 }
 fclose(f);

 return 0;
}