tce3d_lossless.c

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

      QccErrorAddMessage("(QccWAVtce3DIntIPBand): Error calling QccVectorAlloc()");
      goto Error;
    }
  if ((p3 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtce3DIntIPBand): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p4 = QccMatrixAlloc(subband_num_rows,subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtce3DIntIPBand): Error calling QccMatrixAlloc()");
      goto Error;
    }
  if ((p5 = QccVectorAlloc(subband_num_cols)) == NULL)
    {
      QccErrorAddMessage("(QccWAVtce3DIntIPBand): Error calling QccVectorAlloc()");
      goto Error;
    }

  child_density =
    subband_significance[subband] / (subband_num_frames*subband_num_rows * subband_num_cols);
  p_lowerbound = 1.0 / (subband_num_frames*subband_num_rows * subband_num_cols);
  if ((subband%(3*coefficients->spatial_num_levels+1))<=3)
    {
      if ((subband%(3*coefficients->spatial_num_levels+1))==0)
	{
	  if ((subband/(3*coefficients->spatial_num_levels+1))<=1)
	    {
	      parent_subband = 0;
              parent_density =
                subband_significance[parent_subband] /
		(subband_num_frames*subband_num_rows * subband_num_cols) ;
	    }
	  else
	    {
	      parent_subband = subband-(3*coefficients->spatial_num_levels+1);
              parent_density =
                subband_significance[parent_subband] /
		(subband_num_frames*subband_num_rows * subband_num_cols)*2 ;
	    }
	}

      if ((subband%(3*coefficients->spatial_num_levels+1))==1)
	{
	  parent_subband = subband - 1;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}
      if ((subband%(3*coefficients->spatial_num_levels+1))==2)
	{
	  parent_subband = subband - 2;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}
      if ((subband%(3*coefficients->spatial_num_levels+1))==3)
	{
	  parent_subband = subband - 3;
          parent_density =
            subband_significance[parent_subband] /
            (subband_num_frames*subband_num_rows * subband_num_cols) ;
	}
    }
  else
    {
      parent_subband = subband - 3;
      parent_density =
        subband_significance[parent_subband] /
        (subband_num_frames*subband_num_rows * subband_num_cols) * 4;
    }
  
  for (row = 0; row < subband_num_rows; row++)
    for (col = 0; col < subband_num_cols; col++)
      p3[row][col]=QCCTCE3D_BOUNDARY_VALUE;  

  scale =
    QccMathMax(child_density, p_lowerbound) /
    QccMathMax(parent_density, p_lowerbound); 
  increment =
    1.0 / (subband_num_frames*subband_num_rows * subband_num_cols) /
    QccMathMax(parent_density, p_lowerbound);
   
  for (frame = 0; frame < subband_num_frames; frame++)
    {//aaaa
      current_frame=subband_origin_frame+frame;
      for (col = 0; col < subband_num_cols; col++)
        p2[col] =QCCTCE3D_BOUNDARY_VALUE;  ;

      for (row = 0; row < subband_num_rows; row++)
        {  //aaa  
          current_row = subband_origin_row + row;
          for (col = 0; col < subband_num_cols; col++)
            { //aa  
              current_col = subband_origin_col + col;
              p_char = &(significance_map[current_frame][current_row][current_col]);
              if (col == 0)
                p_forward =alpha * (QCCTCE3D_BOUNDARY_VALUE + p2[col] +
                                    p3[row][col]);
              else
                p_forward = alpha * (p1[row][col-1] + p2[col] + p3[row][col]);
          
              if (*p_char < QCCTCE3D_S)
                { //a     
                  p = p_forward + p_estimation[current_frame][current_row][current_col];

                  if (subband != 0)
                    { //b
                      if ((subband%(3*coefficients->spatial_num_levels+1))<=3)
                        {
                          if ((subband%(3*coefficients->spatial_num_levels+1))==0)
                            {
                              if((subband/(3*coefficients->spatial_num_levels+1))<=1)
                                p_parent = p_estimation[0][current_row][current_col];
	   
                              else
                                p_parent = p_estimation[current_frame/2][current_row][current_col];
                            } 

                          if ((subband%(3*coefficients->spatial_num_levels+1))==1)
                            p_parent = p_estimation[current_frame][current_row-subband_num_rows][current_col];

                          if ((subband%(3*coefficients->spatial_num_levels+1))==2)
                            p_parent = p_estimation[current_frame][current_row][current_col-subband_num_cols];

                          if ((subband%(3*coefficients->spatial_num_levels+1))==3)
                            p_parent = p_estimation[current_frame][current_row-subband_num_rows][current_col-subband_num_cols];
			       

                        }
    
                      else
              
                        p_parent = p_estimation[current_frame][current_row/2][current_col/2];

                      if (p < QCCWAVTCE3D_PREDICT_THRESHOLD)
                        {          
                          p_parent = QccMathMin(p_parent*scale, 0.8);
                          p =
                            p * QCCWAVTCE3D_CURRENT_SCALE +
                            QCCWAVTCE3D_PARENT_SCALE * p_parent;
                        }
                    }//b
                  if(p>1)
                    {
			      
                      p=1;
                    }
                  if (QccWAVTce3DUpdateModel(model, p))
                    {
                      QccErrorAddMessage("(QccWAVtce3DIntIPBand): Error calling QccWAVtceUpdateModel()");
                      return_value = 1;
                      goto Error;
                    }
                  if (buffer->type == QCCBITBUFFER_OUTPUT)
                    {
                      if (coefficients->volume[current_frame][current_row][current_col] >=
                          threshold)
                        {
                          symbol = 1;
                          coefficients->volume[current_frame][current_row][current_col] -=
                            threshold;
                        }
                      else
                        symbol = 0;
                      return_value =
                        QccENTArithmeticEncode(&symbol, 1,model, buffer);
                    }
                  else
                    {
                      if (QccENTArithmeticDecode(buffer,model,&symbol, 1))
                        {
                          return_value = 2;
                          goto Return;
                        }
                      else
                        return_value = 0;
                  
                      if (symbol)
                        coefficients->volume[current_frame][current_row][current_col] =
                           
                          threshold + (threshold >> 1);

                    }
                  v = symbol;
	                
                  if (symbol)
                    {//c
                      subband_significance[subband]++;
                      scale += increment;
                      *p_char = QCCTCE3D_S_NEW;
                  
                      if (QccWAVTce3DUpdateModel(model, 0.5))
                        {
                          QccErrorAddMessage("(QccWAVtce3DIntIPBand): Error calling QccWAVtceUpdateModel()");
                          goto Error;
                        }
                  
                      if (buffer->type == QCCBITBUFFER_OUTPUT)
                        {
                          symbol = (int)(sign_array[current_frame][current_row][current_col]);
                          return_value =
                            QccENTArithmeticEncode(&symbol, 1,model, buffer);      
                        }
                      else
                        {
                          if (QccENTArithmeticDecode(buffer,model,&symbol, 1))
                            return_value = 2;      
                          sign_array[current_frame][current_row][current_col] = (char)symbol;
                        }
                      QccWAV3DUpdateNZNStatus(subband_origin_frame,
                                              subband_origin_row,
                                              subband_origin_col,
                                              subband_num_frames,
                                              subband_num_rows,
                                              subband_num_cols,
                                              frame,
                                              row,
                                              col,
                                              significance_map,
                                              subband);
                    }//c    
              
                  if (return_value == 2)
                    goto Return;
                  else
                    {
                      if (return_value)
                        {
                          QccErrorAddMessage("(QccWAVtce3DIntIPBand): QccWAVtceIPBand()");
                          goto Error;
                        }
                    } 

                  if (col == 0)
                    p1[row][col] = alpha * QCCTCE3D_BOUNDARY_VALUE + filter_coef * v;
                  else
                    p1[row][col] = alpha * p1[row][col-1] + filter_coef * v;
                  p2[col] = p1[row][col] + alpha * p2[col];
 
                }//a
              else
                { 
                  if (col == 0)
                    p1[row][col] = alpha * QCCTCE3D_BOUNDARY_VALUE  + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;
                  else
                    p1[row][col] = alpha* p1[row][col-1] + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;
                  p2[col] = p1[row][col] + alpha * p2[col];
                }
              p_estimation[subband_origin_frame+frame][subband_origin_row + row][subband_origin_col + col] =
                p_forward;


            }//aa
     
           
          for (col = subband_num_cols - 1; col >= 0; col--)
            {  
              if (col ==( subband_num_cols - 1)) 
                p2[col] = p2[col] + alpha * QCCTCE3D_BOUNDARY_VALUE;
              else
                p2[col] = p2[col] + alpha * p4[row][col+1];
              p3[row][col]=p2[col]+alpha*p3[row][col];
              p_char = &(significance_map[current_frame][current_row][subband_origin_col + col]);
              if (*p_char == QCCTCE3D_S)
                {
                  if (col == (subband_num_cols - 1))
                    p4[row][col] = alpha * QCCTCE3D_BOUNDARY_VALUE + filter_coef * QCCWAVTCE3D_REFINE_HOLDER; 
                  else 
                    p4[row][col] = alpha * p4[row][col+1] + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;;
                } 
              else
                {
                  v = (*p_char == QCCTCE3D_S_NEW);
                  if (col == subband_num_cols - 1)
                    p4[row][col]  = alpha * QCCTCE3D_BOUNDARY_VALUE + filter_coef * v;
                  else
                    p4[row][col] = alpha * p4[row][col+1] + filter_coef * v;
                }
            }
        }//aaa
	 
      for (col = 0; col < subband_num_cols; col++)
        p5[col]=0;
      for (row = subband_num_rows - 1; row >= 0; row--)
        {
          for (col = 0; col < subband_num_cols; col++)
            {
              p3[row][col]=p3[row][col]+alpha*p5[col];
              if (col ==( subband_num_cols - 1))
                p5[col]=p1[row][col]+alpha*p5[col]+alpha*QCCTCE3D_BOUNDARY_VALUE ;
              else 
                p5[col]=p1[row][col]+alpha*p5[col]+alpha*p4[row][col+1];

            }

        }
    }//aaaa
     
  for (frame = subband_num_frames-1;frame >= 0; frame--)
    {//bbb
      current_frame=subband_origin_frame+frame;
     
      for (row = subband_num_rows - 1; row >= 0; row--)
        {//bb
          current_row = subband_origin_row + row;
          for (col = subband_num_cols-1; col >=0; col--)
            {   
              current_col = subband_origin_col + col; 
              p_char = &(significance_map[current_frame][current_row][current_col]);
              if (col ==( subband_num_cols-1) )
                p_estimation[current_frame][current_row][current_col]+=alpha * (QCCTCE3D_BOUNDARY_VALUE + p2[col] + p3[row][col]);
              else
                p_estimation[current_frame][current_row][current_col] +=alpha *(p1[row][col+1]+p2[col]+p3[row][col]);
                 
              if (*p_char == QCCTCE3D_S)
                {
                  p_estimation[current_frame][current_row][current_col]=
                    QCCWAVTCE3D_REFINE_HOLDER * weight[0] +
                    p_estimation[current_frame][current_row][current_col] * weight[1];
                  if (col == (subband_num_cols-1) )
                    p1[row][col] = alpha * QCCTCE3D_BOUNDARY_VALUE + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;
                  else
  
                    p1[row][col] = alpha * p1[row][col+1] + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;
                }
              else
                {
                  v = (*p_char == QCCTCE3D_S_NEW);
                  p_estimation[current_frame][current_row][current_col] =
                    v * weight[0] +p_estimation[current_frame][current_row][current_col] * weight[1];
                  if (col == (subband_num_cols-1) )
                    p1[row][col] = alpha *  QCCTCE3D_BOUNDARY_VALUE  + filter_coef * v;
                  else

                    p1[row][col] = alpha * p1[row][col+1] + filter_coef * v;
                }    
              p2[col] = p1[row][col] + alpha * p2[col];   
            }
          
          for (col = 0; col < subband_num_cols; col++)
            {
	      if(col==0)
                p2[col] = p2[col] + alpha * QCCTCE3D_BOUNDARY_VALUE;
	      else
                p2[col] = p2[col] + alpha * p4[row][col-1];
              p3[row][col]=p2[col]+alpha*p3[row][col];
              current_col = subband_origin_col + col; 
              p_char = &(significance_map[current_frame][current_row][current_col]);
              if (*p_char == QCCTCE3D_S)
                {
	          if(col==0)
                    p4[row][col] = alpha * QCCTCE3D_BOUNDARY_VALUE + filter_coef * QCCWAVTCE3D_REFINE_HOLDER;