mesh_memc.c

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

/*
 *
 * QccPack: Quantization, compression, and coding utilities
 * Copyright (C) 1997-2009  James E. Fowler
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */


#include "mesh_memc.h"


#define USG_STRING "[-fp %:] [-hp %:] [-qp %:] [-ep %:] [-f1 %: %s:filter1] [-f2 %: %s:filter2] [-f3 %: %s:filter3] [-w %d:window] [-b %d:block_size] [-eb %d:estimation_block_size] [-exp %:] [-cb %:] [-mc %: %s:motion_compensated_frame] [-srf %: %s:subpixel_reference_frame] [-r %: %s:residual_frame] %s:reference_frame %s:current_frame %s:mvfile"

QccIMGImage ReferenceFrame;
QccIMGImage CurrentFrame;

QccString MVFilename;
int NumCols1, NumRows1;
int NumCols2, NumRows2;

int WindowSize = 15;
int BlockSize = 16;
int EstimationBlockSize = 9;

QccIMGImageComponent HorizontalMotion;
QccIMGImageComponent VerticalMotion;

int FullPixelSpecified = 0;
int HalfPixelSpecified = 0;
int QuarterPixelSpecified = 0;
int EighthPixelSpecified = 0;
int MotionAccuracy = QCCVID_ME_FULLPIXEL;

QccIMGImageComponent CurrentFrame2;
QccIMGImageComponent ReferenceFrame2;

int FilterSpecified1 = 0;
QccString FilterFilename1;
QccFilter Filter1;
int FilterSpecified2 = 0;
QccString FilterFilename2;
QccFilter Filter2;
int FilterSpecified3 = 0;
QccString FilterFilename3;
QccFilter Filter3;

int CompensatedFrameSpecified = 0;
QccIMGImage CompensatedFrame;

int SubpixelReferenceFrameSpecified = 0;
QccIMGImage SubpixelReferenceFrame;

int ResidualFrameSpecified = 0;
QccIMGImage ResidualFrame;

QccRegularMesh CurrentMesh;
QccRegularMesh ReferenceMesh;

QccPoint RangeLower;
QccPoint RangeUpper;

int ExponentialKernel = 0;
int ConstrainedBoundary = 0;


