tarp3d.c

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

		return(1);
	      }
	}
      else
	{
	  if (QccENTArithmeticDecode(buffer,
				     model,
				     &symbol, 1))
	    return(2);
          
	  QccWAVTarp3DSetSign(state, symbol);
	}
    }
  
  return(0);
}


static int QccWAVTarp3DSignificancePassSubband(QccWAVSubbandPyramid3D
                                               *coefficients,
                                               QccWAVSubbandPyramid3D
                                               *mask,
                                               unsigned char ***state_array,
                                               double alpha,
                                               int subband,
                                               double threshold,
                                               QccENTArithmeticModel *model,
                                               QccBitBuffer *buffer)
{
  int return_value;
  int subband_origin_frame;
  int subband_origin_row;
  int subband_origin_col;
  int subband_num_frames;
  int subband_num_rows;
  int subband_num_cols;
  int frame, row, col;
  QccVector p2 = NULL;
  QccVector p5 = NULL;
  QccMatrix p1 = NULL;
  QccMatrix p4 = NULL;
  QccMatrix p3 = NULL;
  double beta;
  double p;
  int v;
  int transparent;

  beta = (1.0-alpha)*(1.0-alpha)*(1.0-alpha)/(3.0*alpha+alpha*alpha*alpha);
  
  if (QccWAVSubbandPyramid3DSubbandSize(coefficients,
                                        subband,
                                        &subband_num_frames,
                                        &subband_num_rows,
                                        &subband_num_cols))
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccWAVSubbandPyramid3DSubbandSize()");
      goto Error;
    }
  if (QccWAVSubbandPyramid3DSubbandOffsets(coefficients,
                                           subband,
                                           &subband_origin_frame,
                                           &subband_origin_row,
                                           &subband_origin_col))
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccWAVSubbandPyramid3DSubbandOffsets()");
      goto Error;
    }
  
  if ((!subband_num_frames) || (!subband_num_rows) || (!subband_num_cols))
    return(0);

  if ((p2 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  if ((p5 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccVectorAlloc()");
      goto Error;
    }
  
  if ((p1 = QccMatrixAlloc(subband_num_rows, subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccMatrixAlloc()");
      goto Error;
    }
  
  if ((p4 = QccMatrixAlloc(subband_num_rows, subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccMatrixAlloc()");
      goto Error;
    }
  
  if ((p3 = QccMatrixAlloc(subband_num_rows, subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccMatrixAlloc()");
      goto Error;
    }
  
  for (row = 0; row < subband_num_rows; row++)
    for (col = 0; col < subband_num_cols; col++)
      p3[row][col] = QCCTARP3D_BOUNDARY_VALUE;   
  
  for (frame = 0; frame < subband_num_frames; frame++)
    {
      for (col = 0; col < subband_num_cols; col++)
        p2[col] = QCCTARP3D_BOUNDARY_VALUE;
      for (row = 0; row < subband_num_rows; row++)
        {
          for (col = 0; col < subband_num_cols; col++)
            {
              transparent =
                (mask != NULL) ? 
                QccAlphaTransparent(mask->volume
                                    [subband_origin_frame + frame]
                                    [subband_origin_row + row]
                                    [subband_origin_col + col]) : 0;

              if (!transparent)
                {
                  if (col == 0)
                    p =
                      alpha * (QCCTARP3D_BOUNDARY_VALUE + p2[col] +
                               p3[row][col]);
                  else
                    p = alpha * (p1[row][col-1] + p2[col] + p3[row][col]);
                  
                  return_value =
                    QccWAVTarp3DSignificanceInputOutput(&coefficients->volume
                                                        [subband_origin_frame +
                                                         frame]
                                                        [subband_origin_row +
                                                         row]
                                                        [subband_origin_col +
                                                         col],
                                                        p,
                                                        threshold,
                                                        &state_array
                                                        [subband_origin_frame +
                                                         frame]
                                                        [subband_origin_row +
                                                         row]
                                                        [subband_origin_col +
                                                         col],
                                                        model,
                                                        buffer);
                  if (return_value == 2)
                    goto Return;
                  else
                    if (return_value)
                      {
                        QccErrorAddMessage("(QccWAVTarp3DSignificancePassSubband): Error calling QccWAVTarp3DSignificanceInputOutput()");
                        goto Error;
                      }
                  
                  v =
                    QccWAVTarp3DGetSignificance(state_array
                                                [subband_origin_frame + frame]
                                                [subband_origin_row + row]
                                                [subband_origin_col + col]) !=
                    QCCTARP3D_INSIGNIFICANT;
                  if (col == 0)
                    p1[row][col] = alpha * QCCTARP3D_BOUNDARY_VALUE + beta * v;
                  else
                    p1[row][col] = alpha * p1[row][col-1] + beta * v;
                  p2[col] = p1[row][col] + alpha * p2[col];
                }
            }
          
          for (col = subband_num_cols - 1; col >= 0; col--)
            {
              transparent =
                (mask != NULL) ? 
                QccAlphaTransparent(mask->volume
                                    [subband_origin_frame + frame]
                                    [subband_origin_row + row]
                                    [subband_origin_col + col]) : 0;

              if (!transparent)
                {
                  if (col == subband_num_cols - 1)
                    p2[col] += (alpha * QCCTARP3D_BOUNDARY_VALUE);
                  else
                    p2[col] += (alpha * p4[row][col+1]);
                  p3[row][col] = p2[col] + alpha * p3[row][col];
                  v =
                    QccWAVTarp3DGetSignificance(state_array
                                                [subband_origin_frame + frame]
                                                [subband_origin_row + row]
                                                [subband_origin_col + col]) !=
                    QCCTARP3D_INSIGNIFICANT;
                  if (col == subband_num_cols - 1)
                    p4[row][col] = alpha * QCCTARP3D_BOUNDARY_VALUE + beta * v;
                  else
                    p4[row][col] = alpha * p4[row][col+1] + beta * v;
                }
            }
        }
      
      for (col = 0; col < subband_num_cols; col++)
        p5[col] = QCCTARP3D_BOUNDARY_VALUE;
      for (row = subband_num_rows - 1; row >= 0 ; row--)
        {
          for (col = 0; col < subband_num_cols; col++)
            {
              transparent =
                (mask != NULL) ? 
                QccAlphaTransparent(mask->volume
                                    [subband_origin_frame + frame]
                                    [subband_origin_row + row]
                                    [subband_origin_col + col]) : 0;

              if (!transparent)
                {
                  p3[row][col] += (alpha * p5[col]);
                  if (col == subband_num_cols - 1)
                    p5[col] = p1[row][col] + alpha * p5[col] +
                      alpha * QCCTARP3D_BOUNDARY_VALUE;
                  else
                    p5[col] = p1[row][col] + alpha * p5[col] +
                      alpha * p4[row][col+1];
                }
            }
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(p2);
  QccVectorFree(p5);
  QccMatrixFree(p1, subband_num_rows);
  QccMatrixFree(p4, subband_num_rows);
  QccMatrixFree(p3, subband_num_rows);
  return(return_value);
}


static int QccWAVTarp3DSignificancePass(QccWAVSubbandPyramid3D *coefficients,
                                        QccWAVSubbandPyramid3D *mask,
                                        unsigned char ***state_array,
                                        double alpha,
                                        double threshold,
                                        QccENTArithmeticModel *model,
                                        QccBitBuffer *buffer)
{
  int subband;
  int num_subbands;
  int return_value;
  
  if (coefficients->transform_type ==
      QCCWAVSUBBANDPYRAMID3D_DYADIC)
    num_subbands =
      QccWAVSubbandPyramid3DNumLevelsToNumSubbandsDyadic(coefficients->spatial_num_levels);
  else
    num_subbands =
      QccWAVSubbandPyramid3DNumLevelsToNumSubbandsPacket(coefficients->temporal_num_levels,
                                                         coefficients->spatial_num_levels);
  
  for (subband = 0; subband < num_subbands; subband++)
    {
      return_value =
	QccWAVTarp3DSignificancePassSubband(coefficients,
                                            mask,
                                            state_array,
                                            alpha,
                                            subband,
                                            threshold,
                                            model,
                                            buffer);
      if (return_value == 1)
	{
	  QccErrorAddMessage("(QccWAVTarp3DSignificancePass): Error calling QccWAVTarp3DSignificancePassSubband()");
	  return(1);
	}
      else
	if (return_value == 2)
	  return(2);
    }
  
  return(0);
}


static int QccWAVTarp3DRefinementInputOutput(double *coefficient,
                                             double threshold,
                                             QccENTArithmeticModel *model,
                                             QccBitBuffer *buffer)
{
  int return_value;
  int symbol;
  
  if (QccWAVTarp3DUpdateModel(model, 0.5))
    {
      QccErrorAddMessage("(QccWAVTarp3DRefinementInputOutput): Error calling QccWAVTarp3DUpdateModel()");
      return(1);
    }
  
  if (buffer->type == QCCBITBUFFER_OUTPUT)
    {
      if (*coefficient >= threshold)
	{
	  symbol = 1;
	  *coefficient -= threshold;
	}
      else
	symbol = 0;
      
      return_value =
	QccENTArithmeticEncode(&symbol, 1,
			       model, buffer);
      if (return_value == 2)
	return(2);
      else
	if (return_value)
	  {
	    QccErrorAddMessage("(QccWAVTarp3DRefinementInputOutput): Error calling QccENTArithmeticEncode()");
	    return(1);
	  }
    }
  else
    {
      if (QccENTArithmeticDecode(buffer,
				 model,
				 &symbol, 1))
	return(2);
      
      *coefficient +=
	(symbol == 1) ? threshold / 2 : -threshold / 2;
    }
  
  return(0);
}


static int QccWAVTarp3DRefinementPassSubband(QccWAVSubbandPyramid3D
                                             *coefficients,
                                             QccWAVSubbandPyramid3D
                                             *mask,
                                             unsigned char ***state_array,
                                             double threshold,
                                             int subband,
                                             QccENTArithmeticModel *model,
                                             QccBitBuffer *buffer)
{
  int return_value;