rdwtblock.c

QccPack implementation in C

               (QccWAVSubbandPyramid **)calloc(num_phases,
                                               sizeof(QccWAVSubbandPyramid *)))
              == NULL)
            {
              QccErrorAddMessage("(QccVIDRDWTBlockRDWTPhasesAlloc): Error allocating memory");
              return(NULL);
            }
          
          for (phase_row = 0; phase_row < num_phases; phase_row++)
            if ((rdwt_phases[subpixel_row][subpixel_col][phase_row] =
                 (QccWAVSubbandPyramid *)calloc(num_phases,
                                                sizeof(QccWAVSubbandPyramid)))
                == NULL)
              {
                QccErrorAddMessage("(QccVIDRDWTBlockRDWTPhasesAlloc): Error allocating memory");
                return(NULL);
              }
        }
    }
  
  for (subpixel_row = 0; subpixel_row < num_subpixels; subpixel_row++)
    for (subpixel_col = 0; subpixel_col < num_subpixels; subpixel_col++)
      for (phase_row = 0; phase_row < num_phases; phase_row++)
        for (phase_col = 0; phase_col < num_phases; phase_col++)
          {
            QccWAVSubbandPyramidInitialize(&rdwt_phases
                                           [subpixel_row][subpixel_col]
                                           [phase_row][phase_col]);
            rdwt_phases
              [subpixel_row][subpixel_col][phase_row][phase_col].num_rows =
              num_rows;
            rdwt_phases
              [subpixel_row][subpixel_col][phase_row][phase_col].num_cols =
              num_cols;
            rdwt_phases
              [subpixel_row][subpixel_col][phase_row][phase_col].num_levels =
              num_levels;
            if (QccWAVSubbandPyramidAlloc(&rdwt_phases
                                          [subpixel_row][subpixel_col]
                                          [phase_row][phase_col]))
              {
                QccErrorAddMessage("(QccVIDRDWTBlockRDWTPhasesAlloc): Error calling QccWAVSubbandPyramidAlloc()");
                return(NULL);
              }
          }
  
  return(rdwt_phases);
}


static void QccVIDRDWTBlockRDWTPhasesFree(QccWAVSubbandPyramid ****rdwt_phases,
                                          int num_levels,
                                          int subpixel_accuracy)
{
  int num_subpixels;
  int subpixel_row, subpixel_col;
  int num_phases;
  int phase_row, phase_col;
  
  switch (subpixel_accuracy)
    {
    case QCCVID_ME_FULLPIXEL:
      num_subpixels = 1;
      break;
    case QCCVID_ME_HALFPIXEL:
      num_subpixels = 2;
      break;
    case QCCVID_ME_QUARTERPIXEL:
      num_subpixels = 4;
      break;
    case QCCVID_ME_EIGHTHPIXEL:
      num_subpixels = 8;
      break;
    default:
      return;
    }

  num_phases = (1 << num_levels);
  
  if (rdwt_phases != NULL)
    {
      for (subpixel_row = 0; subpixel_row < num_subpixels; subpixel_row++)
        if (rdwt_phases[subpixel_row] != NULL)
          {
            for (subpixel_col = 0; subpixel_col < num_subpixels;
                 subpixel_col++)
              if (rdwt_phases[subpixel_row][subpixel_col] != NULL)
                {
                  for (phase_row = 0; phase_row < num_phases; phase_row++)
                    if (rdwt_phases[subpixel_row][subpixel_col][phase_row]
                        != NULL)
                      {
                        for (phase_col = 0; phase_col < num_phases;
                             phase_col++)
                          QccWAVSubbandPyramidFree(&rdwt_phases
                                                   [subpixel_row][subpixel_col]
                                                   [phase_row][phase_col]);
                        QccFree(rdwt_phases[subpixel_row][subpixel_col]
                                [phase_row]);
                      }
                  QccFree(rdwt_phases[subpixel_row][subpixel_col]);
                }
            QccFree(rdwt_phases[subpixel_row]);
          }
      QccFree(rdwt_phases);  
    }
}


