path: root/converter/other/fiasco/codec/control.c

/*
 *  control.c:          Control unit of WFA structure
 *
 *  Written by:         Ullrich Hafner
 *
 *  This file is part of FIASCO (Fractal Image And Sequence COdec)
 *  Copyright (C) 1994-2000 Ullrich Hafner
 */

/*
 *  $Date: 2000/06/14 20:50:51 $
 *  $Author: hafner $
 *  $Revision: 5.1 $
 *  $State: Exp $
 */

#include "config.h"

#include <string.h>

#include "types.h"
#include "macros.h"
#include "error.h"

#include "cwfa.h"
#include "ip.h"
#include "misc.h"
#include "wfalib.h"
#include "control.h"

/*****************************************************************************

                                prototypes

*****************************************************************************/

static void
clear_or_alloc (real_t **ptr, size_t size);
static void
compute_images (unsigned from, unsigned to, const wfa_t *wfa, coding_t *c);

/*****************************************************************************

                                public code

*****************************************************************************/

void
append_state (bool_t auxiliary_state, real_t final, unsigned level_of_state,
              wfa_t *wfa, coding_t *c)
/*
 *  Append a 'wfa' state. If 'auxiliary_state' == YES then
 *  allocate memory for inner products and state images.  'final' is
 *  the final distribution of the new state. 'level_of_state' is the
 *  level of the subimage which is represented by this state
 *
 *  No return value.
 *
 *  Side effects:
 *      The WFA information are updated in structure 'wfa'
 *      State images are computed and inner products are cleared (in 'c')
 */
{
   wfa->final_distribution [wfa->states] = final;
   wfa->level_of_state [wfa->states]     = level_of_state;

   if (!auxiliary_state)
   {
      unsigned level;

      wfa->domain_type [wfa->states] = USE_DOMAIN_MASK;

      /*
       *  Allocate memory for inner products and for state images
       */
      clear_or_alloc (&c->images_of_state [wfa->states],
                      size_of_tree (c->options.images_level));

      for (level = c->options.images_level + 1;
           level <= c->options.lc_max_level; level++)
         clear_or_alloc (&c->ip_states_state [wfa->states][level],
                         wfa->states + 1);

      clear_or_alloc (&c->ip_images_state [wfa->states],
                      size_of_tree (c->products_level));

      /*
       *  Compute the images of the current state at level 0,..,'imageslevel'
       */

      c->images_of_state [wfa->states][0] = final;
      compute_images (wfa->states, wfa->states, wfa, c);

      /*
       *  Compute the inner products between the current state and the
       *  old states 0,...,'states'-1
       */

      compute_ip_states_state (wfa->states, wfa->states, wfa, c);
   }
   else
   {
      unsigned level;

      wfa->domain_type [wfa->states] = 0;

      /*
       *  Free the allocated memory
       */
      if (c->images_of_state [wfa->states] != NULL)
      {
         Free (c->images_of_state [wfa->states]);
         c->images_of_state [wfa->states] = NULL;
      }
      for (level = 0; level <= c->options.lc_max_level; level++)
         if (c->ip_states_state [wfa->states][level])
         {
            Free (c->ip_states_state [wfa->states][level]);
            c->ip_states_state [wfa->states][level] = NULL;
         }
      if (c->ip_images_state [wfa->states])
      {
         Free (c->ip_images_state [wfa->states]);
         c->ip_images_state [wfa->states] = NULL;
      }
   }

   wfa->states++;
   if (wfa->states >= MAXSTATES)
      error ("Maximum number of states reached!");
}

void
append_basis_states (unsigned basis_states, wfa_t *wfa, coding_t *c)
/*
 *  Append the WFA basis states 0, ... , ('basis_states' - 1).
 *
 *  No return value.
 *
 *  Side effects:
 *      The WFA information are updated in structure 'wfa'
 *      State images and inner products are computed (in 'c')
 */
{
   unsigned level, state;

   /*
    *  Allocate memory
    */

   for (state = 0; state < basis_states; state++)
   {
      clear_or_alloc (&c->images_of_state [state],
                      size_of_tree (c->options.images_level));

      for (level = c->options.images_level + 1;
           level <= c->options.lc_max_level; level++)
         clear_or_alloc (&c->ip_states_state [state][level], state + 1);

      clear_or_alloc (&c->ip_images_state [state],
                      size_of_tree (c->products_level));

      c->images_of_state [state][0] = wfa->final_distribution [state];
      wfa->level_of_state [state]   = -1;
   }

   compute_images (0, basis_states - 1, wfa, c);
   compute_ip_states_state (0, basis_states - 1, wfa, c);
   wfa->states = basis_states;

   if (wfa->states >= MAXSTATES)
      error ("Maximum number of states reached!");
}

void
append_transitions (unsigned state, unsigned label, const real_t *weight,
                    const word_t *into, wfa_t *wfa)
/*
 *  Append the 'wfa' transitions (given by the arrays 'weight' and 'into')
 *  of the range ('state','label').
 *
 *  No return value.
 *
 *  Side effects:
 *      new 'wfa' edges are appended
 */
{
   unsigned edge;

   wfa->y_column [state][label] = 0;
   for (edge = 0; isedge (into [edge]); edge++)
   {
      append_edge (state, into [edge], weight [edge], label, wfa);
      if (into [edge] == wfa->y_state [state][label])
         wfa->y_column [state][label] = 1;
   }
}

/*****************************************************************************

                                private code

*****************************************************************************/

static void
compute_images (unsigned from, unsigned to, const wfa_t *wfa, coding_t *c)
/*
 *  Computes the images of the given states 'from', ... , 'to'
 *  at level 0,...,'c->imagelevel'.
 *  Uses the fact that each state image is a linear combination of state
 *  images, i.e. s_i := c_0 s_0 + ... + c_i s_i.
 */
{
   unsigned label, level, state;

   /*
    *  Compute the images Phi(state)
    *  #                level = 0
    *  ##               level = 1
    *  ####             level = 2
    *  ########         level = 3
    *  ...
    *  ########...##    level = imageslevel
    */

   for (level = 1; level <= c->options.images_level; level++)
      for (state = from; state <= to; state++)
         for (label = 0; label < MAXLABELS; label++)
         {
            real_t   *dst, *src;
            unsigned  edge;
            int       domain;           /* current domain */

            if (ischild (domain = wfa->tree[state][label]))
            {
               dst = c->images_of_state [state] + address_of_level (level) +
                     label * size_of_level (level - 1);
               src = c->images_of_state [domain]
                     + address_of_level (level - 1);
               memcpy (dst, src, size_of_level (level - 1) * sizeof (real_t));
            }
            for (edge = 0; isedge (domain = wfa->into[state][label][edge]);
                 edge++)
            {
               unsigned n;
               real_t   weight = wfa->weight [state][label][edge];

               dst = c->images_of_state [state] + address_of_level (level) +
                     label * size_of_level (level - 1);
               src = c->images_of_state [domain]
                     + address_of_level (level - 1);

               for (n = size_of_level (level - 1); n; n--)
                  *dst++ += *src++ * weight;
            }
         }

}

static void
clear_or_alloc (real_t **ptr, size_t size)
/*
 *  if *ptr == NULL     allocate memory with Calloc
 *  otherwise           fill the real_t-array ptr[] with 0
 */
{
   if (*ptr == NULL)
      *ptr = Calloc (size, sizeof (real_t));
   else
      memset (*ptr, 0, size * sizeof (real_t));

}