borro el archivo temporal cuando no lo uso mas.

[z.facultad/75.06/jacu.git] / src / ppmc / ppmc.c

diff --git a/src/ppmc/ppmc.c b/src/ppmc/ppmc.c
index cd7f63c9964891c4baadd86803bc1542f2c727a3..91e448f08434dcd0ed813b392c7e08dfe5cfec1a 100644 (file)
--- a/src/ppmc/ppmc.c
+++ b/src/ppmc/ppmc.c
@@ -47,49 +47,49 @@
 // initialized now.
 void ppmc_alloc_memory(void)
 {
 // initialized now.
 void ppmc_alloc_memory(void)
 {

- unsigned long counter;
+       unsigned long counter;

 
 
 
 

- // Init mempool buffers
+       // Init mempool buffers

 
 

- for(counter=0;counter!=_mempool_max_index;++counter)
-   {
-   _bytes_pool_array[counter]=0;
-   _context_pool_array[counter]=0;
-   }
+       for(counter=0;counter!=_mempool_max_index;++counter)
+       {
+               _bytes_pool_array[counter]=0;
+               _context_pool_array[counter]=0;
+       }

 
 

- _bytes_pool_index=1;   //first entry will be used now
- _context_pool_index=1;
+       _bytes_pool_index=1;   //first entry will be used now
+       _context_pool_index=1;

 
 
 
 

- // Allocate memory for ppmc structures and adjust some variables
- if((_bytes_pool=(struct _byte_and_freq *)malloc
-   (sizeof(struct _byte_and_freq)*_bytes_pool_elements))==NULL)
-   {
-   printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-   ppmc_out_of_memory=1;    //flush
-   return;
-   }
+       // Allocate memory for ppmc structures and adjust some variables
+       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements))==NULL)
+       {
+               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+               ppmc_out_of_memory=1;    //flush
+               return;
+       }

 
 

- if((_context_pool=(struct context *)malloc
-   (sizeof(struct context)*_context_pool_elements))==NULL)
-   {
-   printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-   ppmc_out_of_memory=1;    //flush
-   return;
-   }
+       if((_context_pool=(struct context *)malloc
+                               (sizeof(struct context)*_context_pool_elements))==NULL)
+       {
+               printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+               ppmc_out_of_memory=1;    //flush
+               return;
+       }

 
 
 
 

- //save pointers in the array for freeing
- _bytes_pool_array[0]=_bytes_pool;
- _context_pool_array[0]=_context_pool;
+       //save pointers in the array for freeing
+       _bytes_pool_array[0]=_bytes_pool;
+       _context_pool_array[0]=_context_pool;

 
 
 
 

- //adjust variables
- _bytes_pool_max=_bytes_pool+_bytes_pool_elements;
- _context_pool_max=_context_pool+_context_pool_elements;
+       //adjust variables
+       _bytes_pool_max=_bytes_pool+_bytes_pool_elements;
+       _context_pool_max=_context_pool+_context_pool_elements;

 
 

- ppmc_out_of_memory=0;  //we still have memory
+       ppmc_out_of_memory=0;  //we still have memory

 }
 
 
 }
 
 


@@ -97,44 +97,44 @@ void ppmc_alloc_memory(void)
 // those who care about the number of bytes defined in a context.
 void ppmc_initialize_contexts(void)
 {
 // those who care about the number of bytes defined in a context.
 void ppmc_initialize_contexts(void)
 {

- unsigned long counter, counter2;
+       unsigned long counter, counter2;

 
 
 
 

- // Order-0
- for(counter=0;counter!=256;++counter) //clear table
-   order0_array[counter]=0;
+       // Order-0
+       for(counter=0;counter!=256;++counter) //clear table
+               order0_array[counter]=0;

 
 

- order0_defined_bytes=0;       //adjust variables
- order0_max_cump=0;
+       order0_defined_bytes=0;       //adjust variables
+       order0_max_cump=0;

 
 
 
 

- // Order-1
- for(counter=0;counter!=256;++counter)  //erase every table of every context
-   for(counter2=0;counter2!=256;++counter2)
-     order1_array[counter][counter2]=0;
+       // Order-1
+       for(counter=0;counter!=256;++counter)  //erase every table of every context
+               for(counter2=0;counter2!=256;++counter2)
+                       order1_array[counter][counter2]=0;

 
 

- for(counter=0;counter!=256;++counter) //adjust variables
-   {
-   order1_defined_bytes_array[counter]=0;
-   order1_max_cump_array[counter]=0;
-   }
+       for(counter=0;counter!=256;++counter) //adjust variables
+       {
+               order1_defined_bytes_array[counter]=0;
+               order1_max_cump_array[counter]=0;
+       }

 
 
 
 

- // Order-2
- for(counter=0;counter!=65536;++counter)
-   {
-   //order2_array[counter].prob=0;     //clear pointer to bytes and frequencies
-   //order2_array[counter].max_cump=0;
-   order2_array[counter].defined_bytes=0;
-   }
+       // Order-2
+       for(counter=0;counter!=65536;++counter)
+       {
+               //order2_array[counter].prob=0;     //clear pointer to bytes and frequencies
+               //order2_array[counter].max_cump=0;
+               order2_array[counter].defined_bytes=0;
+       }

 
 
 
 

- // Order-4-3
- for(counter=0;counter!=65536;++counter) //order-4-3
-   {
-   order4_hasht[counter]=0;
-   order3_hasht[counter]=0;
-   }
+       // Order-4-3
+       for(counter=0;counter!=65536;++counter) //order-4-3
+       {
+               order4_hasht[counter]=0;
+               order3_hasht[counter]=0;
+       }

 }
 
 
 }
 
 


@@ -146,19 +146,19 @@ void ppmc_initialize_contexts(void)
 void ppmc_encoder_initialize(void)
 {
 
 void ppmc_encoder_initialize(void)
 {
 

- // Initialize order-0 and prepare different bytes for orders
- fputc((byte=fgetc(file_input)),file_output);
- o4_byte=byte;    //order-4
+       // Initialize order-0 and prepare different bytes for orders
+       fputc((byte=fgetc(file_input)),file_output);
+       o4_byte=byte;    //order-4

 
 

- fputc((byte=fgetc(file_input)),file_output);
- o3_byte=byte;    //order-3
+       fputc((byte=fgetc(file_input)),file_output);
+       o3_byte=byte;    //order-3

 
 

- fputc((byte=fgetc(file_input)),file_output);
- o2_byte=byte;    //order-2
- ppmc_update_order0();
+       fputc((byte=fgetc(file_input)),file_output);
+       o2_byte=byte;    //order-2
+       ppmc_update_order0();

 
 

- fputc((byte=fgetc(file_input)),file_output);
- o1_byte=byte;
+       fputc((byte=fgetc(file_input)),file_output);
+       o1_byte=byte;

 
 }
 
 
 }
 


@@ -168,24 +168,24 @@ void ppmc_encoder_initialize(void)
 void ppmc_decoder_initialize(void)
 {
 
 void ppmc_decoder_initialize(void)
 {
 

- // Initialize order-0 and context bytes
- byte=fgetc(file_input);
- o4_byte=byte;    //order-4
- fputc(byte,file_output);
+       // Initialize order-0 and context bytes
+       byte=fgetc(file_input);
+       o4_byte=byte;    //order-4
+       fputc(byte,file_output);

 
 

- byte=fgetc(file_input);
- o3_byte=byte;    //order-3
- fputc(byte,file_output);
+       byte=fgetc(file_input);
+       o3_byte=byte;    //order-3
+       fputc(byte,file_output);

 
 

- byte=fgetc(file_input);
- o2_byte=byte;    //order-2
+       byte=fgetc(file_input);
+       o2_byte=byte;    //order-2

 
 

- fputc(byte,file_output);   //output first byte
- ppmc_update_order0();
+       fputc(byte,file_output);   //output first byte
+       ppmc_update_order0();

 
 

- byte=fgetc(file_input);
- o1_byte=byte;    //order-1
- fputc(byte,file_output);
+       byte=fgetc(file_input);
+       o1_byte=byte;    //order-1
+       fputc(byte,file_output);

 }
 
 
 }
 
 


@@ -193,18 +193,18 @@ void ppmc_decoder_initialize(void)
 // It must be called when done.
 void ppmc_free_memory(void)
 {
 // It must be called when done.
 void ppmc_free_memory(void)
 {

- unsigned long counter;
+       unsigned long counter;

 
 

- // Free the memory buffers
+       // Free the memory buffers

 
 

- for(counter=0;counter!=_mempool_max_index;++counter)
-   {
-   if(_bytes_pool_array[counter]!=0)
-     free(_bytes_pool_array[counter]);
+       for(counter=0;counter!=_mempool_max_index;++counter)
+       {
+               if(_bytes_pool_array[counter]!=0)
+                       free(_bytes_pool_array[counter]);

 
 

-   if(_context_pool_array[counter]!=0)
-     free(_context_pool_array[counter]);
-   }
+               if(_context_pool_array[counter]!=0)
+                       free(_context_pool_array[counter]);
+       }

 
 }
 
 
 }
 


@@ -222,78 +222,78 @@ void ppmc_free_memory(void)
 void ppmc_flush_mem_enc(void)
 {
 
 void ppmc_flush_mem_enc(void)
 {
 

- // Code an escape code in order-4
- if(ppmc_get_totf_order4()!=0)  //if 0 no need of escape code
-   {
+       // Code an escape code in order-4
+       if(ppmc_get_totf_order4()!=0)  //if 0 no need of escape code
+       {

 
 

-   ppmc_get_escape_prob_order4();       //get prob and cump
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order4();       //get prob and cump
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

-   }
+       }

 
 
 
 

- // Code an escape code in order-3
- if(ppmc_get_totf_order3()!=0)  //if 0 no need of escape code
-   {
+       // Code an escape code in order-3
+       if(ppmc_get_totf_order3()!=0)  //if 0 no need of escape code
+       {

 
 

-   ppmc_get_escape_prob_order3();       //get prob and cump
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order3();       //get prob and cump
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

-   }
+       }

 
 
 
 

- // Code an escape code in order-2
+       // Code an escape code in order-2

 
 

- o2_cntxt=ppmc_order2_hash_key(o1_byte,o2_byte);
+       o2_cntxt=ppmc_order2_hash_key(o1_byte,o2_byte);

 
 

- // First check if current order-2 context is empty
- if(order2_array[o2_cntxt].defined_bytes!=0)  //it's not empty
-   {
-   ppmc_get_totf_order2();
-   ppmc_get_escape_prob_order2();
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
-   }
+       // First check if current order-2 context is empty
+       if(order2_array[o2_cntxt].defined_bytes!=0)  //it's not empty
+       {
+               ppmc_get_totf_order2();
+               ppmc_get_escape_prob_order2();
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       }

 
 
 
 

- // Code an escape code in order-1
+       // Code an escape code in order-1

 
 

- // First check if current order-1 table is empty
- if(order1_defined_bytes_array[o1_byte]!=0)  //it's not empty
-   {
-   ppmc_get_totf_order1();
-   ppmc_get_escape_prob_order1();
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
-   }
+       // First check if current order-1 table is empty
+       if(order1_defined_bytes_array[o1_byte]!=0)  //it's not empty
+       {
+               ppmc_get_totf_order1();
+               ppmc_get_escape_prob_order1();
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       }

 
 
 
 

- // Code an escape code in order-0. Order-0 always has at least one symbol
+       // Code an escape code in order-0. Order-0 always has at least one symbol

 
 

- ppmc_get_totf_order0();
- ppmc_get_escape_prob_order0();
- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       ppmc_get_totf_order0();
+       ppmc_get_escape_prob_order0();
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 
 
 
 
 

- // Now we can code the code 256
+       // Now we can code the code 256

 
 

- symb_prob=1;
- symb_cump=256;
- total_cump=257;
- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       symb_prob=1;
+       symb_cump=256;
+       total_cump=257;
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 
 
 

- // Now that decoder knows the flushing, free memory and reinit
+       // Now that decoder knows the flushing, free memory and reinit

 
 

- ppmc_free_memory();
- ppmc_alloc_memory();
- ppmc_initialize_contexts();
+       ppmc_free_memory();
+       ppmc_alloc_memory();
+       ppmc_initialize_contexts();

 
 
 
 

- // Be sure that order-0 has at least one probability
+       // Be sure that order-0 has at least one probability

 
 

- order0_array[o1_byte]++;
- order0_max_cump++;
- order0_defined_bytes++;
+       order0_array[o1_byte]++;
+       order0_max_cump++;
+       order0_defined_bytes++;

 
 }
 
 
 }
 


@@ -303,18 +303,18 @@ void ppmc_flush_mem_enc(void)
 void ppmc_flush_mem_dec(void)
 {
 
 void ppmc_flush_mem_dec(void)
 {
 

- // Free memory and reinit
+       // Free memory and reinit

 
 

- ppmc_free_memory();
- ppmc_alloc_memory();
- ppmc_initialize_contexts();
+       ppmc_free_memory();
+       ppmc_alloc_memory();
+       ppmc_initialize_contexts();

 
 
 
 

- // Be sure that order-0 has at least one probability
+       // Be sure that order-0 has at least one probability

 
 

- order0_array[o1_byte]++;
- order0_max_cump++;
- order0_defined_bytes++;
+       order0_array[o1_byte]++;
+       order0_max_cump++;
+       order0_defined_bytes++;

 
 
 }
 
 
 }


@@ -339,9 +339,9 @@ void ppmc_flush_mem_dec(void)
 // Gets the probability for a given symbol in the order-(-1) (ordern1)
 void ppmc_get_prob_ordern1(void)
 {
 // Gets the probability for a given symbol in the order-(-1) (ordern1)
 void ppmc_get_prob_ordern1(void)
 {

- symb_cump=byte;    //its value
- symb_prob=1;      //flat probability
- total_cump=257;   //total cump
+       symb_cump=byte;    //its value
+       symb_prob=1;      //flat probability
+       total_cump=257;   //total cump

 }
 
 
 }
 
 


