motion_vectors.c

QccPack-0.54-1 released (2007-04-30) is being developed and tested on Fedora Core Linux. QccPack pro

                                           const QccVIDMotionVectorsTable
                                           *table,
                                           int subpixel_accuracy,
                                           QccBitBuffer *input_buffer)
{
  int u, v;
  int subpixel_u, subpixel_v;
  int num_subpixels;

  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("(QccVIDMotionVectorsDecodeVector): Unrecognized subpixel accuracy");
      return(1);
    }

  if (table != NULL)
    {
      if (QccVIDMotionVectorsDecodeMVD(input_buffer,
                                       &u,
                                       (int)(*previous_motion_horizontal),
                                       table))
        {
          QccErrorAddMessage("(QccVIDMotionVectorsDecodeVector): Error calling QccVIDMotionVectorsDecodeMVD()");
          return(1);
        }
      if (QccVIDMotionVectorsDecodeMVD(input_buffer,
                                       &v,
                                       (int)(*previous_motion_vertical),
                                       table))
        {
          QccErrorAddMessage("(QccVIDMotionVectorsDecodeVector): Error calling QccVIDMotionVectorsDecodeMVD()");
          return(1);
        }
      
      if (num_subpixels > 1)
        {
          if (QccVIDMotionVectorsDecodeMVD(input_buffer,
                                           &subpixel_u,
                                           0,
                                           table))
            {
              QccErrorAddMessage("(QccVIDMotionVectorsDecodeVector): Error calling QccVIDMotionVectorsDecodeMVD()");
              return(1);
            }
          if (QccVIDMotionVectorsDecodeMVD(input_buffer,
                                           &subpixel_v,
                                           0,
                                           table))
            {
              QccErrorAddMessage("(QccVIDMotionVectorsDecodeVector): Error calling QccVIDMotionVectorsDecodeMVD()");
              return(1);
            }
        }
      else
        subpixel_u = subpixel_v = 0;
      
      *motion_horizontal = u + (double)subpixel_u / num_subpixels;
      *motion_vertical = v + (double)subpixel_v / num_subpixels;
    }
  else
    {
      if (QccENTExponentialGolombDecode(input_buffer,
                                        &u,
                                        1,
                                        1))
        {
          QccErrorAddMessage("(QccVIDMotionVectorsDecodeVector): Error calling QccENTExponentialGolombDecode()");
          return(1);
        }
      if (QccENTExponentialGolombDecode(input_buffer,
                                        &v,
                                        1,
                                        1))
        {
          QccErrorAddMessage("(QccVIDMotionVectorsDecodeVector): Error calling QccENTExponentialGolombDecode()");
          return(1);
        }
      
      *motion_horizontal =
        ((double)u / num_subpixels) + (*previous_motion_horizontal);
      *motion_vertical =
        ((double)v / num_subpixels) + (*previous_motion_vertical);
    }

  *previous_motion_horizontal = *motion_horizontal;
  *previous_motion_vertical = *motion_vertical;
  
  return(0);
}


int QccVIDMotionVectorsEncode(const QccIMGImageComponent
                              *motion_vector_horizontal,
                              const QccIMGImageComponent
                              *motion_vector_vertical,
                              const QccVIDMotionVectorsTable *table,
                              int subpixel_accuracy,
                              QccBitBuffer *output_buffer)
{
  double previous_motion_horizontal;
  double previous_motion_vertical;
  int row, col;
  
  for (row = 0; row < motion_vector_horizontal->num_rows; row++)
    {
      previous_motion_horizontal = 0;
      previous_motion_vertical = 0;
      
      for (col = 0; col < motion_vector_horizontal->num_cols; col++)
        if (QccVIDMotionVectorsEncodeVector(motion_vector_horizontal->image
                                            [row][col],
                                            motion_vector_vertical->image
                                            [row][col],
                                            &previous_motion_horizontal,
                                            &previous_motion_vertical,
                                            table,
                                            subpixel_accuracy,
                                            output_buffer))
          {
            QccErrorAddMessage("(QccVIDMotionVectorsEncode): Error calling QccVIDMotionVectorsEncodeVector()");
            return(1);
          }
    }
  
  return(0);
}