int main(int argc, char *argv[])
{
  FILE *infile;

  QccInit(argc, argv);

  QccIMGImageInitialize(&ReferenceFrame);
  QccIMGImageInitialize(&CurrentFrame);
  QccIMGImageComponentInitialize(&HorizontalMotion);
  QccIMGImageComponentInitialize(&VerticalMotion);
  QccIMGImageComponentInitialize(&CurrentFrame2);
  QccIMGImageComponentInitialize(&ReferenceFrame2);
  QccFilterInitialize(&Filter1);
  QccFilterInitialize(&Filter2);
  QccFilterInitialize(&Filter3);
  QccIMGImageInitialize(&CompensatedFrame);
  QccIMGImageInitialize(&SubpixelReferenceFrame);
  QccIMGImageInitialize(&ResidualFrame);
  QccRegularMeshInitialize(&CurrentMesh);
  QccRegularMeshInitialize(&ReferenceMesh);

  if (QccParseParameters(argc, argv,
			 USG_STRING,
                         &FullPixelSpecified,
                         &HalfPixelSpecified,
                         &QuarterPixelSpecified,
                         &EighthPixelSpecified,
                         &FilterSpecified1,
                         FilterFilename1,
                         &FilterSpecified2,
                         FilterFilename2,
                         &FilterSpecified3,
                         FilterFilename3,
			 &WindowSize,
                         &BlockSize,
			 &EstimationBlockSize,
                         &ExponentialKernel,
                         &ConstrainedBoundary,
                         &CompensatedFrameSpecified,
                         CompensatedFrame.filename,
                         &SubpixelReferenceFrameSpecified,
                         SubpixelReferenceFrame.filename,
                         &ResidualFrameSpecified,
                         ResidualFrame.filename,
			 ReferenceFrame.filename,
			 CurrentFrame.filename,
                         MVFilename))
    QccErrorExit();
  
  if (EighthPixelSpecified)
    MotionAccuracy = QCCVID_ME_EIGHTHPIXEL;
  else
    if (QuarterPixelSpecified)
      MotionAccuracy = QCCVID_ME_QUARTERPIXEL;
    else
      if (HalfPixelSpecified)
        MotionAccuracy = QCCVID_ME_HALFPIXEL;
      else
        if (FullPixelSpecified)
          MotionAccuracy = QCCVID_ME_FULLPIXEL;
  
  if (FilterSpecified1)
    {
      if ((infile = QccFileOpen(FilterFilename1, "r")) == NULL)
        {
          QccErrorAddMessage("%s: Error calling QccFileOpen()",
                             argv[0]);
          QccErrorExit();
        }
      if (QccFilterRead(infile, &Filter1))
        {
          QccErrorAddMessage("%s: Error calling QccFilterRead()",
                             argv[0]);
          QccErrorExit();
        }
      QccFileClose(infile);
    }
  if (FilterSpecified2)
    {
      if ((infile = QccFileOpen(FilterFilename2, "r")) == NULL)
        {
          QccErrorAddMessage("%s: Error calling QccFileOpen()",
                             argv[0]);
          QccErrorExit();
        }
      if (QccFilterRead(infile, &Filter2))
        {
          QccErrorAddMessage("%s: Error calling QccFilterRead()",
                             argv[0]);
          QccErrorExit();
        }
      QccFileClose(infile);
    }
  if (FilterSpecified3)
    {
      if ((infile = QccFileOpen(FilterFilename3, "r")) == NULL)
        {
          QccErrorAddMessage("%s: Error calling QccFileOpen()",
                             argv[0]);
          QccErrorExit();
        }
      if (QccFilterRead(infile, &Filter3))
        {
          QccErrorAddMessage("%s: Error calling QccFilterRead()",
                             argv[0]);
          QccErrorExit();
        }
      QccFileClose(infile);
    }

  if (QccIMGImageRead(&ReferenceFrame))
    {
      QccErrorAddMessage("%s: Error calling QccIMGImageRead()",
			 argv[0]);
      QccErrorExit();
    }
  if (QccIMGImageRead(&CurrentFrame))
    {
      QccErrorAddMessage("%s: Error calling QccIMGImageRead()",
			 argv[0]);
      QccErrorExit();
    }

  if (QccIMGImageColor(&ReferenceFrame) || QccIMGImageColor(&CurrentFrame))
    {
      QccErrorAddMessage("%s: Both images must be grayscale",
			 argv[0]);
      QccErrorExit();
    }

  if (QccIMGImageGetSize(&ReferenceFrame,
                         &NumRows1, &NumCols1))
    {
      QccErrorAddMessage("%s: Error calling QccIMGImageGetSize()",
			 argv[0]);
      QccErrorExit();
    }
  if (QccIMGImageGetSize(&CurrentFrame,
                         &NumRows2, &NumCols2))
    {
      QccErrorAddMessage("%s: Error calling QccIMGImageGetSize()",
			 argv[0]);
      QccErrorExit();
    }

  if ((NumRows1 % BlockSize) || (NumCols1 % BlockSize))
    {
      QccErrorAddMessage("%s: Image dimensions must be integer multiple of block size %d",
			 argv[0],
			 BlockSize);
      QccErrorExit();
    }

  if ((NumRows1 != NumRows2) || (NumCols1 != NumCols2))
    {
      QccErrorAddMessage("%s: Both images must be same size",
			 argv[0]);
      QccErrorExit();
    }

  HorizontalMotion.num_rows = NumRows1 / BlockSize + 1;
  HorizontalMotion.num_cols = NumCols1 / BlockSize + 1;
  if (QccIMGImageComponentAlloc(&HorizontalMotion))
    {
      QccErrorAddMessage("%s: Error calling QccIMGImageComponentAlloc()",
			 argv[0]);
      QccErrorExit();
    }
  VerticalMotion.num_rows = NumRows1 / BlockSize + 1;
  VerticalMotion.num_cols = NumCols1 / BlockSize + 1;
  if (QccIMGImageComponentAlloc(&VerticalMotion))
    {
      QccErrorAddMessage("%s: Error calling QccIMGImageComponentAlloc()",
			 argv[0]);
      QccErrorExit();
    }

  CurrentMesh.num_rows = HorizontalMotion.num_rows;
  CurrentMesh.num_cols = HorizontalMotion.num_cols;
  if (QccRegularMeshAlloc(&CurrentMesh))
    {
      QccErrorAddMessage("%s: Error calling QccRegularMeshAlloc()",
			 argv[0]);
      QccErrorExit();
    }
  ReferenceMesh.num_rows = HorizontalMotion.num_rows;
  ReferenceMesh.num_cols = HorizontalMotion.num_cols;
  if (QccRegularMeshAlloc(&ReferenceMesh))
    {
      QccErrorAddMessage("%s: Error calling QccRegularMeshAlloc()",
			 argv[0]);
      QccErrorExit();
    }