@@ -349,14 +349,14 @@ void ppmc_get_prob_ordern1(void)
 // order-(-1)
 void ppmc_get_totf_ordern1(void)
 {
 // order-(-1)
 void ppmc_get_totf_ordern1(void)
 {

- total_cump=257;        //this is fixed
+       total_cump=257;        //this is fixed

 }
 
 
 // Returns the symbol for a given cump under order-(-1)
 unsigned long ppmc_get_symbol_ordern1 (void)
 {
 }
 
 
 // Returns the symbol for a given cump under order-(-1)
 unsigned long ppmc_get_symbol_ordern1 (void)
 {

- return symb_cump;
+       return symb_cump;

 }
 
 
 }
 
 


@@ -378,8 +378,8 @@ unsigned long ppmc_get_symbol_ordern1 (void)
 // order-0
 void ppmc_get_totf_order0(void)
 {
 // order-0
 void ppmc_get_totf_order0(void)
 {

- // Total cump is current total cump plus the escape for the escape code
- total_cump=order0_defined_bytes+order0_max_cump;
+       // Total cump is current total cump plus the escape for the escape code
+       total_cump=order0_defined_bytes+order0_max_cump;

 }
 
 
 }
 
 


@@ -389,46 +389,46 @@ void ppmc_get_totf_order0(void)
 // Returns: 1 in case a byte was coded. 0 in case of escape code.
 char ppmc_code_byte_order0(void)
 {
 // Returns: 1 in case a byte was coded. 0 in case of escape code.
 char ppmc_code_byte_order0(void)
 {

- unsigned long counter;
+       unsigned long counter;

 
 

- ppmc_get_totf_order0();      //get total cump
+       ppmc_get_totf_order0();      //get total cump

 
 

- // See if the byte is present
- if(order0_array[byte]==0)      //a probability of 0
-   {
+       // See if the byte is present
+       if(order0_array[byte]==0)      //a probability of 0
+       {

 
 

-   // Because it was not present, output an escape code, prepare variables
+               // Because it was not present, output an escape code, prepare variables

 
 

-   symb_cump=order0_max_cump;   //obviously its cump is current max_cump
-                                //without escape code's space
+               symb_cump=order0_max_cump;   //obviously its cump is current max_cump
+               //without escape code's space

 
 

-   symb_prob=order0_defined_bytes;  //the number of defined bytes
+               symb_prob=order0_defined_bytes;  //the number of defined bytes

 
 

-   // Code the escape code
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+               // Code the escape code
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

-   return 0;    //byte not coded
-   }
- else
-   {
+               return 0;    //byte not coded
+       }
+       else
+       {

 
 

-   coded_in_order=0;
+               coded_in_order=0;

 
 

-   // The symbol is present, code it under order-0
+               // The symbol is present, code it under order-0

 
 

-   symb_prob=order0_array[byte];        //get probability directly
+               symb_prob=order0_array[byte];        //get probability directly

 
 

-   // Make cump for current symbol
+               // Make cump for current symbol

 
 

-   symb_cump=0;         //for first symbol is 0
-   for(counter=0; counter!=byte ; ++counter)
-     symb_cump+=order0_array[counter];  //sum probabilities before our symbol
+               symb_cump=0;         //for first symbol is 0
+               for(counter=0; counter!=byte ; ++counter)
+                       symb_cump+=order0_array[counter];  //sum probabilities before our symbol

 
 

-   // Code the symbol
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+               // Code the symbol
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

-   return 1;    //symbol coded under order-0
-   }
+               return 1;    //symbol coded under order-0
+       }

 }
 
 
 }
 
 


@@ -436,50 +436,50 @@ char ppmc_code_byte_order0(void)
 // care about updating variables, and renormalizing.
 void ppmc_update_order0(void)
 {
 // care about updating variables, and renormalizing.
 void ppmc_update_order0(void)
 {

- if(order0_array[byte]==0)
-   {
-   // It had a zero probability
-   order0_array[byte]++;       //increment symbol probability
-   ++order0_defined_bytes;     //new byte defined
-   ++order0_max_cump;          //total cump
-   return;
-   }
- else
-   {
-   // It had a non-zero probability
-
-   // Increment its probability
-   order0_array[byte]++;      //increment symbol probability
-   ++order0_max_cump;         //total cump
-
-   // Check to see if its the maximum in this case renormalize
-   if(order0_array[byte]==255)
-     ppmc_renormalize_order0();
-
-   return;
-   }
+       if(order0_array[byte]==0)
+       {
+               // It had a zero probability
+               order0_array[byte]++;       //increment symbol probability
+               ++order0_defined_bytes;     //new byte defined
+               ++order0_max_cump;          //total cump
+               return;
+       }
+       else
+       {
+               // It had a non-zero probability
+
+               // Increment its probability
+               order0_array[byte]++;      //increment symbol probability
+               ++order0_max_cump;         //total cump
+
+               // Check to see if its the maximum in this case renormalize
+               if(order0_array[byte]==255)
+                       ppmc_renormalize_order0();
+
+               return;
+       }

 }
 
 
 // This functions renormalizes the probabilities at order-0 updating variables
 void ppmc_renormalize_order0(void)
 {
 }
 
 
 // This functions renormalizes the probabilities at order-0 updating variables
 void ppmc_renormalize_order0(void)
 {

- unsigned long counter;
+       unsigned long counter;

 
 

- // Initialize variables
- order0_defined_bytes=0;        //clear them
- order0_max_cump=0;
+       // Initialize variables
+       order0_defined_bytes=0;        //clear them
+       order0_max_cump=0;

 
 

- // Loop over all probabilities, divide them by a factor of 2 and update variables
- for(counter=0 ; counter!=256 ; ++counter)
-   {
-   order0_array[counter]>>=1;   //divide by a factor of 2
+       // Loop over all probabilities, divide them by a factor of 2 and update variables
+       for(counter=0 ; counter!=256 ; ++counter)
+       {
+               order0_array[counter]>>=1;   //divide by a factor of 2

 
 

-   if(order0_array[counter]!=0) //see if it has a non zero probability
-     order0_defined_bytes++;
+               if(order0_array[counter]!=0) //see if it has a non zero probability
+                       order0_defined_bytes++;

 
 

-   order0_max_cump+=order0_array[counter];      //sum to the total cump
-   }
+               order0_max_cump+=order0_array[counter];      //sum to the total cump
+       }

 }
 
 
 }
 
 


@@ -487,60 +487,60 @@ void ppmc_renormalize_order0(void)
 // or in case of a escape code it returns -1
 void ppmc_decode_order0(void)
 {
 // or in case of a escape code it returns -1
 void ppmc_decode_order0(void)
 {

- unsigned long current_cump, counter;
+       unsigned long current_cump, counter;

 
 
 
 

- // Get the total cump needed for decoding symbol
- ppmc_get_totf_order0();      //total cump needed for decoding
- symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it
+       // Get the total cump needed for decoding symbol
+       ppmc_get_totf_order0();      //total cump needed for decoding
+       symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it

 
 

- // Now check if it's an escape code
- if(symb_cump>=order0_max_cump)     //the defined code space for the escape code
-   {
+       // Now check if it's an escape code
+       if(symb_cump>=order0_max_cump)     //the defined code space for the escape code
+       {

 
 

-   // Update coding values
+               // Update coding values

 
 

-   ppmc_get_escape_prob_order0();
-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order0();
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Mark as escape code
+               // Mark as escape code

 
 

-   byte=-1;
+               byte=-1;

 
 

-   return;   //an escape code
-   }
- else
-   {
-   // Now we have to check what symbol it is
+               return;   //an escape code
+       }
+       else
+       {
+               // Now we have to check what symbol it is

 
 

-   current_cump=0;      //cump of the current symbol
+               current_cump=0;      //cump of the current symbol

 
 

-   for(counter=0 ; counter!= 256 ; ++counter)
-     {
-     if(symb_cump<current_cump)
-       break;                  //symbol found, break search loop
-     current_cump+=order0_array[counter];       //update cump
-     }
+               for(counter=0 ; counter!= 256 ; ++counter)
+               {
+                       if(symb_cump<current_cump)
+                               break;                  //symbol found, break search loop
+                       current_cump+=order0_array[counter];       //update cump
+               }

 
 

-   counter--;           //-1 (see ac_ppmc.html, searching for a given symbol)
+               counter--;           //-1 (see ac_ppmc.html, searching for a given symbol)

 
 

-   byte=counter;        //update the variable with the found symbol
+               byte=counter;        //update the variable with the found symbol

 
 
 
 

-   // Get the cump and prob of byte
+               // Get the cump and prob of byte

 
 

-   symb_prob=order0_array[byte];        //the probabilty
-   symb_cump=current_cump-order0_array[byte]; //using the cump which was
-                                              //already made
+               symb_prob=order0_array[byte];        //the probabilty
+               symb_cump=current_cump-order0_array[byte]; //using the cump which was
+               //already made

 
 

-   // Update coding state
+               // Update coding state

 
 

-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   coded_in_order=0;    //decoded under order-0
+               coded_in_order=0;    //decoded under order-0

 
 

-   return;
-   }
+               return;
+       }

 
 }
 
 
 }
 


@@ -548,12 +548,12 @@ void ppmc_decode_order0(void)
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order0(void)
 {
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order0(void)
 {

- // To understand that remember that the escape allocated for the escape code
- // is above the current maximum cump and that it has a probability determined
- // by the scheme C.
- symb_prob=order0_defined_bytes;
- symb_cump=order0_max_cump;
- total_cump=order0_defined_bytes+order0_max_cump;
+       // To understand that remember that the escape allocated for the escape code
+       // is above the current maximum cump and that it has a probability determined
+       // by the scheme C.
+       symb_prob=order0_defined_bytes;
+       symb_cump=order0_max_cump;
+       total_cump=order0_defined_bytes+order0_max_cump;

 }
 
 
 }
 
 


@@ -581,8 +581,8 @@ void ppmc_get_escape_prob_order0(void)
 // order-1. o1_byte should contain the order-1
 void ppmc_get_totf_order1(void)
 {
 // order-1. o1_byte should contain the order-1
 void ppmc_get_totf_order1(void)
 {

- // Total cump is current total cump plus the escape for the escape code
- total_cump=order1_defined_bytes_array[o1_byte]+order1_max_cump_array[o1_byte];
+       // Total cump is current total cump plus the escape for the escape code
+       total_cump=order1_defined_bytes_array[o1_byte]+order1_max_cump_array[o1_byte];

 }
 
 
 }
 
 


@@ -595,56 +595,56 @@ void ppmc_get_totf_order1(void)
 // In case the byte is coded under this context, coded_in_order=1.
 char ppmc_code_byte_order1(void)
 {
 // In case the byte is coded under this context, coded_in_order=1.
 char ppmc_code_byte_order1(void)
 {

- unsigned long counter;
+       unsigned long counter;

 
 
 
 

- // First check if current order-1 table is empty
- if(order1_defined_bytes_array[o1_byte]==0)  //it's empty
-   {
-   return 0;    //byte not coded, nothing done
-   }
+       // First check if current order-1 table is empty
+       if(order1_defined_bytes_array[o1_byte]==0)  //it's empty
+       {
+               return 0;    //byte not coded, nothing done
+       }

 
 
 
 

- // Now try to code this byte under order-1
+       // Now try to code this byte under order-1

 
 

- ppmc_get_totf_order1();      //get total cump
+       ppmc_get_totf_order1();      //get total cump

 
 

- // See if the byte is present
- if(order1_array[o1_byte][byte]==0)      //a probability of 0
-   {
+       // See if the byte is present
+       if(order1_array[o1_byte][byte]==0)      //a probability of 0
+       {

 
 

-   // Because it was not present, output an escape code, prepare variables
+               // Because it was not present, output an escape code, prepare variables

 
 

-   symb_cump=order1_max_cump_array[o1_byte];//obviously its cump is current max_cump
-                                            //without escape code's space
+               symb_cump=order1_max_cump_array[o1_byte];//obviously its cump is current max_cump
+               //without escape code's space

 
 

-   symb_prob=order1_defined_bytes_array[o1_byte];//the number of defined bytes
+               symb_prob=order1_defined_bytes_array[o1_byte];//the number of defined bytes

 
 

-   // Code the escape code
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+               // Code the escape code
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

-   return 0;    //byte not coded, escape coded
-   }
- else
-   {
+               return 0;    //byte not coded, escape coded
+       }
+       else
+       {

 
 

-   coded_in_order=1;            //because we coded it under order-1
+               coded_in_order=1;            //because we coded it under order-1

 
 

-   // The symbol is present, code it under order-1
+               // The symbol is present, code it under order-1

 
 

-   symb_prob=order1_array[o1_byte][byte];        //get probability directly
+               symb_prob=order1_array[o1_byte][byte];        //get probability directly

 
 

-   // Make cump for current symbol
+               // Make cump for current symbol

 
 

-   symb_cump=0;         //for first symbol is 0
-   for(counter=0; counter!=byte ; ++counter)
-     symb_cump+=order1_array[o1_byte][counter];  //sum probabilities before our symbol
+               symb_cump=0;         //for first symbol is 0
+               for(counter=0; counter!=byte ; ++counter)
+                       symb_cump+=order1_array[o1_byte][counter];  //sum probabilities before our symbol

 
 

-   // Code the symbol
-   range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+               // Code the symbol
+               range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

-   return 1;    //symbol coded under order-1
-   }
+               return 1;    //symbol coded under order-1
+       }

 }
 
 
 }
 
 


