encode.c

open arj source

  r_dx&=(r_cx|0xFF);
  for(l=j-2; m<l; m++)
  {
   r_dx<<=(r_cx&0xFF);
   r_dx^=*(tptr++);
   r_dx&=(r_cx|0xFF);
   t=fpbuf[r_dx];
   fpbuf[r_dx]=m;
   dtree[m]=t;
  }
  dtree[m]=-1;
  dtree[m+1]=-1;
  m=tree_el-i;
  i+=fetch;
  while(i>nchars)
  {
   i--;
   pm=m;
   m++;
   n_passes=(unsigned int)tc_passes;
   f_dicpos=(int)dicpos;
   if((r_ax=upd_tree(m))>i)
    r_ax=tc_passes=i;
   if(n_passes<THRESHOLD||n_passes==THRESHOLD&&f_dicpos>16384||--r_ax>n_passes||r_ax==n_passes&&dicpos>>1<f_dicpos)
   {
    output_opt(tree[pm]);
   }
   else
   {
    i-=n_passes-1;
    m+=n_passes-1;
    r_ax=n_passes+UCHAR_MAX-2;
    output(r_ax, f_dicpos);
    upd_tree(m);
    if(tc_passes>i)
     tc_passes=i;
   }
  }
 }
 while(i>0)
 {
  i--;
  pm=m;
  m++;
  n_passes=tc_passes;
  f_dicpos=dicpos;
  if((r_ax=upd_tree(m))>i)
   r_ax=tc_passes=i;
  if(n_passes<THRESHOLD||n_passes==THRESHOLD&&f_dicpos>16384||--r_ax>n_passes||r_ax==n_passes&&dicpos>>1<f_dicpos)
  {
   output_opt(tree[pm]);
  }
  else
  {
   i-=n_passes-1;
   m+=n_passes-1;
   r_ax=n_passes+UCHAR_MAX-2;
   output(r_ax, f_dicpos);
   if((r_ax=upd_tree(m))>i)
    tc_passes=i;
  }
 }
 huf_encode_end();
 #ifdef ASM8086
  farfree_based(ftree);
 #else
  farfree(ftree);
 #endif
 farfree(fpbuf);
 free(tree);
 tree=NULL;
}

/* Encoding stub for -m3 */

static void NEAR huf_encode_m3()
{
 int hash_bits;
 unsigned short fp_max;
 int i, j, m;
 unsigned short t;                      /* Exchange variable */
 short k, l;
 int tree_el;
 unsigned int fetch;
 unsigned char *tptr;
 unsigned short r_cx, r_dx;
 short r_ax;

 hash_bits=(dicbit+2)/3;
 fpcount=1U<<dicbit;
 fp_max=fpcount-1;
 if(tree==NULL)
 {
  if((tree=calloc(treesize+2, sizeof(*tree)))==NULL)
   error(M_OUT_OF_NEAR_MEMORY);
  #ifdef ASM8086
   ftree=farcalloc_based((unsigned long)treesize+16L, sizeof(*ftree));
   dtree=(FP_OFF(ftree)==0)?ftree:MK_FP(FP_SEG(ftree)+((FP_OFF(ftree)+15)>>4), 0);
  #else
   ftree=dtree=farcalloc((unsigned long)treesize+16L, sizeof(*ftree));
  #endif
  fpbuf=farcalloc((unsigned long)fpcount+4L, 2L);
  if(ftree==NULL||fpbuf==NULL)
   error(M_OUT_OF_MEMORY);
 }
 allocate_memory();
 display_indicator(encoded_bytes=0L);
 j=0;
 while(!unpackable)
 {
  tree_el=0;
  if(dic_alloc!=0&&j!=0)
  {
   tree_el=dic_alloc;
   if((k=j-tree_el)<=0)
   {
    k=0;
    tree_el=j;
   }
   else
    memmove(tree, tree+k, tree_el);
  }
  fetch=(unsigned int)(treesize-tree_el);
  if(multivolume_option)
   fetch=check_multivolume(fetch);
  if((fetch=fetch_uncomp(tree+tree_el, fetch))==0)
   break;
  else
  {
   j=fetch+tree_el;
   encoded_bytes+=(unsigned long)fetch;
   display_indicator(encoded_bytes);
   fill_fpbuf();
   l=fetch;
   tptr=tree;
   r_dx=(unsigned short)*(tptr++);
   r_cx=(fp_max&0xFF00)|(hash_bits&0xFF);
   r_dx<<=(hash_bits&0xFF);
   r_dx^=(unsigned short)*(tptr++);
   r_dx&=(r_cx|0xFF);
   for(m=0; m<j; m++)
   {
    r_dx<<=(r_cx&0xFF);
    r_dx^=*(tptr++);
    r_dx&=(r_cx|0xFF);
    t=fpbuf[r_dx];
    fpbuf[r_dx]=m;
    dtree[m]=t;
   }
   i=l;
   m=tree_el;
   while(i>0)
   {
    r_ax=upd_tree(m);
    if((r_ax=upd_tree(m))>i)
     r_ax=tc_passes=i;
    if(r_ax<THRESHOLD)
    {
     r_ax=(unsigned short)tree[m];
     output(r_ax, 0);
     m++;
     i--;
    }
    else
    {
     r_ax+=UCHAR_MAX-2;
     output(r_ax, dicpos);
     m+=tc_passes;
     i-=tc_passes;
    }
   }
  }
 }
 huf_encode_end();
 #ifdef ASM8086
  farfree_based(ftree);
 #else
  farfree(ftree);
 #endif
 farfree(fpbuf);
 free(tree);
 tree=NULL;
}

