bisk3d.c

spiht for linux this is used to decod and encode vedio i wich all enjoy

                                         mask,
                                         subband);
      if (return_value == 1)
        {
          QccErrorAddMessage("(QccWAVbisk3DInitialization): Error calling QccWAVbisk3DSetSize()");
          return(1);
        }
      
      if (return_value != 2)
        {
          if ((set_node =
               QccListCreateNode(sizeof(QccWAVbisk3DSet), &set)) == NULL)
            {
              QccErrorAddMessage("(QccWAVbisk3DInitialization): Error calling QccListCreateNode()");
              return(1);
            }
          if (QccWAVbisk3DInsertSet(LIS,
                                    set_node,
                                    NULL))
            {
              QccErrorAddMessage("(QccWAVbisk3DInitialization): Error calling QccWAVbisk3DInsertSet()");
              return(1);
            }
        }
    }

  QccListInitialize(LSP);
  
  return(0);
}


static void QccWAVbisk3DFreeLIS(QccList *LIS)
{
  QccListNode *current_list_node;
  QccList *current_list;

  current_list_node = LIS->start;
  while (current_list_node != NULL)
    {
      current_list = (QccList *)(current_list_node->value);
      QccListFree(current_list);
      current_list_node = current_list_node->next;
    }

  QccListFree(LIS);
}


static int QccWAVbisk3DSignificanceMap(const QccWAVSubbandPyramid3D
                                       *coefficients,
                                       const QccWAVSubbandPyramid3D *mask,
                                       unsigned char ***state_array,
                                       double threshold)
{
  int frame, row, col;

  if (state_array == NULL)
    return(0);

  for (frame = 0; frame < coefficients->num_frames; frame++)
    for (row = 0; row < coefficients->num_rows; row++)
      for (col = 0; col < coefficients->num_cols; col++)
        if (!QccWAVbisk3DTransparent(mask, frame, row, col))
          if (coefficients->volume[frame][row][col] >= threshold)
            QccWAVbisk3DPutSignificance(&state_array[frame][row][col],
                                      QCCBISK3D_SIGNIFICANT);
          else
            QccWAVbisk3DPutSignificance(&state_array[frame][row][col],
                                      QCCBISK3D_INSIGNIFICANT);
        else
          QccWAVbisk3DPutSignificance(&state_array[frame][row][col],
                                    QCCBISK3D_INSIGNIFICANT);

  return(0);
}


static int QccWAVbisk3DSetSignificance(QccWAVbisk3DSet *set,
                                       unsigned char ***state_array)
{
  int frame, row, col;

  set->significance = QCCBISK3D_INSIGNIFICANT;

  for (frame=0; frame < set->num_frames; frame++)
    for (row = 0; row < set->num_rows; row++)
      for (col = 0; col < set->num_cols; col++)
        {
          if (QccWAVbisk3DGetSignificance(state_array
                                          [set->origin_frame + frame]
                                          [set->origin_row + row]
                                          [set->origin_col + col]) ==
              QCCBISK3D_SIGNIFICANT)
            {
              set->significance = QCCBISK3D_SIGNIFICANT;
              return(0);
            }
        }

  return(0);
}


static int QccWAVbisk3DInputOutputSetSignificance(QccWAVbisk3DSet *current_set,
                                                  unsigned char ***state_array,
                                                  QccENTArithmeticModel *model,
                                                  QccBitBuffer *buffer)
{
  int symbol;
  int return_value;

  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      if (model->current_context != QCCBISK3D_CONTEXT_NOCODE)
        {
          if (QccWAVbisk3DSetSignificance(current_set,
                                          state_array))
            {
              QccErrorAddMessage("(QccWAVbisk3DInputOutputSetSignificance): Error calling QccWAVbisk3DSetSignificance()");
              return(1);
            }
          symbol = (current_set->significance == QCCBISK3D_SIGNIFICANT);
          return_value =
            QccENTArithmeticEncode(&symbol, 1,
                                   model, buffer);
          if (return_value == 2)
            return(2);
          else
            if (return_value)
              {
                QccErrorAddMessage("(QccWAVbisk3DInputOutputSetSignificance): Error calling QccENTArithmeticEncode()");
                return(1);
              }
        }
      else
        current_set->significance = QCCBISK3D_SIGNIFICANT;
    }
  else
    if (model->current_context != QCCBISK3D_CONTEXT_NOCODE)
      {
        if (QccENTArithmeticDecode(buffer,
                                   model,
                                   &symbol, 1))
          return(2);
        current_set->significance =
          (symbol) ? QCCBISK3D_SIGNIFICANT : QCCBISK3D_INSIGNIFICANT;
      }
    else
      current_set->significance = QCCBISK3D_SIGNIFICANT;

  return(0);
}