@@ -652,50 +652,50 @@ char ppmc_code_byte_order1(void)
 // care about updating variables, and renormalizing. o1_byte must be filled.
 void ppmc_update_order1(void)
 {
 // care about updating variables, and renormalizing. o1_byte must be filled.
 void ppmc_update_order1(void)
 {

- if(order1_array[o1_byte][byte]==0)
-   {
-   // It had a zero probability
-   order1_array[o1_byte][byte]++;       //increment symbol probability
-   ++order1_defined_bytes_array[o1_byte];     //new byte defined
-   ++order1_max_cump_array[o1_byte];          //total cump
-   return;
-   }
- else
-   {
-   // It had a non-zero probability
-
-   // Increment its probability
-   order1_array[o1_byte][byte]++;      //increment symbol probability
-   ++order1_max_cump_array[o1_byte];         //total cump
-
-   // Check to see if its the maximum in this case renormalize
-   if(order1_array[o1_byte][byte]==255)
-     ppmc_renormalize_order1();
-
-   return;
-   }
+       if(order1_array[o1_byte][byte]==0)
+       {
+               // It had a zero probability
+               order1_array[o1_byte][byte]++;       //increment symbol probability
+               ++order1_defined_bytes_array[o1_byte];     //new byte defined
+               ++order1_max_cump_array[o1_byte];          //total cump
+               return;
+       }
+       else
+       {
+               // It had a non-zero probability
+
+               // Increment its probability
+               order1_array[o1_byte][byte]++;      //increment symbol probability
+               ++order1_max_cump_array[o1_byte];         //total cump
+
+               // Check to see if its the maximum in this case renormalize
+               if(order1_array[o1_byte][byte]==255)
+                       ppmc_renormalize_order1();
+
+               return;
+       }

 }
 
 
 // This functions renormalizes the probabilities at order-1 updating variables
 void ppmc_renormalize_order1(void)
 {
 }
 
 
 // This functions renormalizes the probabilities at order-1 updating variables
 void ppmc_renormalize_order1(void)
 {

- unsigned long counter;
+       unsigned long counter;

 
 

- // Initialize variables
- order1_defined_bytes_array[o1_byte]=0;        //clear them
- order1_max_cump_array[o1_byte]=0;
+       // Initialize variables
+       order1_defined_bytes_array[o1_byte]=0;        //clear them
+       order1_max_cump_array[o1_byte]=0;

 
 

- // Loop over all probabilities, divide them by a factor of 2 and update variables
- for(counter=0 ; counter!=256 ; ++counter)
-   {
-   order1_array[o1_byte][counter]>>=1;   //divide by a factor of 2
+       // Loop over all probabilities, divide them by a factor of 2 and update variables
+       for(counter=0 ; counter!=256 ; ++counter)
+       {
+               order1_array[o1_byte][counter]>>=1;   //divide by a factor of 2

 
 

-   if(order1_array[o1_byte][counter]!=0) //see if it has a non zero probability
-     order1_defined_bytes_array[o1_byte]++;
+               if(order1_array[o1_byte][counter]!=0) //see if it has a non zero probability
+                       order1_defined_bytes_array[o1_byte]++;

 
 

-   order1_max_cump_array[o1_byte]+=order1_array[o1_byte][counter];      //sum to the total cump
-   }
+               order1_max_cump_array[o1_byte]+=order1_array[o1_byte][counter];      //sum to the total cump
+       }

 }
 
 
 }
 
 


@@ -704,71 +704,71 @@ void ppmc_renormalize_order1(void)
 // It updates "coded_in_order".
 void ppmc_decode_order1(void)
 {
 // It updates "coded_in_order".
 void ppmc_decode_order1(void)
 {

- unsigned long current_cump, counter;
+       unsigned long current_cump, counter;

 
 
 
 

- // First check if current order-1 table is empty
- if(order1_defined_bytes_array[o1_byte]==0)  //it's empty
-   {
-   byte=-1;   //byte not coded, nothing done
-   return;
-   }
+       // First check if current order-1 table is empty
+       if(order1_defined_bytes_array[o1_byte]==0)  //it's empty
+       {
+               byte=-1;   //byte not coded, nothing done
+               return;
+       }

 
 
 
 

- // Get the total cump needed for decoding symbol
- ppmc_get_totf_order1();      //total cump needed for decoding
- symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it
+       // Get the total cump needed for decoding symbol
+       ppmc_get_totf_order1();      //total cump needed for decoding
+       symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it

 
 

- // Now check if it's an escape code
- if(symb_cump>=order1_max_cump_array[o1_byte])     //the defined code space for the escape code
-   {
+       // Now check if it's an escape code
+       if(symb_cump>=order1_max_cump_array[o1_byte])     //the defined code space for the escape code
+       {

 
 

-   // Update coding values
+               // Update coding values

 
 

-   ppmc_get_escape_prob_order1();
-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order1();
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Mark as escape code
+               // Mark as escape code

 
 

-   byte=-1;
+               byte=-1;

 
 

-   return;   //an escape code
-   }
- else
-   {
-   // Now we have to check what symbol it is
+               return;   //an escape code
+       }
+       else
+       {
+               // Now we have to check what symbol it is

 
 

-   current_cump=0;      //cump of the current symbol
+               current_cump=0;      //cump of the current symbol

 
 

-   for(counter=0 ; counter!= 256 ; ++counter)
-     {
-     if(symb_cump<current_cump)
-       break;                  //symbol found, break search loop
-     current_cump+=order1_array[o1_byte][counter];       //update cump
-     }
+               for(counter=0 ; counter!= 256 ; ++counter)
+               {
+                       if(symb_cump<current_cump)
+                               break;                  //symbol found, break search loop
+                       current_cump+=order1_array[o1_byte][counter];       //update cump
+               }

 
 

-   counter--;           //-1 (see ac_ppmc.html, searching for a given symbol)
+               counter--;           //-1 (see ac_ppmc.html, searching for a given symbol)

 
 

-   byte=counter;        //update the variable with the found symbol
+               byte=counter;        //update the variable with the found symbol

 
 
 
 

-   // Get the cump and prob of byte
+               // Get the cump and prob of byte

 
 

-   symb_prob=order1_array[o1_byte][byte];        //the probabilty
-   symb_cump=current_cump-order1_array[o1_byte][byte]; //using the cump which was
-                                              //already made
+               symb_prob=order1_array[o1_byte][byte];        //the probabilty
+               symb_cump=current_cump-order1_array[o1_byte][byte]; //using the cump which was
+               //already made

 
 

-   // Update coding state
+               // Update coding state

 
 

-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 
 
 

-   // Update coded_in_order used for update exclusion
+               // Update coded_in_order used for update exclusion

 
 

-   coded_in_order=1;
+               coded_in_order=1;

 
 

-   return;
-   }
+               return;
+       }

 
 }
 
 
 }
 


@@ -776,12 +776,12 @@ void ppmc_decode_order1(void)
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order1(void)
 {
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order1(void)
 {

- // To understand that remember that the escape allocated for the escape code
- // is above the current maximum cump and that it has a probability determined
- // by the scheme C.
- symb_prob=order1_defined_bytes_array[o1_byte];
- symb_cump=order1_max_cump_array[o1_byte];
- total_cump=order1_defined_bytes_array[o1_byte]+order1_max_cump_array[o1_byte];
+       // To understand that remember that the escape allocated for the escape code
+       // is above the current maximum cump and that it has a probability determined
+       // by the scheme C.
+       symb_prob=order1_defined_bytes_array[o1_byte];
+       symb_cump=order1_max_cump_array[o1_byte];
+       total_cump=order1_defined_bytes_array[o1_byte]+order1_max_cump_array[o1_byte];

 }
 
 
 }
 
 


@@ -813,8 +813,8 @@ void ppmc_get_escape_prob_order1(void)
 // for order-2.
 void ppmc_get_totf_order2(void)
 {
 // for order-2.
 void ppmc_get_totf_order2(void)
 {

- // Total cump is current total cump plus the escape for the escape code
- total_cump=order2_array[o2_cntxt].defined_bytes+order2_array[o2_cntxt].max_cump;
+       // Total cump is current total cump plus the escape for the escape code
+       total_cump=order2_array[o2_cntxt].defined_bytes+order2_array[o2_cntxt].max_cump;

 }
 
 
 }
 
 


@@ -826,87 +826,87 @@ void ppmc_get_totf_order2(void)
 // In case the byte is coded under this context, coded_in_order=2.
 char ppmc_code_byte_order2(void)
 {
 // In case the byte is coded under this context, coded_in_order=2.
 char ppmc_code_byte_order2(void)
 {

- unsigned long counter;
- struct _byte_and_freq *node;
+       unsigned long counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Initialize o2_cntxt
+       // Initialize o2_cntxt

 
 

- o2_cntxt=ppmc_order2_hash_key(o1_byte,o2_byte);
+       o2_cntxt=ppmc_order2_hash_key(o1_byte,o2_byte);

 
 
 
 

- // First check if current order-2 context is empty
- if(order2_array[o2_cntxt].defined_bytes==0)  //it's empty
-   {
-   return 0;   //byte not coded, nothing done
-   }
+       // First check if current order-2 context is empty
+       if(order2_array[o2_cntxt].defined_bytes==0)  //it's empty
+       {
+               return 0;   //byte not coded, nothing done
+       }

 
 
 
 

- // Now try to code this byte under order-2
+       // Now try to code this byte under order-2

 
 

- ppmc_get_totf_order2();      //get total cump
+       ppmc_get_totf_order2();      //get total cump

 
 
 
 

- // See if the byte is present and compute its cump at the same time
+       // See if the byte is present and compute its cump at the same time

 
 

- node=order2_array[o2_cntxt].prob; //pointer to first element in the linked list
+       node=order2_array[o2_cntxt].prob; //pointer to first element in the linked list

 
 

- symb_cump=0;   //the first symbol always has a 0 cump
+       symb_cump=0;   //the first symbol always has a 0 cump

 
 
 
 

- // Now search the byte in the linked list
+       // Now search the byte in the linked list

 
 

- do{
-   if(node->byte==byte)
-     goto ppmc_o2_byte_found;   //bad thing, I know, anyone has a better idea?
-   symb_cump+=node->freq;       //add the probability of this byte to the cump
-   if(node->next==0)
-     break;
-   node=node->next;             //next element in the linked list
-   }while(1);
+       do{
+               if(node->byte==byte)
+                       goto ppmc_o2_byte_found;   //bad thing, I know, anyone has a better idea?
+               symb_cump+=node->freq;       //add the probability of this byte to the cump
+               if(node->next==0)
+                       break;
+               node=node->next;             //next element in the linked list
+       }while(1);

 
 
 
 

- // If we reach that point, the byte was not found in the linked list
- // so we don't need the cump, we have to output an escape code, whose
- // probabilities are know using the context structure in the table.
+       // If we reach that point, the byte was not found in the linked list
+       // so we don't need the cump, we have to output an escape code, whose
+       // probabilities are know using the context structure in the table.

 
 

- // Byte was not present in the linked list, current node is the last one,
- // and that's the node needed for creating a new node, save it.
+       // Byte was not present in the linked list, current node is the last one,
+       // and that's the node needed for creating a new node, save it.

 
 

- o2_ll_node=node;
+       o2_ll_node=node;

 
 

- // Now get the probability and cump of the escape code
+       // Now get the probability and cump of the escape code

 
 

- symb_cump=order2_array[o2_cntxt].max_cump;
- symb_prob=order2_array[o2_cntxt].defined_bytes;
+       symb_cump=order2_array[o2_cntxt].max_cump;
+       symb_prob=order2_array[o2_cntxt].defined_bytes;

 
 

- // Code the escape code
- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       // Code the escape code
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

- return 0;
+       return 0;

 
 
 
 

- // That code is executed when the byte is found in the linked list
+       // That code is executed when the byte is found in the linked list

 
 

- ppmc_o2_byte_found:
+ppmc_o2_byte_found:

 
 
 
 

- // Everything has been tested, now we can feel free to code the byte,
- // the symb_cump is already computed, now get its probability and code
- // the byte, also save pointer to this element in the linked lists for
- // updating.
+       // Everything has been tested, now we can feel free to code the byte,
+       // the symb_cump is already computed, now get its probability and code
+       // the byte, also save pointer to this element in the linked lists for
+       // updating.

 
 

- coded_in_order=2;      //successfully coded under order-2
+       coded_in_order=2;      //successfully coded under order-2

 
 

- o2_ll_node=node;       //save it for updating
+       o2_ll_node=node;       //save it for updating

 
 

- symb_prob=node->freq;  //get the probability of the byte
+       symb_prob=node->freq;  //get the probability of the byte

 
 

- // Code it.
+       // Code it.

 
 

- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

- return 1;      //byte coded under order-2
+       return 1;      //byte coded under order-2

 }
 
 
 }
 
 


@@ -920,129 +920,129 @@ char ppmc_code_byte_order2(void)
 void ppmc_update_order2(void)
 {
 
 void ppmc_update_order2(void)
 {
 

- // First of all check if that's the first byte in this context, in that case
- // we have to initialize some variables in the context structure.
+       // First of all check if that's the first byte in this context, in that case
+       // we have to initialize some variables in the context structure.

 
 

- if(order2_array[o2_cntxt].defined_bytes==0)    //no byte defined yet
-   {
+       if(order2_array[o2_cntxt].defined_bytes==0)    //no byte defined yet
+       {

 
 

-   if(ppmc_out_of_memory==1)
-    return;                //exit this function, we can't allocate memory
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate memory

 
 

-   order2_array[o2_cntxt].defined_bytes=1;
-   order2_array[o2_cntxt].max_cump=1;
-   order2_array[o2_cntxt].prob=_bytes_pool;
+               order2_array[o2_cntxt].defined_bytes=1;
+               order2_array[o2_cntxt].max_cump=1;
+               order2_array[o2_cntxt].prob=_bytes_pool;

 
 

-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

-   return;      //nothing else to do
-   }
+               return;      //nothing else to do
+       }

 
 
 
 

- // The byte was coded under order two, otherwise it was coded under a
- // lower order (never higher ones, remember that we are using update
- // exclusion) in this case we have to create a new node in the list.
+       // The byte was coded under order two, otherwise it was coded under a
+       // lower order (never higher ones, remember that we are using update
+       // exclusion) in this case we have to create a new node in the list.

 
 

- if(coded_in_order==2)  //coded under order-2
-   {
+       if(coded_in_order==2)  //coded under order-2
+       {

 
 

-   // Update its count and variables of this context and check for renormalization
+               // Update its count and variables of this context and check for renormalization

 
 

-   o2_ll_node->freq++;  //increment its frequency (rather probability)
+               o2_ll_node->freq++;  //increment its frequency (rather probability)

 
 

-   order2_array[o2_cntxt].max_cump++;   //total cump
+               order2_array[o2_cntxt].max_cump++;   //total cump

 
 

-   if(o2_ll_node->freq==255)    //do we have to renormalize?
-     ppmc_renormalize_order2(); //renormalize
+               if(o2_ll_node->freq==255)    //do we have to renormalize?
+                       ppmc_renormalize_order2(); //renormalize

 
 

-   }
- else
-   {
+       }
+       else
+       {

 
 

-   // Once every paranoid check has been done we are sure that this byte
-   // did not existed and so we have to create a new node in the linked
-   // list. Also we have to take care of memory issues.
+               // Once every paranoid check has been done we are sure that this byte
+               // did not existed and so we have to create a new node in the linked
+               // list. Also we have to take care of memory issues.

 
 

-   if(ppmc_out_of_memory==1)
-     return;                //exit this function, we can't allocate mem
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate mem

 
 

-   o2_ll_node->next=_bytes_pool;    //put it in the next free entry
-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               o2_ll_node->next=_bytes_pool;    //put it in the next free entry
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   order2_array[o2_cntxt].max_cump++;   //total cump
-   order2_array[o2_cntxt].defined_bytes++;   //total cump
+               order2_array[o2_cntxt].max_cump++;   //total cump
+               order2_array[o2_cntxt].defined_bytes++;   //total cump

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

- }
+       }

 
 }
 
 
 }
 