/* Encodes a single file. */

void encode(int method)
{
 char *dsw;                             /* Debug switch (-hd) pointer */
 char a;

 numchars=UCHAR_MAX+5;
 dicbit=14;
 dic_alloc=DICSIZ;
 treesize=31744;
 dicsiz_cur=DICSIZ-2;
 adjust_dicbit();
 /* Method 0 (store) is already filtered away at this point */
 switch(method)
 {
  case 1:
   numchars=UCHAR_MAX+5;
   break;
  case 2:
   treesize=30720;
   numchars=72;
   dic_alloc=20480;
   break;
  case 3:
   treesize=30720;
   numchars=32;
   dic_alloc=8192;
   break;
  default:
   error(M_UNKNOWN_METHOD);
 }
 switch(max_compression)
 {
  case 1:
   numchars=3000;
   dic_alloc=DICSIZ+512;
   break;
  case 2:
   numchars=512;
   dic_alloc=DICSIZ+512;
   break;
  case 3:
   numchars=1024;
   dicbit=12;
   treesize=20480;
   dicsiz_cur=dic_alloc=16384;
   break;
  case 4:
   numchars=1024;
   dicbit=12;
   treesize=12288;
   dicsiz_cur=dic_alloc=8192;
 }
 if(debug_enabled)
 {
  dsw=debug_opt;
  while(*dsw!='\0')
  {
   a=*(dsw++);
   switch(a)
   {
    case 'd':                           /* Dictionary size */
     dicsiz_cur=(unsigned int)strtol(dsw, &dsw, 10);
     break;
    case 'g':                           /* G-size */
     dic_alloc=(int)strtol(dsw, &dsw, 10);
     break;
    case 'h':
     dicbit=(int)strtol(dsw, &dsw, 10);
     break;
    case 'm':
     numchars=(int)strtol(dsw, &dsw, 10);
     break;
    case 'w':
     treesize=(int)strtol(dsw, &dsw, 10);
     break;
   }
  }
  if(strchr(debug_opt, 'v')!=NULL)
   msg_cprintf(0, M_PRECOMP_STAT, numchars, dicbit, dicsiz_cur, dic_alloc, treesize);
 }
 if(dicsiz_cur>DICSIZ_MAX)
  error(M_LARGE_DICTIONARY);
 if(dic_alloc>treesize)
  error(M_LARGE_GSIZE);
 if(method==3)
  huf_encode_m3();
 else
  huf_encode();
}

/* Fast search stub for method 4 */

static void enc4_pass1(int n_c)
{
 #ifdef ASM8086
  asm{
                mov     dx, n_c
                mov     bx, 1
                mov     cx, 0
                cmp     dx, bx
                jl      cease_search
  }
binsearch:
  asm{
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      cease_search
                jmp     binsearch
  }
cease_search:
  asm{
                or      cx, cx
                jz      chk_ctr_bounds
                push    dx
                push    cx
                mov     ax, 65535
                push    ax
                push    cx
                call    far ptr putbits
                add     sp, 4
                pop     cx
                pop     dx
  }
chk_ctr_bounds:
  asm{
                cmp     cx, 7
                jge     p1exit
                inc     cx
  }
p1exit:
  asm{
                push    dx
                push    cx
                call    far ptr putbits
                add     sp, 4
  }
 #else
  short r_bx=1;
  int r_cx=0;

  while(n_c>=r_bx)
  {
   n_c-=r_bx;
   r_cx++;
   r_bx<<=1;
  }
  if(r_cx!=0)
   putbits(r_cx, -1);
  if(r_cx<7)
   r_cx++;
  putbits(r_cx, n_c);
 #endif
}