static int QccVIDRDWTBlockExtractPhases(QccMatrix *rdwt,
                                        QccWAVSubbandPyramid ****phases,
                                        int num_rows,
                                        int num_cols,
                                        int reference_num_rows,
                                        int reference_num_cols,
                                        int num_levels,
                                        int subpixel_accuracy,
                                        const QccWAVWavelet *wavelet)
{
  int return_value;
  int num_subpixels;
  int subpixel_row, subpixel_col;
  int num_phases;
  int phase_row, phase_col;
  QccMatrix *rdwt2 = NULL;
  int num_subbands;
  int subband;
  int row, col;

  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_levels);

  if ((rdwt2 =
       QccWAVWaveletRedundantDWT2DAlloc(num_rows, num_cols, num_levels)) ==
      NULL)
    {
      QccErrorAddMessage("(QccWAVRDWTBlockExtractPhases): Error calling QccWAVWaveletRedundantDWT2DAlloc()");
      goto Error;
    }

  switch (subpixel_accuracy)
    {
    case QCCVID_ME_FULLPIXEL:
      num_subpixels = 1;
      break;
    case QCCVID_ME_HALFPIXEL:
      num_subpixels = 2;
      break;
    case QCCVID_ME_QUARTERPIXEL:
      num_subpixels = 4;
      break;
    case QCCVID_ME_EIGHTHPIXEL:
      num_subpixels = 8;
      break;
    default:
      QccErrorAddMessage("(QccVIDRDWTBlockExtractPhases): Unrecognized subpixel accuracy");
      goto Error;
    }

  num_phases = (1 << num_levels);
  
  for (subpixel_row = 0; subpixel_row < num_subpixels; subpixel_row++)
    for (subpixel_col = 0; subpixel_col < num_subpixels; subpixel_col++)
      {
        for (subband = 0; subband < num_subbands; subband++)
          for (row = 0; row < num_rows; row++)
            for (col = 0; col < num_cols; col++)
              rdwt2[subband][row][col] =
                rdwt[subband]
                [row * num_subpixels + subpixel_row]
                [col * num_subpixels + subpixel_col];

        for (phase_row = 0; phase_row < num_phases; phase_row++)
          for (phase_col = 0; phase_col < num_phases; phase_col++)
            {
              phases[subpixel_row][subpixel_col]
                [phase_row][phase_col].subsample_pattern_row = phase_row;
              phases[subpixel_row][subpixel_col]
                [phase_row][phase_col].subsample_pattern_col = phase_col;
              
              if (QccWAVSubbandPyramidRedundantDWTSubsample(rdwt2,
                                                            &phases
                                                            [subpixel_row]
                                                            [subpixel_col]
                                                            [phase_row]
                                                            [phase_col],
                                                            wavelet))
                {
                  QccErrorAddMessage("(QccWAVRDWTBlockExtractPhases): Error calling QccWAVSubbandPyramidRedundantDWTSubsample()");
                  goto Error;
                }
            }
      }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccWAVWaveletRedundantDWT2DFree(rdwt2, num_rows, num_levels);
  return(return_value);
}


static int QccVIDRDWTBlockCreateReferenceFrame(QccMatrix
                                               *reconstructed_frame_rdwt,
                                               QccMatrix
                                               *reference_frame_rdwt,
                                               int num_rows,
                                               int num_cols,
                                               int reference_num_rows,
                                               int reference_num_cols,
                                               int num_levels,
                                               int subpixel_accuracy,
                                               const QccFilter *filter1,
                                               const QccFilter *filter2,
                                               const QccFilter *filter3)
{
  int subband;
  int num_subbands;
  QccIMGImageComponent reconstructed_subband;
  QccIMGImageComponent reference_subband;

  QccIMGImageComponentInitialize(&reconstructed_subband);
  QccIMGImageComponentInitialize(&reference_subband);

  num_subbands = QccWAVSubbandPyramidNumLevelsToNumSubbands(num_levels);

  reconstructed_subband.num_rows = num_rows;
  reconstructed_subband.num_cols = num_cols;
  reference_subband.num_rows = reference_num_rows;
  reference_subband.num_cols = reference_num_cols;

  for (subband = 0; subband < num_subbands; subband++)
    {
      reconstructed_subband.image =
        (QccIMGImageArray)reconstructed_frame_rdwt[subband];
      reference_subband.image =
        (QccIMGImageArray)reference_frame_rdwt[subband];

      if (QccVIDMotionEstimationCreateReferenceFrame(&reconstructed_subband,
                                                     &reference_subband,
                                                     subpixel_accuracy,
                                                     filter1,
                                                     filter2,
                                                     filter3))
        {
          QccErrorAddMessage("(QccVIDRDWTBlockCreateReferenceFrame): Error calling QccVIDMotionEstimationCreateReferenceFrame()");
          return(1);
        }
    }

  return(0);
}