@@ -1051,31 +1051,31 @@ void ppmc_update_order2(void)
 // variables.
 void ppmc_renormalize_order2(void)
 {
 // variables.
 void ppmc_renormalize_order2(void)
 {

- unsigned long counter;
- struct _byte_and_freq *node;
+       unsigned long counter;
+       struct _byte_and_freq *node;

 
 

- // Initialize variables. Defined bytes remain the same.
- order2_array[o2_cntxt].max_cump=0;        //clear them
+       // Initialize variables. Defined bytes remain the same.
+       order2_array[o2_cntxt].max_cump=0;        //clear them

 
 

- node=order2_array[o2_cntxt].prob;      //get pointer to lined lists
+       node=order2_array[o2_cntxt].prob;      //get pointer to lined lists

 
 

- // Divide all the probabilities by 2 and update context variables
- while(1)
-   {
-   node->freq>>=1;                      //divide by a factor of 2
+       // Divide all the probabilities by 2 and update context variables
+       while(1)
+       {
+               node->freq>>=1;                      //divide by a factor of 2

 
 

-   if(node->freq==0)    //don't allow a probability to be 0
-     node->freq=1;
+               if(node->freq==0)    //don't allow a probability to be 0
+                       node->freq=1;

 
 

-   order2_array[o2_cntxt].max_cump+=node->freq; //sum to the total cump
+               order2_array[o2_cntxt].max_cump+=node->freq; //sum to the total cump

 
 

-   if(node->next==0)    //last element
-     break;
-   node=node->next;
-   }
+               if(node->next==0)    //last element
+                       break;
+               node=node->next;
+       }

 
 
 
 

- //printf("\nRenormalization, context:%c%c",o2_byte,o1_byte);
+       //printf("\nRenormalization, context:%c%c",o2_byte,o1_byte);

 
 }
 
 
 }
 


@@ -1090,82 +1090,82 @@ void ppmc_renormalize_order2(void)
 // "o2_ll_node" the pointer to its node. (so updating is faster)
 void ppmc_decode_order2(void)
 {
 // "o2_ll_node" the pointer to its node. (so updating is faster)
 void ppmc_decode_order2(void)
 {

- unsigned long current_cump, counter;
- struct _byte_and_freq *node;
+       unsigned long current_cump, counter;
+       struct _byte_and_freq *node;

 
 

- // Initialize o2_cntxt
+       // Initialize o2_cntxt

 
 

- o2_cntxt=ppmc_order2_hash_key(o1_byte,o2_byte);
+       o2_cntxt=ppmc_order2_hash_key(o1_byte,o2_byte);

 
 
 
 

- // First check if current order-2 context is empty
- if(order2_array[o2_cntxt].defined_bytes==0)  //it's empty
-   {
-   byte=-1;   //byte not coded, nothing done
-   return;
-   }
+       // First check if current order-2 context is empty
+       if(order2_array[o2_cntxt].defined_bytes==0)  //it's empty
+       {
+               byte=-1;   //byte not coded, nothing done
+               return;
+       }

 
 
 
 

- // Get the total cump needed for decoding symbol
- ppmc_get_totf_order2();      //total cump needed for decoding
- symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it
+       // Get the total cump needed for decoding symbol
+       ppmc_get_totf_order2();      //total cump needed for decoding
+       symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it

 
 

- // Now check if it's an escape code
- if(symb_cump>=order2_array[o2_cntxt].max_cump)     //the defined code space for the escape code
-   {
+       // Now check if it's an escape code
+       if(symb_cump>=order2_array[o2_cntxt].max_cump)     //the defined code space for the escape code
+       {

 
 

-   // Update coding values
+               // Update coding values

 
 

-   ppmc_get_escape_prob_order2();
-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order2();
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Mark as escape code
+               // Mark as escape code

 
 

-   byte=-1;
+               byte=-1;

 
 

-   return;   //an escape code
-   }
- else
-   {
-   // Now we have to check what symbol it is
+               return;   //an escape code
+       }
+       else
+       {
+               // Now we have to check what symbol it is

 
 

-   current_cump=0;      //cump of the current symbol
+               current_cump=0;      //cump of the current symbol

 
 

-   node=order2_array[o2_cntxt].prob;    //get pointer to linked lists
+               node=order2_array[o2_cntxt].prob;    //get pointer to linked lists

 
 

-   while(1)
-     {
-     current_cump+=node->freq; //update cump
-     if(symb_cump<current_cump)
-       break;                  //symbol found, break search loop
+               while(1)
+               {
+                       current_cump+=node->freq; //update cump
+                       if(symb_cump<current_cump)
+                               break;                  //symbol found, break search loop

 
 

-     node=node->next;          //next element
-     //we have no need to check for the last symbol, we'll never read further
-     //the end of the linked lists, before we'll found the last byte.
-     }
+                       node=node->next;          //next element
+                       //we have no need to check for the last symbol, we'll never read further
+                       //the end of the linked lists, before we'll found the last byte.
+               }

 
 
 
 

-   //read byte value and probability
+               //read byte value and probability

 
 

-   symb_prob=node->freq;     //get the probability for updating the state
-   byte=node->byte;          //get byte
-   o2_ll_node=node;          //used for updating
+               symb_prob=node->freq;     //get the probability for updating the state
+               byte=node->byte;          //get byte
+               o2_ll_node=node;          //used for updating

 
 
 
 

-   // Get the cump of byte
+               // Get the cump of byte

 
 

-   symb_cump=current_cump-symb_prob;
+               symb_cump=current_cump-symb_prob;

 
 

-   // Update coding state
+               // Update coding state

 
 

-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Update coded_in_order used for update exclusion
+               // Update coded_in_order used for update exclusion

 
 

-   coded_in_order=2;
+               coded_in_order=2;

 
 

-   return;
-   }
+               return;
+       }

 
 }
 
 
 }
 


@@ -1182,147 +1182,147 @@ void ppmc_decode_order2(void)
 // when the context has not been initalized yet.
 void ppmc_update_dec_order2(void)
 {
 // when the context has not been initalized yet.
 void ppmc_update_dec_order2(void)
 {

- struct _byte_and_freq *node;
+       struct _byte_and_freq *node;

 
 
 
 

- // Handle the case when the context is not initialized
- // This code is the same as the one for the encoding.
+       // Handle the case when the context is not initialized
+       // This code is the same as the one for the encoding.

 
 

- if(order2_array[o2_cntxt].defined_bytes==0)    //no byte defined yet
-   {
+       if(order2_array[o2_cntxt].defined_bytes==0)    //no byte defined yet
+       {

 
 

-   if(ppmc_out_of_memory==1)
-    return;                //exit this function, we can't allocate memory
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate memory

 
 

-   order2_array[o2_cntxt].defined_bytes=1;
-   order2_array[o2_cntxt].max_cump=1;
-   order2_array[o2_cntxt].prob=_bytes_pool;
+               order2_array[o2_cntxt].defined_bytes=1;
+               order2_array[o2_cntxt].max_cump=1;
+               order2_array[o2_cntxt].prob=_bytes_pool;

 
 

-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 
 
 

-   return;      //nothing else to do
-   }
+               return;      //nothing else to do
+       }

 
 
 
 

- // Current context is initalized, proceed
+       // Current context is initalized, proceed

 
 

- if(coded_in_order==2)          //check if it was decoded under order-2
-   {
+       if(coded_in_order==2)          //check if it was decoded under order-2
+       {

 
 

-   // We can be sure that the pointer "o2_ll_node" points to its entry, and
-   // it has a non 0 probability (otherwise it couldn't be coded) so just
-   // update its probability and max_cump
+               // We can be sure that the pointer "o2_ll_node" points to its entry, and
+               // it has a non 0 probability (otherwise it couldn't be coded) so just
+               // update its probability and max_cump

 
 

-   o2_ll_node->freq++;          //the probability of the byte
-   order2_array[o2_cntxt].max_cump++; //the max_cump
+               o2_ll_node->freq++;          //the probability of the byte
+               order2_array[o2_cntxt].max_cump++; //the max_cump

 
 

-   if(o2_ll_node->freq==255)    //check for renormalization
-     ppmc_renormalize_order2();
+               if(o2_ll_node->freq==255)    //check for renormalization
+                       ppmc_renormalize_order2();

 
 

-   }
- else
-   {
+       }
+       else
+       {

 
 

-   // An escape code was decoded under order-2, we have to read till the
-   // end of the linked list so we can add a new node for this new byte.
+               // An escape code was decoded under order-2, we have to read till the
+               // end of the linked list so we can add a new node for this new byte.

 
 

-   node=order2_array[o2_cntxt].prob;    //get pointer to linked list
+               node=order2_array[o2_cntxt].prob;    //get pointer to linked list

 
 

-   while(1)
-     {
-     if(node->next==0)          //check for the end of the linked list
-       break;
-     node=node->next;           //next node
-     }
+               while(1)
+               {
+                       if(node->next==0)          //check for the end of the linked list
+                               break;
+                       node=node->next;           //next node
+               }

 
 
 
 

-   // We reached the end of the linked list, add a new node if possible,
-   // we are using the same code of "ppmc_update_order2()" with the
-   // difference that the pointer to the linked list is "node"
+               // We reached the end of the linked list, add a new node if possible,
+               // we are using the same code of "ppmc_update_order2()" with the
+               // difference that the pointer to the linked list is "node"

 
 

-   if(ppmc_out_of_memory==1)
-     return;                //exit this function, we can't allocate mem
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate mem

 
 

-   node->next=_bytes_pool;          //put it in the next free entry
-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               node->next=_bytes_pool;          //put it in the next free entry
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   order2_array[o2_cntxt].max_cump++;   //total cump
-   order2_array[o2_cntxt].defined_bytes++;   //total cump
+               order2_array[o2_cntxt].max_cump++;   //total cump
+               order2_array[o2_cntxt].defined_bytes++;   //total cump

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

-   return;      //we are finished updating
+               return;      //we are finished updating

 
 

-   }
+       }

 
 }
 
 
 }
 


@@ -1330,12 +1330,12 @@ void ppmc_update_dec_order2(void)
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order2(void)
 {
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order2(void)
 {

- // To understand that remember that the escape allocated for the escape code
- // is above the current maximum cump and that it has a probability determined
- // by the scheme C.
+       // To understand that remember that the escape allocated for the escape code
+       // is above the current maximum cump and that it has a probability determined
+       // by the scheme C.

 
 

- symb_prob=order2_array[o2_cntxt].defined_bytes;
- symb_cump=order2_array[o2_cntxt].max_cump;
+       symb_prob=order2_array[o2_cntxt].defined_bytes;
+       symb_cump=order2_array[o2_cntxt].max_cump;

 }
 
 
 }
 
 


@@ -1367,61 +1367,61 @@ void ppmc_get_escape_prob_order2(void)
 // have to code under this context.
 char ppmc_get_totf_order3(void)
 {
 // have to code under this context.
 char ppmc_get_totf_order3(void)
 {

- struct context *cntxt_node;
+       struct context *cntxt_node;

 
 
 
 

- // First make the hash key for order-3
+       // First make the hash key for order-3

 
 

- o3_cntxt=ppmc_order3_hash_key(o1_byte,o2_byte,o3_byte);
- full_o3_cntxt=(o1_byte)+(o2_byte<<8)+(o3_byte<<16);    //order-3
+       o3_cntxt=ppmc_order3_hash_key(o1_byte,o2_byte,o3_byte);
+       full_o3_cntxt=(o1_byte)+(o2_byte<<8)+(o3_byte<<16);    //order-3

 
 
 
 

- // Now check the hash entry in the table
+       // Now check the hash entry in the table

 
 

- if(order3_hasht[o3_cntxt]==0)  //if 0, not initialized
-   {
+       if(order3_hasht[o3_cntxt]==0)  //if 0, not initialized
+       {

 
 

-   o3_context=0;        //no hash entry
+               o3_context=0;        //no hash entry

 
 

-   return 0;    //hash entry not initialized
-   }
+               return 0;    //hash entry not initialized
+       }

 
 
 
 

- // Now read trough the linked list of context searching current one
+       // Now read trough the linked list of context searching current one

 
 

- cntxt_node=order3_hasht[o3_cntxt];
+       cntxt_node=order3_hasht[o3_cntxt];

 
 

- while(1)
-   {
+       while(1)
+       {

 
 

-   if(cntxt_node->order4321==full_o3_cntxt)     //compare context
-     goto ppmc_gtf_cntxt_found;
+               if(cntxt_node->order4321==full_o3_cntxt)     //compare context
+                       goto ppmc_gtf_cntxt_found;

 
 

-   if(cntxt_node->next==0)      //end of context's linked list
-     break;
+               if(cntxt_node->next==0)      //end of context's linked list
+                       break;

 
 

-   cntxt_node=cntxt_node->next; //next element
+               cntxt_node=cntxt_node->next; //next element

 
 

-   }
+       }

 
 
 
 

- // Once there the context was not found
- o3_context=cntxt_node;    //pointer to last element in the linked list
+       // Once there the context was not found
+       o3_context=cntxt_node;    //pointer to last element in the linked list

 
 

- return 0;      //it was not present
+       return 0;      //it was not present

 
 
 
 

- // The context is found, so return pointer and cump
+       // The context is found, so return pointer and cump

 
 

- ppmc_gtf_cntxt_found:
+ppmc_gtf_cntxt_found:

 
 

- o3_context=cntxt_node;
+       o3_context=cntxt_node;

 
 

- // Total cump is current total cump plus the escape for the escape code
+       // Total cump is current total cump plus the escape for the escape code

 
 

- total_cump=o3_context->defined_bytes+o3_context->max_cump;
+       total_cump=o3_context->defined_bytes+o3_context->max_cump;

 
 

- return 1;      //context found
+       return 1;      //context found

 
 }
 
 
 }
 