/* Dictionary position lookup */

static void enc4_pass2(int n_c)
{
 #ifdef ASM8086
  asm{
                mov     dx, n_c
                mov     bx, 512
                mov     cx, 9
                cmp     dx, bx
                jl      p2_cease_search
  }
p2_bsearch:
  asm{
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      p2_cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      p2_cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      p2_cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jl      p2_cease_search
                sub     dx, bx
                inc     cx
                shl     bx, 1
                cmp     dx, bx
                jge     p2_bsearch
  }
p2_cease_search:
  asm{
                mov     ch, cl
                sub     cl, 9
                jz      p2_chk_ctr
                push    cx
                push    dx
                mov     ax, 65535
                push    ax
                push    cx
                call    far ptr putbits
                add     sp, 4
                pop     dx
                pop     cx
  }
p2_chk_ctr:
  asm{
                cmp     ch, 13
                jge     p2exit
                inc     ch
  }
p2exit:
  asm{
                mov     cl, ch
                push    dx
                push    cx
                call    far ptr putbits
                add     sp, 4
  }
 #else
  unsigned short r_bx=1<<9;
  int r_cx=9;

  while(n_c>=r_bx)
  {
   n_c-=r_bx;
   r_cx++;
   r_bx<<=1;
  }
  if(r_cx!=9)
   putbits(r_cx-9, -1);
  if(r_cx<13)
   r_cx++;
  putbits(r_cx, n_c);
 #endif
}

/* Encodes a single file, using method 4 */

void encode_f()
{
 int fetch;
 int hash_bits;
 unsigned short fp_max;
 unsigned char *tptr;
 int i, m;
 unsigned short r_cx, r_dx, r_ax;
 unsigned short t;

 dicbit=14;
 numchars=32;
 dicsiz_cur=15800;
 treesize=30720;
 adjust_dicbit();
 hash_bits=(dicbit+2)/3;
 fpcount=1U<<dicbit;
 fp_max=fpcount-1;
 if(tree==NULL)
 {
  if((tree=calloc(treesize+2, sizeof(*tree)))==NULL)
   error(M_OUT_OF_NEAR_MEMORY);
  #ifdef ASM8086
   ftree=farcalloc_based((unsigned long)treesize+16L, sizeof(*ftree));
   dtree=(FP_OFF(ftree)==0)?ftree:MK_FP(FP_SEG(ftree)+((FP_OFF(ftree)+15)>>4), 0);
  #else
   ftree=dtree=farcalloc((unsigned long)treesize+16L, sizeof(*ftree));
  #endif
  fpbuf=farcalloc((unsigned long)fpcount+4L, 2L);
  if(ftree==NULL||fpbuf==NULL)
   error(M_OUT_OF_MEMORY);
 }
 init_putbits();
 cpos=0;
 display_indicator(encoded_bytes=0L);
 while(!unpackable)
 {
  fetch=treesize;
  if(multivolume_option)
   fetch=check_multivolume(fetch);
  if((fetch=fetch_uncomp(tree, fetch))==0)
   break;
  encoded_bytes+=(unsigned long)fetch;
  display_indicator(encoded_bytes);
  fill_fpbuf();
  m=0;
  tptr=tree;
  r_dx=(unsigned short)*(tptr++);
  r_cx=(fp_max&0xFF00)|(hash_bits&0xFF);
  r_dx<<=(hash_bits&0xFF);
  r_dx^=(unsigned short)*(tptr++);
  r_dx&=(r_cx|0xFF);
  for(m=0; m<fetch; m++)
  {
   r_dx<<=(r_cx&0xFF);
   r_dx^=(unsigned char)*(tptr++);
   r_dx&=(r_cx|0xFF);
   t=fpbuf[r_dx];
   fpbuf[r_dx]=m;
   dtree[m]=t;
  }
  m=0;
  i=fetch;
  while(i>0)
  {
   if((r_ax=upd_tree(m))>i)
    r_ax=tc_passes=i;
   if(r_ax<THRESHOLD)
   {
    putbits(9, (unsigned char)tree[m]);
    i--;
    m++;
   }
   else
   {
    i-=tc_passes;
    m+=tc_passes;
    r_ax=tc_passes-2;
    enc4_pass1(r_ax);
    enc4_pass2(dicpos);
   }
  }
 }
 shutdown_putbits();
 farfree(fpbuf);
 #ifdef ASM8086
  farfree_based(ftree);
 #else
  farfree(ftree);
 #endif
 free(tree);
 tree=NULL;
}