int QccVIDMotionVectorsDecode(QccIMGImageComponent
                              *motion_vector_horizontal,
                              QccIMGImageComponent
                              *motion_vector_vertical,
                              const QccVIDMotionVectorsTable *table,
                              int subpixel_accuracy,
                              QccBitBuffer *input_buffer)
{
  double previous_motion_horizontal;
  double previous_motion_vertical;
  int row, col;
  
  for (row = 0; row < motion_vector_horizontal->num_rows; row++)
    {
      previous_motion_horizontal = 0;
      previous_motion_vertical = 0;
      
      for (col = 0; col < motion_vector_horizontal->num_cols; col++)
        if (QccVIDMotionVectorsDecodeVector(&motion_vector_horizontal->image
                                            [row][col],
                                            &motion_vector_vertical->image
                                            [row][col],
                                            &previous_motion_horizontal,
                                            &previous_motion_vertical,
                                            table,
                                            subpixel_accuracy,
                                            input_buffer))
          {
            QccErrorAddMessage("(QccVIDMotionVectorsDecode): Error calling QccVIDMotionVectorsDecodeVector()");
            return(1);
          }
    }
  
  return(0);
}


int QccVIDMotionVectorsReadFile(QccIMGImageComponent
                                *motion_vectors_horizontal,
                                QccIMGImageComponent
                                *motion_vectors_vertical,
                                const QccString filename,
                                int frame_num)
{
  QccString current_filename;
  FILE *current_file;
  int row, col;

  if (motion_vectors_horizontal == NULL)
    return(0);
  if (motion_vectors_vertical == NULL)
    return(0);
  if (filename == NULL)
    return(0);
  if (QccStringNull(filename))
    return(0);

  if (motion_vectors_horizontal->image == NULL)
    return(0);
  if (motion_vectors_vertical->image == NULL)
    return(0);

  if (frame_num < 0)
    {
      QccErrorAddMessage("(QccVIDMotionVectorsReadFile): Invalid frame number (%d)",
                         frame_num);
      return(1);
    }

  if ((motion_vectors_horizontal->num_rows !=
       motion_vectors_vertical->num_rows) ||
      (motion_vectors_horizontal->num_cols !=
       motion_vectors_vertical->num_cols))
    {
      QccErrorAddMessage("(QccVIDMotionVectorsReadFile): Motion-vector fields must have same size");
      return(1);
    }

  QccStringSprintf(current_filename, filename, frame_num);

  if ((current_file = QccFileOpen(current_filename, "r")) == NULL)
    {
      QccErrorAddMessage("(QccVIDMotionVectorsReadFile): Error calling QccFileOpen()");
      return(1);
    }

  for (row = 0; row < motion_vectors_horizontal->num_rows; row++)
    for (col = 0; col < motion_vectors_horizontal->num_cols; col++)
      {
        fscanf(current_file, "%lf",
               &motion_vectors_vertical->image[row][col]);
        if (ferror(current_file) || feof(current_file))
          {
            QccErrorAddMessage("(QccVIDMotionVectorsReadFile): Error reading file %s",
                               current_filename);
            return(1);
          }
        fscanf(current_file, "%lf",
               &motion_vectors_horizontal->image[row][col]);
        if (ferror(current_file) || feof(current_file))
          {
            QccErrorAddMessage("(QccVIDMotionVectorsReadFile): Error reading file %s",
                               current_filename);
            return(1);
          }
      }

  QccFileClose(current_file);

  return(0);
}


int QccVIDMotionVectorsWriteFile(const QccIMGImageComponent
                                 *motion_vectors_horizontal,
                                 const QccIMGImageComponent
                                 *motion_vectors_vertical,
                                 const QccString filename,
                                 int frame_num)
{
  QccString current_filename;
  FILE *current_file;
  int row, col;

  if (motion_vectors_horizontal == NULL)
    return(0);
  if (motion_vectors_vertical == NULL)
    return(0);
  if (filename == NULL)
    return(0);
  if (QccStringNull(filename))
    return(0);

  if (frame_num < 0)
    {
      QccErrorAddMessage("(QccVIDMotionVectorsWriteFile): Invalid frame number (%d)",
                         frame_num);
      return(1);
    }

  if ((motion_vectors_horizontal->num_rows !=
       motion_vectors_vertical->num_rows) ||
      (motion_vectors_horizontal->num_cols !=
       motion_vectors_vertical->num_cols))
    {
      QccErrorAddMessage("(QccVIDMotionVectorsWriteFile): Motion-vector fields must have same size");
      return(1);
    }

  QccStringSprintf(current_filename, filename, frame_num);

  if ((current_file = QccFileOpen(current_filename, "w")) == NULL)
    {
      QccErrorAddMessage("(QccVIDMotionVectorsWriteFile): Error calling QccFileOpen()");
      return(1);
    }

  for (row = 0; row < motion_vectors_horizontal->num_rows; row++)
    for (col = 0; col < motion_vectors_horizontal->num_cols; col++)
      fprintf(current_file, "% 11.4f % 11.4f\n",
              motion_vectors_vertical->image[row][col],
              motion_vectors_horizontal->image[row][col]);

  QccFileClose(current_file);

  return(0);
}