static int QccWAVbisk3DInputOutputSign(unsigned char *state,
                                       double *coefficient,
                                       double threshold,
                                       QccENTArithmeticModel *model,
                                       QccBitBuffer *buffer)
{
  int return_value;
  int symbol;

  model->current_context = QCCBISK3D_CONTEXT_SIGN;
  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      symbol = (QccWAVbisk3DGetSign(*state) == QCCBISK3D_POSITIVE);
      *coefficient -= threshold;

      return_value =
        QccENTArithmeticEncode(&symbol, 1,
                               model, buffer);
      if (return_value == 2)
        return(2);
      else
        if (return_value)
          {
            QccErrorAddMessage("(QccWAVbisk3DInputOutputSign): Error calling QccENTArithmeticEncode()");
            return(1);
          }
    }
  else
    {
      if (QccENTArithmeticDecode(buffer,
                                 model,
                                 &symbol, 1))
        return(2);

      QccWAVbisk3DPutSign(state,
                          (symbol) ? QCCBISK3D_POSITIVE : QCCBISK3D_NEGATIVE);

      *coefficient = 1.5 * threshold;
    }

  return(0);
}


static int QccWAVbisk3DPartitionSet(const QccWAVbisk3DSet *set,
                                    const QccWAVSubbandPyramid3D *mask,
                                    QccListNode **subset_node1,
                                    QccListNode **subset_node2)
{
  QccWAVbisk3DSet subset1;
  QccWAVbisk3DSet subset2;
  int split_frame;
  int split_row;
  int split_col;
  int num_frames;
  int num_rows;
  int num_cols;
  int return_value;
  int split_direction;

  split_frame = (set->num_frames)/2;
  split_row = (set->num_rows)/2;
  split_col = (set->num_cols)/2;
  
  //determines the largest split dimension and splits the dimension in half
  
  // frame:col precidence
  if ((split_frame >= split_row) && (split_frame >= split_col))
    split_direction = QCCBISK3D_SPECTRALSPLIT;
  else 
    if ((split_col > split_frame) && (split_col >= split_row))
      split_direction = QCCBISK3D_HORIZONTALSPLIT;
    else 
      if ((split_row > split_frame) && (split_row > split_col))
        split_direction = QCCBISK3D_VERTICALSPLIT;
      else 
        split_direction = -1;
  
  // initialize the subset split data
  subset1.vertical_splits = set->vertical_splits;
  subset1.horizontal_splits = set->horizontal_splits;
  subset1.temporal_splits = set->temporal_splits;
  subset2.vertical_splits = set->vertical_splits;
  subset2.horizontal_splits = set->horizontal_splits;
  subset2.temporal_splits = set->temporal_splits;
  
  switch (split_direction)
    {
    case QCCBISK3D_HORIZONTALSPLIT:
      {
        num_cols = set->num_cols - split_col;
        subset1.vertical_splits++;
        subset2.vertical_splits++;

        /* Right */
        subset1.origin_frame = set->origin_frame;
        subset1.origin_row = set->origin_row;
        subset1.origin_col = set->origin_col + num_cols;
        subset1.num_frames = set->num_frames;
        subset1.num_rows = set->num_rows;
        subset1.num_cols = set->num_cols - num_cols;

        /* Left */
        subset2.origin_frame = set->origin_frame;
        subset2.origin_row = set->origin_row;
        subset2.origin_col = set->origin_col;
        subset2.num_frames = set->num_frames;
        subset2.num_rows = set->num_rows;
        subset2.num_cols = num_cols;
        break;
      }
    case QCCBISK3D_VERTICALSPLIT:
      {
        num_rows = set->num_rows - split_row;
        subset1.horizontal_splits++;
        subset2.horizontal_splits++;

        /* Bottom */
        subset1.origin_frame = set->origin_frame;
        subset1.origin_row = set->origin_row + num_rows;
        subset1.origin_col = set->origin_col;
        subset1.num_frames = set->num_frames;
        subset1.num_rows = set->num_rows - num_rows;
        subset1.num_cols = set->num_cols;

        /* Top */
        subset2.origin_frame = set->origin_frame;
        subset2.origin_row = set->origin_row;
        subset2.origin_col = set->origin_col;
        subset2.num_frames = set->num_frames;
        subset2.num_rows = num_rows;
        subset2.num_cols = set->num_cols;
        break;
      }
    case QCCBISK3D_SPECTRALSPLIT:
      {
        num_frames = set->num_frames - split_frame;
        subset1.temporal_splits++;
        subset2.temporal_splits++;

        /* Front */
        subset1.origin_frame = set->origin_frame;
        subset1.origin_row = set->origin_row;
        subset1.origin_col = set->origin_col;
        subset1.num_frames = num_frames;
        subset1.num_rows = set->num_rows;
        subset1.num_cols = set->num_cols;
        
        /* Back */
        subset2.origin_frame = set->origin_frame + num_frames;
        subset2.origin_row = set->origin_row;
        subset2.origin_col = set->origin_col;
        subset2.num_frames = set->num_frames - num_frames;
        subset2.num_rows = set->num_rows;
        subset2.num_cols = set->num_cols;
        break;
      }
    default:
      {
        QccErrorAddMessage("(QccWAVbisk3DPartitionSet): Error split_direction not valid");
        return(1);
      }
    }

  subset1.significance = QCCBISK3D_INSIGNIFICANT;
  subset2.significance = QCCBISK3D_INSIGNIFICANT;

  return_value = QccWAVbisk3DSetShrink(&subset1, mask);
  if (return_value == 1)
    {
      QccErrorAddMessage("(QccWAVbisk3DPartitionSet): Error calling QccWAVbisk3DSetShrink()");
      return(1);
    }
  if (return_value == 2)
    subset1.significance = QCCBISK3D_EMPTYSET;

  return_value = QccWAVbisk3DSetShrink(&subset2, mask);
  if (return_value == 1)
    {
      QccErrorAddMessage("(QccWAVbisk3DPartitionSet): Error calling QccWAVbisk3DSetShrink()");
      return(1);
    }
  if (return_value == 2)
    subset2.significance = QCCBISK3D_EMPTYSET;
  
  if ((*subset_node1 =
       QccListCreateNode(sizeof(QccWAVbisk3DSet), &subset1)) == NULL)
    {
      QccErrorAddMessage("(QccWAVbisk3DPartitionSet): Error calling QccListCreateNode()");
      return(1);
    }
  if ((*subset_node2 =
       QccListCreateNode(sizeof(QccWAVbisk3DSet), &subset2)) == NULL)
    {
      QccErrorAddMessage("(QccWAVbisk3DPartitionSet): Error calling QccListCreateNode()");
      return(1);
    }
  
  return(0);
}