@@ -1432,76 +1432,76 @@ char ppmc_get_totf_order3(void)
 // In case the byte is coded under this context, coded_in_order=3.
 char ppmc_code_byte_order3(void)
 {
 // In case the byte is coded under this context, coded_in_order=3.
 char ppmc_code_byte_order3(void)
 {

- unsigned long counter;
- struct _byte_and_freq *node;
+       unsigned long counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Get current context (if present) and total cump.
+       // Get current context (if present) and total cump.

 
 

- if(ppmc_get_totf_order3()==0)
-   return 0;
+       if(ppmc_get_totf_order3()==0)
+               return 0;

 
 
 
 

- // See if the byte is present and compute its cump at the same time
+       // See if the byte is present and compute its cump at the same time

 
 

- node=o3_context->prob; //pointer to first element in the linked list
+       node=o3_context->prob; //pointer to first element in the linked list

 
 

- symb_cump=0;   //the first symbol always has a 0 cump
+       symb_cump=0;   //the first symbol always has a 0 cump

 
 
 
 

- // Now search the byte in the linked list
+       // Now search the byte in the linked list

 
 

- do{
-   if(node->byte==byte)
-     goto ppmc_o3_byte_found;   //bad thing, I know, anyone has a better idea?
-   symb_cump+=node->freq;       //add the probability of this byte to the cump
-   if(node->next==0)
-     break;
-   node=node->next;             //next element in the linked list
-   }while(1);
+       do{
+               if(node->byte==byte)
+                       goto ppmc_o3_byte_found;   //bad thing, I know, anyone has a better idea?
+               symb_cump+=node->freq;       //add the probability of this byte to the cump
+               if(node->next==0)
+                       break;
+               node=node->next;             //next element in the linked list
+       }while(1);

 
 
 
 

- // If we reach that point, the byte was not found in the linked list
- // so we don't need the cump, we have to output an escape code, whose
- // probabilities are know using the context structure in the table.
+       // If we reach that point, the byte was not found in the linked list
+       // so we don't need the cump, we have to output an escape code, whose
+       // probabilities are know using the context structure in the table.

 
 

- // Byte was not present in the linked list, current node is the last one,
- // and that's the node needed for creating a new node, save it.
+       // Byte was not present in the linked list, current node is the last one,
+       // and that's the node needed for creating a new node, save it.

 
 

- o3_ll_node=node;
+       o3_ll_node=node;

 
 

- // Now get the probability and cump of the escape code
+       // Now get the probability and cump of the escape code

 
 

- symb_cump=o3_context->max_cump;
- symb_prob=o3_context->defined_bytes;
+       symb_cump=o3_context->max_cump;
+       symb_prob=o3_context->defined_bytes;

 
 

- // Code the escape code
- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       // Code the escape code
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

- return 0;
+       return 0;

 
 
 
 

- // That code is executed when the byte is found in the linked list
+       // That code is executed when the byte is found in the linked list

 
 

- ppmc_o3_byte_found:
+ppmc_o3_byte_found:

 
 
 
 

- // Everything has been tested, now we can feel free to code the byte,
- // the symb_cump is already computed, now get its probability and code
- // the byte, also save pointer to this element in the linked lists for
- // updating.
+       // Everything has been tested, now we can feel free to code the byte,
+       // the symb_cump is already computed, now get its probability and code
+       // the byte, also save pointer to this element in the linked lists for
+       // updating.

 
 

- coded_in_order=3;      //successfully coded under order-3
+       coded_in_order=3;      //successfully coded under order-3

 
 

- o3_ll_node=node;       //save it for updating
+       o3_ll_node=node;       //save it for updating

 
 

- symb_prob=node->freq;  //get the probability of the byte
+       symb_prob=node->freq;  //get the probability of the byte

 
 

- // Code it.
+       // Code it.

 
 

- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

- return 1;      //byte coded under order-3
+       return 1;      //byte coded under order-3

 }
 
 
 }
 
 