static int QccVIDRDWTBlockMotionEstimationSearch(QccWAVSubbandPyramid
                                                 ****reference_frame_phases,
                                                 QccVIDRDWTBlockBlock
                                                 *current_block,
                                                 QccVIDRDWTBlockBlock
                                                 *reference_block,
                                                 int num_rows,
                                                 int num_cols,
                                                 int num_levels,
                                                 double search_row,
                                                 double search_col,
                                                 double window_size,
                                                 double search_step,
                                                 int subpixel_accuracy,
                                                 double *mv_horizontal,
                                                 double *mv_vertical)
{                                                   
  double u, v;
  double reference_frame_row, reference_frame_col;
  int subsample_pattern_row, subsample_pattern_col;
  int num_phases;
  double current_mae;
  double min_mae = MAXDOUBLE;
  int integer_row, integer_col;
  int subpixel_row, subpixel_col;
  int num_subpixels;
  
  num_phases = (1 << num_levels);
  
  switch (subpixel_accuracy)
    {
    case QCCVID_ME_FULLPIXEL:
      num_subpixels = 1;
      break;
    case QCCVID_ME_HALFPIXEL:
      num_subpixels = 2;
      break;
    case QCCVID_ME_QUARTERPIXEL:
      num_subpixels = 4;
      break;
    case QCCVID_ME_EIGHTHPIXEL:
      num_subpixels = 8;
      break;
    default:
      QccErrorAddMessage("(QccVIDRDWTBlockMotionEstimationSearch): Unrecognized subpixel accuracy");
      return(1);
    }
  
  for (v = -window_size; v <= window_size; v += search_step)
    for (u = -window_size; u <= window_size; u += search_step)
      {
        reference_frame_row = search_row + v;
        reference_frame_col = search_col + u;
        
        integer_row = (int)floor(reference_frame_row);
        integer_col = (int)floor(reference_frame_col);
        subpixel_row =
          (int)((reference_frame_row - integer_row) * num_subpixels);
        subpixel_col =
          (int)((reference_frame_col - integer_col) * num_subpixels);
        
        subsample_pattern_row = QccMathModulus(integer_row, num_phases);
        subsample_pattern_col = QccMathModulus(integer_col, num_phases);
        
        if (QccVIDRDWTBlockExtractBlock(&reference_frame_phases
                                        [subpixel_row][subpixel_col]
                                        [subsample_pattern_row]
                                        [subsample_pattern_col],
                                        reference_block,
                                        integer_row,
                                        integer_col,
                                        num_rows,
                                        num_cols,
                                        num_levels))
          {
            QccErrorAddMessage("(QccVIDRDWTBlockMotionEstimationSearch): Error calling QccVIDRDWTBlockExtractBlock()");
            return(1);
          }
        
        current_mae =
          QccVIDRDWTBlockMAE(current_block,
                             reference_block,
                             num_levels);
        if (current_mae < min_mae)
          {
            min_mae = current_mae;
            *mv_horizontal = u;
            *mv_vertical = v;
          }
      }
  
  return(0);
}


static int QccVIDRDWTBlockMotionEstimation(QccWAVSubbandPyramid
                                           ****reference_frame_phases,
                                           QccWAVSubbandPyramid
                                           *current_subband_pyramid,
                                           QccIMGImageComponent
                                           *horizontal_motion,
                                           QccIMGImageComponent
                                           *vertical_motion,
                                           int blocksize,
                                           int subpixel_accuracy)
{
  int row, col;
  int num_rows, num_cols;
  int num_levels;
  int num_phases;
  double u, v;
  QccVIDRDWTBlockBlock current_block;
  QccVIDRDWTBlockBlock reference_block;