static int QccWAVbisk3DProcessSet(QccListNode *current_set_node,
                                  QccListNode *current_list_node,
                                  QccList *LIS,
                                  QccList *LSP,
                                  QccList *garbage,
                                  QccWAVSubbandPyramid3D *coefficients,
                                  const QccWAVSubbandPyramid3D *mask,
                                  unsigned char ***state_array,
                                  double threshold,
                                  QccENTArithmeticModel *model,
                                  QccBitBuffer *buffer);


static int QccWAVbisk3DCodeSet(QccListNode *current_set_node,
                               QccListNode *current_list_node,
                               QccList *LIS,
                               QccList *LSP,
                               QccList *garbage,
                               QccWAVSubbandPyramid3D *coefficients,
                               const QccWAVSubbandPyramid3D *mask,
                               unsigned char ***state_array,
                               double threshold,
                               QccENTArithmeticModel *model,
                               QccBitBuffer *buffer)
{
  int return_value;
  QccWAVbisk3DSet *current_set = (QccWAVbisk3DSet *)(current_set_node->value);
  QccWAVbisk3DSet *subset1 = NULL;
  QccListNode *subset_node1;
  QccListNode *subset_node2;

  if (QccWAVbisk3DPartitionSet(current_set,
                               mask,
                               &subset_node1,
                               &subset_node2))
    {