@@ -1516,274 +1516,274 @@ char ppmc_code_byte_order3(void)
 void ppmc_update_order3(void)
 {
 
 void ppmc_update_order3(void)
 {
 

- // First thing first, check if the hash entry is initialized
+       // First thing first, check if the hash entry is initialized

 
 

- if(order3_hasht[o3_cntxt]==0)    //no pointer to linked list defined yet
-   {
+       if(order3_hasht[o3_cntxt]==0)    //no pointer to linked list defined yet
+       {

 
 

-   if(ppmc_out_of_memory==1)
-     return;                //exit this function, we can't allocate memory
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate memory

 
 
 
 

-   // First create the context
+               // First create the context

 
 

-   order3_hasht[o3_cntxt]=_context_pool;
+               order3_hasht[o3_cntxt]=_context_pool;

 
 

-   _context_pool->next=0;       //this is the last element
-   _context_pool->order4321=full_o3_cntxt;      //put context
-   _context_pool->prob=_bytes_pool;             //pointer to linked list
-   _context_pool->max_cump=1;
-   _context_pool->defined_bytes=1;
+               _context_pool->next=0;       //this is the last element
+               _context_pool->order4321=full_o3_cntxt;      //put context
+               _context_pool->prob=_bytes_pool;             //pointer to linked list
+               _context_pool->max_cump=1;
+               _context_pool->defined_bytes=1;

 
 
 
 

-   // Do update of linked list variables and memory use of contexts
+               // Do update of linked list variables and memory use of contexts

 
 

-   ++_context_pool;           //next time use next entry (this is a pointer)
+               ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_context_pool==_context_pool_max)    //maximum reached
-     {
+               if(_context_pool==_context_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_context_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_context_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_context_pool=(struct context *)malloc
-       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-       {
-       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_context_pool=(struct context *)malloc
+                                               (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                       {
+                               printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _context_pool_array[_context_pool_index]=_context_pool;
+                       _context_pool_array[_context_pool_index]=_context_pool;

 
 

-     _context_pool_max=_context_pool+_context_pool_elements_inc;
+                       _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-     _context_pool_index++;
+                       _context_pool_index++;

 
 

-     }
+               }

 
 
 
 

-   // Now care about the first (and last) linked list element
+               // Now care about the first (and last) linked list element

 
 

-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

-   return;      //nothing else to do
-   }
+               return;      //nothing else to do
+       }

 
 
 
 
 
 
 
 

- // The byte was coded under order three, otherwise it was coded under a
- // lower order (never higher ones, remember that we are using update
- // exclusion) in this case we have to create a new node in the list.
+       // The byte was coded under order three, otherwise it was coded under a
+       // lower order (never higher ones, remember that we are using update
+       // exclusion) in this case we have to create a new node in the list.

 
 

- if(coded_in_order==3)  //coded under order-3
-   {
+       if(coded_in_order==3)  //coded under order-3
+       {

 
 

-   // Update its count and variables of this context and check for renormalization
+               // Update its count and variables of this context and check for renormalization

 
 

-   o3_ll_node->freq++;  //increment its frequency (rather probability)
+               o3_ll_node->freq++;  //increment its frequency (rather probability)

 
 

-   o3_context->max_cump++;   //total cump
+               o3_context->max_cump++;   //total cump

 
 

-   if(o3_ll_node->freq==255)    //do we have to renormalize?
-     ppmc_renormalize_order3(); //renormalize
+               if(o3_ll_node->freq==255)    //do we have to renormalize?
+                       ppmc_renormalize_order3(); //renormalize

 
 

-   }
- else
-   {
+       }
+       else
+       {

 
 

-   // Now we have two cases, under a given context (which we actually found)
-   // we coded an escape coded, in that case just create a new node in the
-   // linked list of bytes and probabilities. Otherwise we didn't find the
-   // same node so we have to create it in the linked list for context.
-   // And we can be sure that it at least has one element and that
-   // "o3_context" points to the last element, so we can put the new element.
+               // Now we have two cases, under a given context (which we actually found)
+               // we coded an escape coded, in that case just create a new node in the
+               // linked list of bytes and probabilities. Otherwise we didn't find the
+               // same node so we have to create it in the linked list for context.
+               // And we can be sure that it at least has one element and that
+               // "o3_context" points to the last element, so we can put the new element.

 
 

-   if(o3_context->order4321==full_o3_cntxt) //chech if that's the last
-     {                                      //element or the a context found
+               if(o3_context->order4321==full_o3_cntxt) //chech if that's the last
+               {                                      //element or the a context found

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate mem
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate mem

 
 

-     o3_ll_node->next=_bytes_pool;    //put it in the next free entry
-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       o3_ll_node->next=_bytes_pool;    //put it in the next free entry
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     o3_context->max_cump++;   //total cump
-     o3_context->defined_bytes++;   //total cump
+                       o3_context->max_cump++;   //total cump
+                       o3_context->defined_bytes++;   //total cump

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-        printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-                ppmc_out_of_memory=1;    //flush
-                return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
-     }
-   else
-     {
+                       }
+               }
+               else
+               {

 
 

-     // We have to create a new context node
+                       // We have to create a new context node

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate memory
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate memory

 
 
 
 

-     // First create the context
+                       // First create the context

 
 

-     o3_context->next=_context_pool;
+                       o3_context->next=_context_pool;

 
 

-     _context_pool->next=0;       //this is the last element
-     _context_pool->order4321=full_o3_cntxt;      //put context
-     _context_pool->prob=_bytes_pool;             //pointer to linked list
-     _context_pool->max_cump=1;
-     _context_pool->defined_bytes=1;
+                       _context_pool->next=0;       //this is the last element
+                       _context_pool->order4321=full_o3_cntxt;      //put context
+                       _context_pool->prob=_bytes_pool;             //pointer to linked list
+                       _context_pool->max_cump=1;
+                       _context_pool->defined_bytes=1;

 
 
 
 

-     // Do update of linked list variables and memory use of contexts
+                       // Do update of linked list variables and memory use of contexts

 
 

-     ++_context_pool;           //next time use next entry (this is a pointer)
+                       ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_context_pool==_context_pool_max)    //maximum reached
-       {
+                       if(_context_pool==_context_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_context_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_context_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_context_pool=(struct context *)malloc
-         (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-         {
-         printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_context_pool=(struct context *)malloc
+                                                       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                               {
+                                       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _context_pool_array[_context_pool_index]=_context_pool;
+                               _context_pool_array[_context_pool_index]=_context_pool;

 
 

-       _context_pool_max=_context_pool+_context_pool_elements_inc;
+                               _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-       _context_pool_index++;
+                               _context_pool_index++;

 
 

-       }
+                       }

 
 

-     // Now care about the first (and last) linked list element
+                       // Now care about the first (and last) linked list element

 
 

-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-        printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-                ppmc_out_of_memory=1;    //flush
-                return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
+                       }

 
 

-     }
+               }

 
 

- }
+       }

 
 }
 
 
 }
 


@@ -1792,29 +1792,29 @@ void ppmc_update_order3(void)
 // variables.
 void ppmc_renormalize_order3(void)
 {
 // variables.
 void ppmc_renormalize_order3(void)
 {

- unsigned long counter;
- struct _byte_and_freq *node;
+       unsigned long counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Initialize variables. Defined bytes remain the same.
- o3_context->max_cump=0;        //clear them
+       // Initialize variables. Defined bytes remain the same.
+       o3_context->max_cump=0;        //clear them

 
 

- node=o3_context->prob;      //get pointer to lined lists
+       node=o3_context->prob;      //get pointer to lined lists

 
 

- // Divide all the probabilities by 2 and update context variables
- while(1)
-   {
-   node->freq>>=1;                      //divide by a factor of 2
+       // Divide all the probabilities by 2 and update context variables
+       while(1)
+       {
+               node->freq>>=1;                      //divide by a factor of 2

 
 

-   if(node->freq==0)    //don't allow a probability to be 0
-     node->freq=1;
+               if(node->freq==0)    //don't allow a probability to be 0
+                       node->freq=1;

 
 

-   o3_context->max_cump+=node->freq; //sum to the total cump
+               o3_context->max_cump+=node->freq; //sum to the total cump

 
 

-   if(node->next==0)    //last element
-     break;
-   node=node->next;
-   }
+               if(node->next==0)    //last element
+                       break;
+               node=node->next;
+       }

 
 
 }
 
 
 }


@@ -1830,79 +1830,79 @@ void ppmc_renormalize_order3(void)
 // "o3_ll_node" the pointer to its node. (so updating is faster)
 void ppmc_decode_order3(void)
 {
 // "o3_ll_node" the pointer to its node. (so updating is faster)
 void ppmc_decode_order3(void)
 {

- unsigned long current_cump, counter;
- struct _byte_and_freq *node;
+       unsigned long current_cump, counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Get current context (if present) and total cump.
+       // Get current context (if present) and total cump.

 
 

- if(ppmc_get_totf_order3()==0)
-   {
-   byte=-1;
-   return;
-   }
+       if(ppmc_get_totf_order3()==0)
+       {
+               byte=-1;
+               return;
+       }

 
 
 
 

- // Decode current cump
+       // Decode current cump

 
 

- symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it
+       symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it

 
 

- // Now check if it's an escape code
- if(symb_cump>=o3_context->max_cump)     //the defined code space for the escape code
-   {
+       // Now check if it's an escape code
+       if(symb_cump>=o3_context->max_cump)     //the defined code space for the escape code
+       {

 
 

-   // Update coding values
+               // Update coding values

 
 

-   ppmc_get_escape_prob_order3();
-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order3();
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Mark as escape code
+               // Mark as escape code

 
 

-   byte=-1;
+               byte=-1;

 
 

-   return;   //an escape code
-   }
- else
-   {
-   // Now we have to check what symbol it is
+               return;   //an escape code
+       }
+       else
+       {
+               // Now we have to check what symbol it is

 
 

-   current_cump=0;      //cump of the current symbol
+               current_cump=0;      //cump of the current symbol

 
 

-   node=o3_context->prob;    //get pointer to linked lists
+               node=o3_context->prob;    //get pointer to linked lists

 
 

-   while(1)
-     {
-     current_cump+=node->freq; //update cump
-     if(symb_cump<current_cump)
-       break;                  //symbol found, break search loop
+               while(1)
+               {
+                       current_cump+=node->freq; //update cump
+                       if(symb_cump<current_cump)
+                               break;                  //symbol found, break search loop

 
 

-     node=node->next;          //next element
-     //we have no need to check for the last symbol, we'll never read further
-     //the end of the linked lists, before we'll found the last byte.
-     }
+                       node=node->next;          //next element
+                       //we have no need to check for the last symbol, we'll never read further
+                       //the end of the linked lists, before we'll found the last byte.
+               }

 
 
 
 

-   //read byte value and probability
+               //read byte value and probability

 
 

-   symb_prob=node->freq;     //get the probability for updating the state
-   byte=node->byte;          //get byte
-   o3_ll_node=node;          //used for updating
+               symb_prob=node->freq;     //get the probability for updating the state
+               byte=node->byte;          //get byte
+               o3_ll_node=node;          //used for updating

 
 
 
 

-   // Get the cump of byte
+               // Get the cump of byte

 
 

-   symb_cump=current_cump-symb_prob;
+               symb_cump=current_cump-symb_prob;

 
 

-   // Update coding state
+               // Update coding state

 
 

-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Update coded_in_order used for update exclusion
+               // Update coded_in_order used for update exclusion

 
 

-   coded_in_order=3;
+               coded_in_order=3;

 
 

-   return;
-   }
+               return;
+       }

 
 }
 
 
 }
 


@@ -1914,286 +1914,286 @@ void ppmc_decode_order3(void)
 // linked list.
 void ppmc_update_dec_order3(void)
 {
 // linked list.
 void ppmc_update_dec_order3(void)
 {

- struct _byte_and_freq *node;
+       struct _byte_and_freq *node;

 
 

- // First thing first, check if the hash entry is initialized
+       // First thing first, check if the hash entry is initialized

 
 

- if(order3_hasht[o3_cntxt]==0)    //no pointer to linked list defined yet
-   {
+       if(order3_hasht[o3_cntxt]==0)    //no pointer to linked list defined yet
+       {

 
 

-   if(ppmc_out_of_memory==1)
-     return;                //exit this function, we can't allocate memory
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate memory

 
 
 
 

-   // First create the context
+               // First create the context

 
 

-   order3_hasht[o3_cntxt]=_context_pool;
+               order3_hasht[o3_cntxt]=_context_pool;

 
 

-   _context_pool->next=0;       //this is the last element
-   _context_pool->order4321=full_o3_cntxt;      //put context
-   _context_pool->prob=_bytes_pool;             //pointer to linked list
-   _context_pool->max_cump=1;
-   _context_pool->defined_bytes=1;
+               _context_pool->next=0;       //this is the last element
+               _context_pool->order4321=full_o3_cntxt;      //put context
+               _context_pool->prob=_bytes_pool;             //pointer to linked list
+               _context_pool->max_cump=1;
+               _context_pool->defined_bytes=1;

 
 
 
 

-   // Do update of linked list variables and memory use of contexts
+               // Do update of linked list variables and memory use of contexts

 
 

-   ++_context_pool;           //next time use next entry (this is a pointer)
+               ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_context_pool==_context_pool_max)    //maximum reached
-     {
+               if(_context_pool==_context_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_context_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_context_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_context_pool=(struct context *)malloc
-       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-       {
-       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_context_pool=(struct context *)malloc
+                                               (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                       {
+                               printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _context_pool_array[_context_pool_index]=_context_pool;
+                       _context_pool_array[_context_pool_index]=_context_pool;

 
 

-     _context_pool_max=_context_pool+_context_pool_elements_inc;
+                       _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-     _context_pool_index++;
+                       _context_pool_index++;

 
 

-     }
+               }

 
 

-   // Now care about the first (and last) linked list element
+               // Now care about the first (and last) linked list element

 
 

-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

-   return;      //nothing else to do
-   }
+               return;      //nothing else to do
+       }

 
 
 
 

- // The byte was coded under order three, otherwise it was coded under a
- // lower order (never higher ones, remember that we are using update
- // exclusion) in this case we have to create a new node in the list.
+       // The byte was coded under order three, otherwise it was coded under a
+       // lower order (never higher ones, remember that we are using update
+       // exclusion) in this case we have to create a new node in the list.

 
 

- if(coded_in_order==3)  //coded under order-3
-   {
+       if(coded_in_order==3)  //coded under order-3
+       {

 
 

-   // Update its count and variables of this context and check for renormalization
+               // Update its count and variables of this context and check for renormalization

 
 

-   o3_ll_node->freq++;  //increment its frequency (rather probability)
+               o3_ll_node->freq++;  //increment its frequency (rather probability)

 
 

-   o3_context->max_cump++;   //total cump
+               o3_context->max_cump++;   //total cump

 
 

-   if(o3_ll_node->freq==255)    //do we have to renormalize?
-     ppmc_renormalize_order3(); //renormalize
+               if(o3_ll_node->freq==255)    //do we have to renormalize?
+                       ppmc_renormalize_order3(); //renormalize

 
 

-   }
- else
-   {
+       }
+       else
+       {

 
 

-   // Now we have two cases, under a given context (which we actually found)
-   // we coded an escape coded, in that case just create a new node in the
-   // linked list of bytes and probabilities. Otherwise we didn't find the
-   // same node so we have to create it in the linked list for context.
-   // And we can be sure that it at least has one element and that
-   // "o3_context" points to the last element, so we can put the new element.
+               // Now we have two cases, under a given context (which we actually found)
+               // we coded an escape coded, in that case just create a new node in the
+               // linked list of bytes and probabilities. Otherwise we didn't find the
+               // same node so we have to create it in the linked list for context.
+               // And we can be sure that it at least has one element and that
+               // "o3_context" points to the last element, so we can put the new element.

 
 

-   if(o3_context->order4321==full_o3_cntxt) //chech if that's the last
-     {                                      //element or the a context found
+               if(o3_context->order4321==full_o3_cntxt) //chech if that's the last
+               {                                      //element or the a context found

 
 

-     // Read till the end of the linked list
+                       // Read till the end of the linked list

 
 

-     node=o3_context->prob;    //get pointer to linked list
+                       node=o3_context->prob;    //get pointer to linked list

 
 

-     while(1)
-       {
-       if(node->next==0)          //check for the end of the linked list
-         break;
-       node=node->next;           //next node
-       }
+                       while(1)
+                       {
+                               if(node->next==0)          //check for the end of the linked list
+                                       break;
+                               node=node->next;           //next node
+                       }

 
 

-     // Now add element
+                       // Now add element

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate mem
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate mem

 
 

-     node->next=_bytes_pool;          //put it in the next free entry
-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       node->next=_bytes_pool;          //put it in the next free entry
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     o3_context->max_cump++;   //total cump
-     o3_context->defined_bytes++;   //total cump
+                       o3_context->max_cump++;   //total cump
+                       o3_context->defined_bytes++;   //total cump

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-         printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
-     }
-   else
-     {
+                       }
+               }
+               else
+               {

 
 

-     // We have to create a new context node
+                       // We have to create a new context node

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate memory
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate memory

 
 
 
 

-     // First create the context
+                       // First create the context

 
 

-     o3_context->next=_context_pool;
+                       o3_context->next=_context_pool;

 
 

-     _context_pool->next=0;       //this is the last element
-     _context_pool->order4321=full_o3_cntxt;      //put context
-     _context_pool->prob=_bytes_pool;             //pointer to linked list
-     _context_pool->max_cump=1;
-     _context_pool->defined_bytes=1;
+                       _context_pool->next=0;       //this is the last element
+                       _context_pool->order4321=full_o3_cntxt;      //put context
+                       _context_pool->prob=_bytes_pool;             //pointer to linked list
+                       _context_pool->max_cump=1;
+                       _context_pool->defined_bytes=1;

 
 
 
 

-     // Do update of linked list variables and memory use of contexts
+                       // Do update of linked list variables and memory use of contexts

 
 

-     ++_context_pool;           //next time use next entry (this is a pointer)
+                       ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_context_pool==_context_pool_max)    //maximum reached
-       {
+                       if(_context_pool==_context_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_context_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_context_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_context_pool=(struct context *)malloc
-         (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-         {
-         printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_context_pool=(struct context *)malloc
+                                                       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                               {
+                                       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _context_pool_array[_context_pool_index]=_context_pool;
+                               _context_pool_array[_context_pool_index]=_context_pool;

 
 

-       _context_pool_max=_context_pool+_context_pool_elements_inc;
+                               _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-       _context_pool_index++;
+                               _context_pool_index++;

 
 

-       }
+                       }

 
 

-     // Now care about the first (and last) linked list element
+                       // Now care about the first (and last) linked list element

 
 

-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-         printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
+                       }

 
 

-     }
+               }

 
 

- }
+       }

 
 }
 
 
 }
 


@@ -2202,12 +2202,12 @@ void ppmc_update_dec_order3(void)
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order3(void)
 {
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order3(void)
 {

- // To understand that remember that the escape allocated for the escape code
- // is above the current maximum cump and that it has a probability determined
- // by the scheme C.
+       // To understand that remember that the escape allocated for the escape code
+       // is above the current maximum cump and that it has a probability determined
+       // by the scheme C.

 
 

- symb_prob=o3_context->defined_bytes;
- symb_cump=o3_context->max_cump;
+       symb_prob=o3_context->defined_bytes;
+       symb_cump=o3_context->max_cump;

 }
 
 
 }
 
 


@@ -2239,61 +2239,61 @@ void ppmc_get_escape_prob_order3(void)
 // have to code under this context.
 char ppmc_get_totf_order4(void)
 {
 // have to code under this context.
 char ppmc_get_totf_order4(void)
 {

- struct context *cntxt_node;
+       struct context *cntxt_node;

 
 
 
 

- // First make the hash key for order-4
+       // First make the hash key for order-4

 
 

- o4_cntxt=ppmc_order4_hash_key(o1_byte,o2_byte,o3_byte,o4_byte);
- full_o4_cntxt=(o1_byte)+(o2_byte<<8)+(o3_byte<<16)+(o4_byte<<24);    //order-4
+       o4_cntxt=ppmc_order4_hash_key(o1_byte,o2_byte,o3_byte,o4_byte);
+       full_o4_cntxt=(o1_byte)+(o2_byte<<8)+(o3_byte<<16)+(o4_byte<<24);    //order-4

 
 
 
 

- // Now check the hash entry in the table
+       // Now check the hash entry in the table

 
 

- if(order4_hasht[o4_cntxt]==0)  //if 0, not initialized
-   {
+       if(order4_hasht[o4_cntxt]==0)  //if 0, not initialized
+       {

 
 

-   o4_context=0;        //no hash entry
+               o4_context=0;        //no hash entry

 
 

-   return 0;    //hash entry not initialized
-   }
+               return 0;    //hash entry not initialized
+       }

 
 
 
 

- // Now read trough the linked list of context searching current one
+       // Now read trough the linked list of context searching current one

 
 

- cntxt_node=order4_hasht[o4_cntxt];
+       cntxt_node=order4_hasht[o4_cntxt];

 
 

- while(1)
-   {
+       while(1)
+       {

 
 

-   if(cntxt_node->order4321==full_o4_cntxt)     //compare context
-     goto ppmc_gtfo4_cntxt_found;
+               if(cntxt_node->order4321==full_o4_cntxt)     //compare context
+                       goto ppmc_gtfo4_cntxt_found;

 
 

-   if(cntxt_node->next==0)      //end of context's linked list
-     break;
+               if(cntxt_node->next==0)      //end of context's linked list
+                       break;

 
 

-   cntxt_node=cntxt_node->next; //next element
+               cntxt_node=cntxt_node->next; //next element

 
 

-   }
+       }

 
 
 
 

- // Once there the context was not found
- o4_context=cntxt_node;    //pointer to last element in the linked list
+       // Once there the context was not found
+       o4_context=cntxt_node;    //pointer to last element in the linked list

 
 

- return 0;      //it was not present
+       return 0;      //it was not present

 
 
 
 

- // The context is found, so return pointer and cump
+       // The context is found, so return pointer and cump

 
 

- ppmc_gtfo4_cntxt_found:
+ppmc_gtfo4_cntxt_found:

 
 

- o4_context=cntxt_node;
+       o4_context=cntxt_node;

 
 

- // Total cump is current total cump plus the escape for the escape code
+       // Total cump is current total cump plus the escape for the escape code

 
 

- total_cump=o4_context->defined_bytes+o4_context->max_cump;
+       total_cump=o4_context->defined_bytes+o4_context->max_cump;

 
 

- return 1;      //context found
+       return 1;      //context found

 
 }
 
 
 }
 


@@ -2304,76 +2304,76 @@ char ppmc_get_totf_order4(void)
 // In case the byte is coded under this context, coded_in_order=4.
 char ppmc_code_byte_order4(void)
 {
 // In case the byte is coded under this context, coded_in_order=4.
 char ppmc_code_byte_order4(void)
 {

- unsigned long counter;
- struct _byte_and_freq *node;
+       unsigned long counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Get current context (if present) and total cump.
+       // Get current context (if present) and total cump.

 
 

- if(ppmc_get_totf_order4()==0)
-   return 0;
+       if(ppmc_get_totf_order4()==0)
+               return 0;

 
 
 
 

- // See if the byte is present and compute its cump at the same time
+       // See if the byte is present and compute its cump at the same time

 
 

- node=o4_context->prob; //pointer to first element in the linked list
+       node=o4_context->prob; //pointer to first element in the linked list

 
 

- symb_cump=0;   //the first symbol always has a 0 cump
+       symb_cump=0;   //the first symbol always has a 0 cump

 
 
 
 

- // Now search the byte in the linked list
+       // Now search the byte in the linked list

 
 

- do{
-   if(node->byte==byte)
-     goto ppmc_o4_byte_found;   //bad thing, I know, anyone has a better idea?
-   symb_cump+=node->freq;       //add the probability of this byte to the cump
-   if(node->next==0)
-     break;
-   node=node->next;             //next element in the linked list
-   }while(1);
+       do{
+               if(node->byte==byte)
+                       goto ppmc_o4_byte_found;   //bad thing, I know, anyone has a better idea?
+               symb_cump+=node->freq;       //add the probability of this byte to the cump
+               if(node->next==0)
+                       break;
+               node=node->next;             //next element in the linked list
+       }while(1);

 
 
 
 

- // If we reach that point, the byte was not found in the linked list
- // so we don't need the cump, we have to output an escape code, whose
- // probabilities are know using the context structure in the table.
+       // If we reach that point, the byte was not found in the linked list
+       // so we don't need the cump, we have to output an escape code, whose
+       // probabilities are know using the context structure in the table.

 
 

- // Byte was not present in the linked list, current node is the last one,
- // and that's the node needed for creating a new node, save it.
+       // Byte was not present in the linked list, current node is the last one,
+       // and that's the node needed for creating a new node, save it.

 
 

- o4_ll_node=node;
+       o4_ll_node=node;

 
 

- // Now get the probability and cump of the escape code
+       // Now get the probability and cump of the escape code

 
 

- symb_cump=o4_context->max_cump;
- symb_prob=o4_context->defined_bytes;
+       symb_cump=o4_context->max_cump;
+       symb_prob=o4_context->defined_bytes;

 
 

- // Code the escape code
- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       // Code the escape code
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

- return 0;
+       return 0;

 
 
 
 

- // That code is executed when the byte is found in the linked list
+       // That code is executed when the byte is found in the linked list

 
 

- ppmc_o4_byte_found:
+ppmc_o4_byte_found:

 
 
 
 

- // Everything has been tested, now we can feel free to code the byte,
- // the symb_cump is already computed, now get its probability and code
- // the byte, also save pointer to this element in the linked lists for
- // updating.
+       // Everything has been tested, now we can feel free to code the byte,
+       // the symb_cump is already computed, now get its probability and code
+       // the byte, also save pointer to this element in the linked lists for
+       // updating.

 
 

- coded_in_order=4;      //successfully coded under order-4
+       coded_in_order=4;      //successfully coded under order-4

 
 

- o4_ll_node=node;       //save it for updating
+       o4_ll_node=node;       //save it for updating

 
 

- symb_prob=node->freq;  //get the probability of the byte
+       symb_prob=node->freq;  //get the probability of the byte

 
 

- // Code it.
+       // Code it.

 
 

- range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);
+       range_coder_encode(&rc_coder,total_cump,symb_cump,symb_prob);

 
 

- return 1;      //byte coded under order-4
+       return 1;      //byte coded under order-4

 }
 
 
 }
 
 


@@ -2388,274 +2388,274 @@ char ppmc_code_byte_order4(void)
 void ppmc_update_order4(void)
 {
 
 void ppmc_update_order4(void)
 {
 

- // First thing first, check if the hash entry is initialized
+       // First thing first, check if the hash entry is initialized

 
 

- if(order4_hasht[o4_cntxt]==0)    //no pointer to linked list defined yet
-   {
+       if(order4_hasht[o4_cntxt]==0)    //no pointer to linked list defined yet
+       {

 
 

-   if(ppmc_out_of_memory==1)
-     return;                //exit this function, we can't allocate memory
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate memory

 
 
 
 

-   // First create the context
+               // First create the context

 
 

-   order4_hasht[o4_cntxt]=_context_pool;
+               order4_hasht[o4_cntxt]=_context_pool;

 
 

-   _context_pool->next=0;       //this is the last element
-   _context_pool->order4321=full_o4_cntxt;      //put context
-   _context_pool->prob=_bytes_pool;             //pointer to linked list
-   _context_pool->max_cump=1;
-   _context_pool->defined_bytes=1;
+               _context_pool->next=0;       //this is the last element
+               _context_pool->order4321=full_o4_cntxt;      //put context
+               _context_pool->prob=_bytes_pool;             //pointer to linked list
+               _context_pool->max_cump=1;
+               _context_pool->defined_bytes=1;

 
 
 
 

-   // Do update of linked list variables and memory use of contexts
+               // Do update of linked list variables and memory use of contexts

 
 

-   ++_context_pool;           //next time use next entry (this is a pointer)
+               ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_context_pool==_context_pool_max)    //maximum reached
-     {
+               if(_context_pool==_context_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_context_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_context_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_context_pool=(struct context *)malloc
-       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-       {
-       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_context_pool=(struct context *)malloc
+                                               (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                       {
+                               printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _context_pool_array[_context_pool_index]=_context_pool;
+                       _context_pool_array[_context_pool_index]=_context_pool;

 
 

-     _context_pool_max=_context_pool+_context_pool_elements_inc;
+                       _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-     _context_pool_index++;
+                       _context_pool_index++;

 
 

-     }
+               }

 
 
 
 

-   // Now care about the first (and last) linked list element
+               // Now care about the first (and last) linked list element

 
 

-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

-   return;      //nothing else to do
-   }
+               return;      //nothing else to do
+       }

 
 
 
 
 
 
 
 

- // The byte was coded under order three, otherwise it was coded under a
- // lower order (never higher ones, remember that we are using update
- // exclusion) in this case we have to create a new node in the list.
+       // The byte was coded under order three, otherwise it was coded under a
+       // lower order (never higher ones, remember that we are using update
+       // exclusion) in this case we have to create a new node in the list.

 
 

- if(coded_in_order==4)  //coded under order-4
-   {
+       if(coded_in_order==4)  //coded under order-4
+       {

 
 

-   // Update its count and variables of this context and check for renormalization
+               // Update its count and variables of this context and check for renormalization

 
 

-   o4_ll_node->freq++;  //increment its frequency (rather probability)
+               o4_ll_node->freq++;  //increment its frequency (rather probability)

 
 

-   o4_context->max_cump++;   //total cump
+               o4_context->max_cump++;   //total cump

 
 

-   if(o4_ll_node->freq==255)    //do we have to renormalize?
-     ppmc_renormalize_order4(); //renormalize
+               if(o4_ll_node->freq==255)    //do we have to renormalize?
+                       ppmc_renormalize_order4(); //renormalize

 
 

-   }
- else
-   {
+       }
+       else
+       {

 
 

-   // Now we have two cases, under a given context (which we actually found)
-   // we coded an escape coded, in that case just create a new node in the
-   // linked list of bytes and probabilities. Otherwise we didn't find the
-   // same node so we have to create it in the linked list for context.
-   // And we can be sure that it at least has one element and that
-   // "o4_context" points to the last element, so we can put the new element.
+               // Now we have two cases, under a given context (which we actually found)
+               // we coded an escape coded, in that case just create a new node in the
+               // linked list of bytes and probabilities. Otherwise we didn't find the
+               // same node so we have to create it in the linked list for context.
+               // And we can be sure that it at least has one element and that
+               // "o4_context" points to the last element, so we can put the new element.

 
 

-   if(o4_context->order4321==full_o4_cntxt) //chech if that's the last
-     {                                      //element or the a context found
+               if(o4_context->order4321==full_o4_cntxt) //chech if that's the last
+               {                                      //element or the a context found

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate mem
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate mem

 
 

-     o4_ll_node->next=_bytes_pool;    //put it in the next free entry
-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       o4_ll_node->next=_bytes_pool;    //put it in the next free entry
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     o4_context->max_cump++;   //total cump
-     o4_context->defined_bytes++;   //total cump
+                       o4_context->max_cump++;   //total cump
+                       o4_context->defined_bytes++;   //total cump

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-         printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
-     }
-   else
-     {
+                       }
+               }
+               else
+               {

 
 

-     // We have to create a new context node
+                       // We have to create a new context node

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate memory
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate memory

 
 
 
 

-     // First create the context
+                       // First create the context

 
 

-     o4_context->next=_context_pool;
+                       o4_context->next=_context_pool;

 
 

-     _context_pool->next=0;       //this is the last element
-     _context_pool->order4321=full_o4_cntxt;      //put context
-     _context_pool->prob=_bytes_pool;             //pointer to linked list
-     _context_pool->max_cump=1;
-     _context_pool->defined_bytes=1;
+                       _context_pool->next=0;       //this is the last element
+                       _context_pool->order4321=full_o4_cntxt;      //put context
+                       _context_pool->prob=_bytes_pool;             //pointer to linked list
+                       _context_pool->max_cump=1;
+                       _context_pool->defined_bytes=1;

 
 
 
 

-     // Do update of linked list variables and memory use of contexts
+                       // Do update of linked list variables and memory use of contexts

 
 

-     ++_context_pool;           //next time use next entry (this is a pointer)
+                       ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_context_pool==_context_pool_max)    //maximum reached
-       {
+                       if(_context_pool==_context_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_context_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_context_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_context_pool=(struct context *)malloc
-         (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-         {
-         printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_context_pool=(struct context *)malloc
+                                                       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                               {
+                                       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _context_pool_array[_context_pool_index]=_context_pool;
+                               _context_pool_array[_context_pool_index]=_context_pool;

 
 

-       _context_pool_max=_context_pool+_context_pool_elements_inc;
+                               _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-       _context_pool_index++;
+                               _context_pool_index++;

 
 

-       }
+                       }

 
 

-     // Now care about the first (and last) linked list element
+                       // Now care about the first (and last) linked list element

 
 

-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-         printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
+                       }

 
 

-     }
+               }

 
 

- }
+       }

 
 }
 
 
 }
 


@@ -2664,29 +2664,29 @@ void ppmc_update_order4(void)
 // variables.
 void ppmc_renormalize_order4(void)
 {
 // variables.
 void ppmc_renormalize_order4(void)
 {

- unsigned long counter;
- struct _byte_and_freq *node;
+       unsigned long counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Initialize variables. Defined bytes remain the same.
- o4_context->max_cump=0;        //clear them
+       // Initialize variables. Defined bytes remain the same.
+       o4_context->max_cump=0;        //clear them

 
 

- node=o4_context->prob;      //get pointer to lined lists
+       node=o4_context->prob;      //get pointer to lined lists

 
 

- // Divide all the probabilities by 2 and update context variables
- while(1)
-   {
-   node->freq>>=1;                      //divide by a factor of 2
+       // Divide all the probabilities by 2 and update context variables
+       while(1)
+       {
+               node->freq>>=1;                      //divide by a factor of 2

 
 

-   if(node->freq==0)    //don't allow a probability to be 0
-     node->freq=1;
+               if(node->freq==0)    //don't allow a probability to be 0
+                       node->freq=1;

 
 

-   o4_context->max_cump+=node->freq; //sum to the total cump
+               o4_context->max_cump+=node->freq; //sum to the total cump

 
 

-   if(node->next==0)    //last element
-     break;
-   node=node->next;
-   }
+               if(node->next==0)    //last element
+                       break;
+               node=node->next;
+       }

 
 
 }
 
 
 }


@@ -2702,79 +2702,79 @@ void ppmc_renormalize_order4(void)
 // "o4_ll_node" the pointer to its node. (so updating is faster)
 void ppmc_decode_order4(void)
 {
 // "o4_ll_node" the pointer to its node. (so updating is faster)
 void ppmc_decode_order4(void)
 {

- unsigned long current_cump, counter;
- struct _byte_and_freq *node;
+       unsigned long current_cump, counter;
+       struct _byte_and_freq *node;

 
 
 
 

- // Get current context (if present) and total cump.
+       // Get current context (if present) and total cump.

 
 

- if(ppmc_get_totf_order4()==0)
-   {
-   byte=-1;
-   return;
-   }
+       if(ppmc_get_totf_order4()==0)
+       {
+               byte=-1;
+               return;
+       }

 
 
 
 

- // Decode current cump
+       // Decode current cump

 
 

- symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it
+       symb_cump=range_decoder_decode(&rc_decoder,total_cump);        //decode it

 
 

- // Now check if it's an escape code
- if(symb_cump>=o4_context->max_cump)     //the defined code space for the escape code
-   {
+       // Now check if it's an escape code
+       if(symb_cump>=o4_context->max_cump)     //the defined code space for the escape code
+       {

 
 

-   // Update coding values
+               // Update coding values

 
 

-   ppmc_get_escape_prob_order4();
-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               ppmc_get_escape_prob_order4();
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Mark as escape code
+               // Mark as escape code

 
 

-   byte=-1;
+               byte=-1;

 
 

-   return;   //an escape code
-   }
- else
-   {
-   // Now we have to check what symbol it is
+               return;   //an escape code
+       }
+       else
+       {
+               // Now we have to check what symbol it is

 
 

-   current_cump=0;      //cump of the current symbol
+               current_cump=0;      //cump of the current symbol

 
 

-   node=o4_context->prob;    //get pointer to linked lists
+               node=o4_context->prob;    //get pointer to linked lists

 
 

-   while(1)
-     {
-     current_cump+=node->freq; //update cump
-     if(symb_cump<current_cump)
-       break;                  //symbol found, break search loop
+               while(1)
+               {
+                       current_cump+=node->freq; //update cump
+                       if(symb_cump<current_cump)
+                               break;                  //symbol found, break search loop

 
 

-     node=node->next;          //next element
-     //we have no need to check for the last symbol, we'll never read further
-     //the end of the linked lists, before we'll found the last byte.
-     }
+                       node=node->next;          //next element
+                       //we have no need to check for the last symbol, we'll never read further
+                       //the end of the linked lists, before we'll found the last byte.
+               }

 
 
 
 

-   //read byte value and probability
+               //read byte value and probability

 
 

-   symb_prob=node->freq;     //get the probability for updating the state
-   byte=node->byte;          //get byte
-   o4_ll_node=node;          //used for updating
+               symb_prob=node->freq;     //get the probability for updating the state
+               byte=node->byte;          //get byte
+               o4_ll_node=node;          //used for updating

 
 
 
 

-   // Get the cump of byte
+               // Get the cump of byte

 
 

-   symb_cump=current_cump-symb_prob;
+               symb_cump=current_cump-symb_prob;

 
 

-   // Update coding state
+               // Update coding state

 
 

-   range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);
+               range_decoder_update(&rc_decoder,total_cump,symb_cump,symb_prob);

 
 

-   // Update coded_in_order used for update exclusion
+               // Update coded_in_order used for update exclusion

 
 

-   coded_in_order=4;
+               coded_in_order=4;

 
 

-   return;
-   }
+               return;
+       }

 
 }
 
 
 }
 


@@ -2786,286 +2786,286 @@ void ppmc_decode_order4(void)
 // linked list.
 void ppmc_update_dec_order4(void)
 {
 // linked list.
 void ppmc_update_dec_order4(void)
 {

- struct _byte_and_freq *node;
+       struct _byte_and_freq *node;

 
 

- // First thing first, check if the hash entry is initialized
+       // First thing first, check if the hash entry is initialized

 
 

- if(order4_hasht[o4_cntxt]==0)    //no pointer to linked list defined yet
-   {
+       if(order4_hasht[o4_cntxt]==0)    //no pointer to linked list defined yet
+       {

 
 

-   if(ppmc_out_of_memory==1)
-     return;                //exit this function, we can't allocate memory
+               if(ppmc_out_of_memory==1)
+                       return;                //exit this function, we can't allocate memory

 
 
 
 

-   // First create the context
+               // First create the context

 
 

-   order4_hasht[o4_cntxt]=_context_pool;
+               order4_hasht[o4_cntxt]=_context_pool;

 
 

-   _context_pool->next=0;       //this is the last element
-   _context_pool->order4321=full_o4_cntxt;      //put context
-   _context_pool->prob=_bytes_pool;             //pointer to linked list
-   _context_pool->max_cump=1;
-   _context_pool->defined_bytes=1;
+               _context_pool->next=0;       //this is the last element
+               _context_pool->order4321=full_o4_cntxt;      //put context
+               _context_pool->prob=_bytes_pool;             //pointer to linked list
+               _context_pool->max_cump=1;
+               _context_pool->defined_bytes=1;

 
 
 
 

-   // Do update of linked list variables and memory use of contexts
+               // Do update of linked list variables and memory use of contexts

 
 

-   ++_context_pool;           //next time use next entry (this is a pointer)
+               ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_context_pool==_context_pool_max)    //maximum reached
-     {
+               if(_context_pool==_context_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_context_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_context_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_context_pool=(struct context *)malloc
-       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-       {
-       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_context_pool=(struct context *)malloc
+                                               (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                       {
+                               printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _context_pool_array[_context_pool_index]=_context_pool;
+                       _context_pool_array[_context_pool_index]=_context_pool;

 
 

-     _context_pool_max=_context_pool+_context_pool_elements_inc;
+                       _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-     _context_pool_index++;
+                       _context_pool_index++;

 
 

-     }
+               }

 
 

-   // Now care about the first (and last) linked list element
+               // Now care about the first (and last) linked list element

 
 

-   _bytes_pool->byte=byte;          //initialize byte to current one
-   _bytes_pool->freq=1;             //it appeared once
-   _bytes_pool->next=0;             //now this is last element in ll
+               _bytes_pool->byte=byte;          //initialize byte to current one
+               _bytes_pool->freq=1;             //it appeared once
+               _bytes_pool->next=0;             //now this is last element in ll

 
 

-   // Do update of linked list variables and memory use
+               // Do update of linked list variables and memory use

 
 

-   ++_bytes_pool;           //next time use next entry (this is a pointer)
+               ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-   if(_bytes_pool==_bytes_pool_max)    //maximum reached
-     {
+               if(_bytes_pool==_bytes_pool_max)    //maximum reached
+               {

 
 

-     // First check to see that we still have entries in the array
+                       // First check to see that we still have entries in the array

 
 

-     if(_bytes_pool_index==_mempool_max_index)
-       {
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if(_bytes_pool_index==_mempool_max_index)
+                       {
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     // Allocate memory for new buffer
+                       // Allocate memory for new buffer

 
 

-     if((_bytes_pool=(struct _byte_and_freq *)malloc
-       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-       {
-       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-       ppmc_out_of_memory=1;    //flush
-       return;
-       }
+                       if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                               (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                       {
+                               printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                               ppmc_out_of_memory=1;    //flush
+                               return;
+                       }

 
 

-     _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-     _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-     _bytes_pool_index++;
+                       _bytes_pool_index++;

 
 

-     }
+               }

 
 

-   return;      //nothing else to do
-   }
+               return;      //nothing else to do
+       }

 
 
 
 

- // The byte was coded under order four, otherwise it was coded under a
- // lower order (never higher ones, remember that we are using update
- // exclusion) in this case we have to create a new node in the list.
+       // The byte was coded under order four, otherwise it was coded under a
+       // lower order (never higher ones, remember that we are using update
+       // exclusion) in this case we have to create a new node in the list.

 
 

- if(coded_in_order==4)  //coded under order-4
-   {
+       if(coded_in_order==4)  //coded under order-4
+       {

 
 

-   // Update its count and variables of this context and check for renormalization
+               // Update its count and variables of this context and check for renormalization

 
 

-   o4_ll_node->freq++;  //increment its frequency (rather probability)
+               o4_ll_node->freq++;  //increment its frequency (rather probability)

 
 

-   o4_context->max_cump++;   //total cump
+               o4_context->max_cump++;   //total cump

 
 

-   if(o4_ll_node->freq==255)    //do we have to renormalize?
-     ppmc_renormalize_order4(); //renormalize
+               if(o4_ll_node->freq==255)    //do we have to renormalize?
+                       ppmc_renormalize_order4(); //renormalize

 
 

-   }
- else
-   {
+       }
+       else
+       {

 
 

-   // Now we have two cases, under a given context (which we actually found)
-   // we coded an escape coded, in that case just create a new node in the
-   // linked list of bytes and probabilities. Otherwise we didn't find the
-   // same node so we have to create it in the linked list for context.
-   // And we can be sure that it at least has one element and that
-   // "o4_context" points to the last element, so we can put the new element.
+               // Now we have two cases, under a given context (which we actually found)
+               // we coded an escape coded, in that case just create a new node in the
+               // linked list of bytes and probabilities. Otherwise we didn't find the
+               // same node so we have to create it in the linked list for context.
+               // And we can be sure that it at least has one element and that
+               // "o4_context" points to the last element, so we can put the new element.

 
 

-   if(o4_context->order4321==full_o4_cntxt) //chech if that's the last
-     {                                      //element or the a context found
+               if(o4_context->order4321==full_o4_cntxt) //chech if that's the last
+               {                                      //element or the a context found

 
 

-     // Read till the end of the linked list
+                       // Read till the end of the linked list

 
 

-     node=o4_context->prob;    //get pointer to linked list
+                       node=o4_context->prob;    //get pointer to linked list

 
 

-     while(1)
-       {
-       if(node->next==0)          //check for the end of the linked list
-         break;
-       node=node->next;           //next node
-       }
+                       while(1)
+                       {
+                               if(node->next==0)          //check for the end of the linked list
+                                       break;
+                               node=node->next;           //next node
+                       }

 
 

-     // Now add element
+                       // Now add element

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate mem
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate mem

 
 

-     node->next=_bytes_pool;          //put it in the next free entry
-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       node->next=_bytes_pool;          //put it in the next free entry
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     o4_context->max_cump++;   //total cump
-     o4_context->defined_bytes++;   //total cump
+                       o4_context->max_cump++;   //total cump
+                       o4_context->defined_bytes++;   //total cump

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-         printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
-     }
-   else
-     {
+                       }
+               }
+               else
+               {

 
 

-     // We have to create a new context node
+                       // We have to create a new context node

 
 

-     if(ppmc_out_of_memory==1)
-       return;                //exit this function, we can't allocate memory
+                       if(ppmc_out_of_memory==1)
+                               return;                //exit this function, we can't allocate memory

 
 
 
 

-     // First create the context
+                       // First create the context

 
 

-     o4_context->next=_context_pool;
+                       o4_context->next=_context_pool;

 
 

-     _context_pool->next=0;       //this is the last element
-     _context_pool->order4321=full_o4_cntxt;      //put context
-     _context_pool->prob=_bytes_pool;             //pointer to linked list
-     _context_pool->max_cump=1;
-     _context_pool->defined_bytes=1;
+                       _context_pool->next=0;       //this is the last element
+                       _context_pool->order4321=full_o4_cntxt;      //put context
+                       _context_pool->prob=_bytes_pool;             //pointer to linked list
+                       _context_pool->max_cump=1;
+                       _context_pool->defined_bytes=1;

 
 
 
 

-     // Do update of linked list variables and memory use of contexts
+                       // Do update of linked list variables and memory use of contexts

 
 

-     ++_context_pool;           //next time use next entry (this is a pointer)
+                       ++_context_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_context_pool==_context_pool_max)    //maximum reached
-       {
+                       if(_context_pool==_context_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_context_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_context_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_context_pool=(struct context *)malloc
-         (sizeof(struct context)*_context_pool_elements_inc))==NULL)
-         {
-         printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_context_pool=(struct context *)malloc
+                                                       (sizeof(struct context)*_context_pool_elements_inc))==NULL)
+                               {
+                                       printf("Can't allocate memory for context's memory pool.\nIndex: %d",_context_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _context_pool_array[_context_pool_index]=_context_pool;
+                               _context_pool_array[_context_pool_index]=_context_pool;

 
 

-       _context_pool_max=_context_pool+_context_pool_elements_inc;
+                               _context_pool_max=_context_pool+_context_pool_elements_inc;

 
 

-       _context_pool_index++;
+                               _context_pool_index++;

 
 

-       }
+                       }

 
 

-     // Now care about the first (and last) linked list element
+                       // Now care about the first (and last) linked list element

 
 

-     _bytes_pool->byte=byte;          //initialize byte to current one
-     _bytes_pool->freq=1;             //it appeared once
-     _bytes_pool->next=0;             //now this is last element in ll
+                       _bytes_pool->byte=byte;          //initialize byte to current one
+                       _bytes_pool->freq=1;             //it appeared once
+                       _bytes_pool->next=0;             //now this is last element in ll

 
 

-     // Do update of linked list variables and memory use
+                       // Do update of linked list variables and memory use

 
 

-     ++_bytes_pool;           //next time use next entry (this is a pointer)
+                       ++_bytes_pool;           //next time use next entry (this is a pointer)

 
 

-     if(_bytes_pool==_bytes_pool_max)    //maximum reached
-       {
+                       if(_bytes_pool==_bytes_pool_max)    //maximum reached
+                       {

 
 

-       // First check to see that we still have entries in the array
+                               // First check to see that we still have entries in the array

 
 

-       if(_bytes_pool_index==_mempool_max_index)
-         {
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if(_bytes_pool_index==_mempool_max_index)
+                               {
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       // Allocate memory for new buffer
+                               // Allocate memory for new buffer

 
 

-       if((_bytes_pool=(struct _byte_and_freq *)malloc
-         (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
-         {
-         printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
-         ppmc_out_of_memory=1;    //flush
-         return;
-         }
+                               if((_bytes_pool=(struct _byte_and_freq *)malloc
+                                                       (sizeof(struct _byte_and_freq)*_bytes_pool_elements_inc))==NULL)
+                               {
+                                       printf("\nCan't allocate memory for bytes memory pool.\nIndex: %d",_bytes_pool_index);
+                                       ppmc_out_of_memory=1;    //flush
+                                       return;
+                               }

 
 

-       _bytes_pool_array[_bytes_pool_index]=_bytes_pool;
+                               _bytes_pool_array[_bytes_pool_index]=_bytes_pool;

 
 

-       _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;
+                               _bytes_pool_max=_bytes_pool+_bytes_pool_elements_inc;

 
 

-       _bytes_pool_index++;
+                               _bytes_pool_index++;

 
 

-       }
+                       }

 
 

-     }
+               }

 
 

- }
+       }

 
 }
 
 
 }
 


@@ -3074,11 +3074,11 @@ void ppmc_update_dec_order4(void)
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order4(void)
 {
 // This function returns the probability for the escape codes in the variables
 void ppmc_get_escape_prob_order4(void)
 {

- // To understand that remember that the escape allocated for the escape code
- // is above the current maximum cump and that it has a probability determined
- // by the scheme C.
+       // To understand that remember that the escape allocated for the escape code
+       // is above the current maximum cump and that it has a probability determined
+       // by the scheme C.

 
 

- symb_prob=o4_context->defined_bytes;
- symb_cump=o4_context->max_cump;
+       symb_prob=o4_context->defined_bytes;
+       symb_cump=o4_context->max_cump;

 }
 
 }