Changeset 517 in SHVCSoftware for branches/SHM-4.1-dev/source

Timestamp:

17 Dec 2013, 20:25:51 (11 years ago)

Author:

qualcomm

Message:

JSVM based down-sampler

Location:

branches/SHM-4.1-dev/source/App/TAppDownConvert

Files:

• DownConvert.cpp (added)
• DownConvert.h (added)
• TAppDownConvert.cpp (modified) (1 diff)

branches/SHM-4.1-dev/source/App/TAppDownConvert/TAppDownConvert.cpp

@@ -35 +35 @@
     \brief    Down convert application main
 */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-//! \ingroup TAppDecoder
-//! \{
-
-#define pi 3.1415926
-
-int get_mem2DPelWithPad(unsigned char ***array2D, int dim0, int dim1, int iPadY, int iPadX)
-{
-  int i;
-  unsigned char *curr = NULL;
-  int iHeight, iWidth;
-
-  iHeight = dim0+2*iPadY;
-  iWidth = dim1+2*iPadX;
-  (*array2D) = (unsigned char**)malloc(iHeight*sizeof(unsigned char*));
-  *(*array2D) = (unsigned char* )calloc(iHeight * iWidth, sizeof(unsigned char ));
-
-  (*array2D)[0] += iPadX;
-  curr = (*array2D)[0];
-  for(i = 1 ; i < iHeight; i++)
-  {
-    curr += iWidth;
-    (*array2D)[i] = curr;
-  }
-  (*array2D) = &((*array2D)[iPadY]);
-
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+
+#include "DownConvert.h"
+
+typedef struct
+{
+  int            stride;
+  int            lines;
+  unsigned char* data;
+  unsigned char* data2;
+} ColorComponent;
+
+typedef struct
+{
+  ColorComponent y;
+  ColorComponent u;
+  ColorComponent v;
+} YuvFrame;
+
+
+void
+  createColorComponent( ColorComponent& c, int maxwidth, int maxheight )
+{
+  maxwidth  = ( ( maxwidth  + 15 ) >> 4 ) << 4;
+  maxheight = ( ( maxheight + 15 ) >> 4 ) << 4;
+  int size  = maxwidth * maxheight;
+  c.stride  = maxwidth;
+  c.lines   = maxheight;
+  c.data    = new unsigned char [ size ];
+  c.data2   = new unsigned char [ size ];
+
+  if( ! c.data || ! c.data2 )
+  {
+    fprintf(stderr, "\nERROR: memory allocation failed!\n\n");
+    exit(1);
+  }
+}
+
+void
+  deleteColorComponent( ColorComponent& c )
+{
+  delete[] c.data;
+  delete[] c.data2;
+  c.stride  = 0;
+  c.lines   = 0;
+  c.data    = 0;
+  c.data2   = 0;
+}
+
+int
+  readColorComponent( ColorComponent& c, FILE* file, int width, int height, bool second )
+{
+  assert( width  <= c.stride );
+  assert( height <= c.lines  );
+
+  int iMaxPadWidth  = gMin( c.stride, ( ( width  + 15 ) >> 4 ) << 4 );
+  int iMaxPadHeight = gMin( c.lines,  ( ( height + 31 ) >> 5 ) << 5 );
+
+  for( int i = 0; i < height; i++ )
+  {
+    unsigned char* buffer = ( second ? c.data2 : c.data ) + i * c.stride;
+    int            rsize  = (int)fread( buffer, sizeof(unsigned char), width, file );
+    if( rsize != width )
+    {
+      return 1;
+    }
+    for( int xp = width; xp < iMaxPadWidth; xp++ )
+    {
+      buffer[xp] = buffer[xp-1];
+    }
+  }
+  for( int yp = height; yp < iMaxPadHeight; yp++ )
+  {
+    unsigned char* buffer  = ( second ? c.data2 : c.data ) + yp * c.stride;
+    unsigned char* bufferX = buffer - c.stride;
+    for( int xp = 0; xp < c.stride; xp++ )
+    {
+      buffer[xp] = bufferX[xp];
+    }
+  }
   return 0;
 }
 
-int get_mem2DintWithPad(int ***array2D, int dim0, int dim1, int iPadY, int iPadX)
-{
-  int i;
-  int *curr = NULL;
-  int iHeight, iWidth;
-
-  iHeight = dim0+2*iPadY;
-  iWidth = dim1+2*iPadX;
-  (*array2D) = (int**)malloc(iHeight*sizeof(int*));
-  *(*array2D) = (int* )calloc(iHeight * iWidth, sizeof(int ));
-
-  (*array2D)[0] += iPadX;
-  curr = (*array2D)[0];
-  for(i = 1 ; i < iHeight; i++)
-  {
-    curr += iWidth;
-    (*array2D)[i] = curr;
-  }
-  (*array2D) = &((*array2D)[iPadY]);
-
+void
+  duplicateColorComponent( ColorComponent& c )
+{
+  memcpy( c.data2, c.data, c.stride * c.lines * sizeof(unsigned char) );
+}
+
+void
+  combineTopAndBottomInColorComponent( ColorComponent& c, Bool bBotField )
+{
+  int            offs = ( bBotField ? c.stride : 0 );
+  unsigned char* pDes = c.data  + offs;
+  unsigned char* pSrc = c.data2 + offs;
+  for( int i = 0; i < c.lines / 2; i++, pDes += 2*c.stride, pSrc += 2*c.stride )
+  {
+    memcpy( pDes, pSrc, c.stride * sizeof(unsigned char) );
+  }
+}
+
+void
+  writeColorComponent( ColorComponent& c, FILE* file, int width, int height, bool second )
+{
+  assert( width  <= c.stride );
+  assert( height <= c.lines  );
+
+  for( int i = 0; i < height; i++ )
+  {
+    unsigned char* buffer = ( second ? c.data2 : c.data ) + i * c.stride;
+    int            wsize  = (int)fwrite( buffer, sizeof(unsigned char), width, file );
+
+    if( wsize != width )
+    {
+      fprintf(stderr, "\nERROR: while writing to output file!\n\n");
+      exit(1);
+    }
+  }
+}
+
+
+void
+  createFrame( YuvFrame& f, int width, int height )
+{
+  createColorComponent( f.y, width,      height      );
+  createColorComponent( f.u, width >> 1, height >> 1 );
+  createColorComponent( f.v, width >> 1, height >> 1 );
+}
+
+void
+  deleteFrame( YuvFrame& f )
+{
+  deleteColorComponent( f.y );
+  deleteColorComponent( f.u );
+  deleteColorComponent( f.v );
+}
+
+int
+  readFrame( YuvFrame& f, FILE* file, int width, int height, bool second = false )
+{
+  ROTRS( readColorComponent( f.y, file, width,      height,      second ), 1 );
+  ROTRS( readColorComponent( f.u, file, width >> 1, height >> 1, second ), 1 );
+  ROTRS( readColorComponent( f.v, file, width >> 1, height >> 1, second ), 1 );
   return 0;
 }
 
-void free_mem2DPelWithPad(unsigned char **array2D, int iPadY, int iPadX)
-{
-  if (array2D)
-  {
-    if (*array2D)
-    {
-      free (array2D[-iPadY]-iPadX);
-    }
-    else 
-    {
-      printf("free_mem2DintWithPad: trying to free unused memory\r\nPress Any Key\r\n");
-    }
-
-    free (&array2D[-iPadY]);
-  } 
-  else
-  {
-    printf("free_mem2DintWithPad: trying to free unused memory\r\nPress Any Key\r\n");
-  }
-}
-
-void free_mem2DintWithPad(int **array2D, int iPadY, int iPadX)
-{
-  if (array2D)
-  {
-    if (*array2D)
-    {
-      free (array2D[-iPadY]-iPadX);
-    }
-    else 
-    {
-      printf("free_mem2DintWithPad: trying to free unused memory\r\nPress Any Key\r\n");
-    }
-
-    free (&array2D[-iPadY]);
-  } 
-  else
-  {
-    printf("free_mem2DintWithPad: trying to free unused memory\r\nPress Any Key\r\n");
-  }
-}
-
-void PadImgHorizontal(unsigned char **src, unsigned char **dst, int height, int width, int pad_h)
-{
-  int i, j;
-  unsigned char *BufSrc, *BufDst;
-
-  for (j=0;j<height;j++)
-  {    
-    BufDst = &(dst[j][-pad_h] );
-    BufSrc = src[j];
-    for (i=0;i<pad_h;i++)
-    {
-      *(BufDst++) = BufSrc[0];
-    }
-    memcpy(BufDst, BufSrc, width*sizeof(unsigned char));
-    BufDst += width;
-    for (i=0;i<pad_h;i++)
-    {
-      *(BufDst++) = BufSrc[width-1];
-    }
-  }
-}
-
-void FilterImg( unsigned char **src,
-                int           **temp,
-                unsigned char **dst,
-                int           height1,  
-                int           width1,  
-                int           M, 
-                int           N, 
-                int           **phase_filter,
-                int           length,
-                int           shift,
-                int           plane)
-{
-  int height2,width2;
-  int k,iSum;
-  int i0, div_i0, i1;
-  int j0, div_j0, j1;
-  int *p_filter;
-  unsigned char *p_src, *p_dst;
-  int **p_temp, *p_tmp;
-  int shift2 = (2*shift);
-  int shift_round = (1 << (2 * shift - 1));
-
-  height2 = (height1 * M) / N;
-  width2  = (width1  * M) / N;
-
-  // horizontal filtering
-  for(j1 = 0; j1 < height1; j1++)
-  {
-    i0=-N;
-    p_tmp = temp[j1];
-    for(i1 = 0; i1 < width2; i1++)
-    {
-      i0      += N;
-      div_i0   = (i0 / M);
-      p_src    = &src[j1][ div_i0 - (length >> 1)];
-      p_filter = phase_filter[i0 - div_i0 * M];
-      iSum     = 0;
-      for(k = 0; k < length; k++)
-      {
-        iSum += (*p_src++) * (*p_filter++);
-      }
-      *p_tmp++ = iSum;
-    }
-  }
-
-  // pad temp (vertical)
-  for (k=-(length>>1);k<0;k++)
-    memcpy(temp[k], temp[0], width2*sizeof(int));
-  for (k=height1;k<(height1+(length>>1));k++)
-    memcpy(temp[k], temp[k-1], (width2)* sizeof(int));
-
-  // vertical filtering
-  j0 = (plane == 0) ? -N : -(N-1);
-  
-  for(j1 = 0; j1 < height2; j1++)
-  {
-    j0      += N;
-    div_j0   = (j0 / M);
-    p_dst    = dst[j1];
-    p_temp   = &temp[div_j0 - (length>>1)];
-    p_filter = phase_filter[j0 - div_j0 * M];
-    for(i1 = 0; i1 < width2;i1++)
-    {
-      iSum=0;
-      for(k = 0; k < length; k++)
-      {
-        iSum += p_temp[k][i1] * p_filter[k];
-      }
-      iSum=((iSum + shift_round) >> shift2);
-      *p_dst++ = (unsigned char)(iSum > 255 ? 255 : iSum < 0 ? 0 : iSum);
-    }
-  }
-}
-
-// ====================================================================================================================
-// Main function
-// ====================================================================================================================
-
-int main(int argc, char *argv[])
-{
-  const int phase_filter_0[4][13]={
-    {0,  2,  -3,  -9,   6,  39,  58,  39,   6,  -9,  -3,  2,  0},  
-    {0,  1,  -1,  -8,  -1,  31,  57,  47,  13,  -7,  -5,  1,  0},  
-    {0,  1,   0,  -7,  -5,  22,  53,  53,  22,  -5,  -7,  0,  1},  
-    {0,  0,   1,  -5,  -7,  13,  47,  57,  31,  -1,  -8,-1,  1}  
-  };
-
-  const int phase_filter_1[8][13]={
-    {0,   0,  5,  -6,  -10,  37,  76,  37,-10,   -6, 5,  0,   0},    
-    {0,  -1,  5,  -3,  -12,  29,  75,  45,  -7,   -8, 5,  0,   0},    
-    {0,  -1,  4,  -1,  -13,  22,  73,  52,  -3,  -10, 4,  1,   0},    
-    {0,  -1,  4,   1,  -13,  14,  70,  59,   2,  -12, 3,  2,  -1},  
-    {0,  -1,  3,   2,  -13,   8,  65,  65,   8,  -13, 2,  3,  -1},    
-    {0,  -1,  2,   3,  -12,   2,  59,  70,  14,  -13, 1,  4,  -1},    
-    {0,   0,  1,   4,  -10,  -3,  52,  73,  22,  -13,-1,  4,  -1},    
-    {0,   0,  0,   5,   -8,  -7,  45,  75,  29,  -12,-3,  5,  -1}    
-  };
-
-  int i,j;
-
-  int width_org,  width_org_c,  width_sampled,  width_sampled_c;
-  int height_org, height_org_c, height_sampled, height_sampled_c;
-  int size_org,   size_org_c,   size_sampled,   size_sampled_c;
-
-  unsigned char **Y1,    **U1,    **V1;
-  unsigned char **Y2,    **U2,    **V2;
-  unsigned char **temp_luma,    **temp_chroma;
-  int           **tempY, **tempU, **tempV;
-
-  int **phase_filter;
-  int log2_scaling_factor=7;
-
-  FILE * infile;
-  FILE * outfile;
-
-  int M = -1 ,N = -1;
-  int ratio = -1;
-  int Frames=0;
-  int totalFrames=0;
-  int StartFrame=0;
-  int Tap=13;
-
-  if (argc < 6)
-  {
-    printf("\nIncorrect number of arguments!!!\n\n");
-    printf("Syntax: \n");
-    printf("%s <input width> <input height> <input file> <output file> <downsampling method> [frames_to_process] [start_frame]\n\n", argv[0]);
-    printf("<downsampling method> 0: 2x downsampling, 1: 1.5x downsampling. \n");
-    printf("Examples: \n");
-    printf("%s 1920 1080 input_1920x1080_24p.yuv output_960x540_24p.yuv 0 \n", argv[0]);
-    printf("%s 1920 1080 input_1920x1080_24p.yuv output_1280x720_24p.yuv 1 \n", argv[0]);
-    return -1;
-  }
-
-  width_org  = atoi  (argv[1]);
-  height_org = atoi  (argv[2]);
-  infile     = fopen (argv[3], "rb");
-  outfile    = fopen (argv[4], "wb");
-  ratio      = atoi  (argv[5]); 
-
-  for(i=7; i<= argc; i++)
-  {
-    switch(i)
-    {
-    case 7:
-      Frames = atoi(argv[6]);
-      break;
-    case 8:
-      StartFrame = atoi(argv[7]);
-      break;
-    default:
-      printf("Too many input arguments");
-      break;
-    }
-  }
-
-  if( width_org < 4 || height_org < 4 )
-  {
-    printf("\ninput resolution is too small, exit\n");
-    return -1;
-  }
-  if ( infile == NULL || outfile == NULL )
-  {
-    printf("\ninput or output file is invalid, exit\n");
-    return -1;
-  }
-  if ((argc > 6) && (Frames < 1 || StartFrame < 0))
-  {
-    printf("input frame parameter error\n");
-    return -1;
-  }
-
-  switch( ratio )
-  {
-  default:
-    printf("\ndown sampling parameter %d is not supported (0: 2x downsampling, 1: 1.5x downsampling)\n", ratio);
-    return -1;
-  case 0:
-    M=4;
-    N=8;
-    break;
-  case 1:
-    M=8;
-    N=12;
-    break;
-  }
-
-  width_org_c      = width_org  >> 1;
-  height_org_c     = height_org >> 1;
-  width_sampled    = (width_org  * M) / N;
-  height_sampled   = (height_org * M) / N;
-  width_sampled_c  = width_sampled  >> 1;
-  height_sampled_c = height_sampled >> 1;
-  size_org         = height_org * width_org;
-  size_org_c       = height_org_c * width_org_c;
-  size_sampled     = height_sampled * width_sampled;
-  size_sampled_c   = height_sampled_c * width_sampled_c;
-
-  printf("\n=============================================================\n");
-  printf("\n Input  = %s", argv[3]);
-  printf("\n Output = %s", argv[4]);
-  printf("\n Rescaling input from (%d,%d) to (%d,%d) resolution\n", width_org, height_org, width_sampled, height_sampled);
-  printf("\n=============================================================\n\n");  
-
-  // construct phase filters
-  get_mem2DintWithPad (&phase_filter, M, Tap, 0, 0);
-
-  for (j=0;j<M;j++)
-    for (i=0;i<Tap;i++)
-      phase_filter[j][i]= ratio==0 ? phase_filter_0[j][i] :  phase_filter_1[j][i];
-
-  get_mem2DPelWithPad (&Y1, height_org,   width_org,   0, Tap>>1);
-  get_mem2DPelWithPad (&U1, height_org_c, width_org_c, 0, Tap>>1);
-  get_mem2DPelWithPad (&V1, height_org_c, width_org_c, 0, Tap>>1);
-
-  get_mem2DintWithPad (&tempY, height_org,   width_sampled,   Tap>>1, 0);
-  get_mem2DintWithPad (&tempU, height_org_c, width_sampled_c, Tap>>1, 0);
-  get_mem2DintWithPad (&tempV, height_org_c, width_sampled_c, Tap>>1, 0);
-
-  get_mem2DPelWithPad (&Y2, height_sampled,   width_sampled,  0,0);
-  get_mem2DPelWithPad (&U2, height_sampled_c, width_sampled_c,0,0);
-  get_mem2DPelWithPad (&V2, height_sampled_c, width_sampled_c,0,0);
-
-  get_mem2DPelWithPad (&temp_luma,   height_org,   width_org,  0,0);
-  get_mem2DPelWithPad (&temp_chroma, height_org_c, width_org_c,0,0);
-
-  if(StartFrame!=0)
-  {
-    for (i = 0; i < StartFrame; i ++)
-    {
-      fread(temp_luma[0], sizeof(unsigned char), size_org,     infile);
-      fread(temp_chroma[0], sizeof(unsigned char), size_org_c, infile);
-      fread(temp_chroma[0], sizeof(unsigned char), size_org_c, infile);
-      if (feof(infile))
-      {
-        printf("\nThe start frame number exceeds the file size\n");
-        return -1;
-      }
-    }
-    //fseek64(infile, (size_org * StartFrame * 3) >> 1,SEEK_SET);
-  }
-
-  if (Frames)
-  {
-    totalFrames = Frames;
-  }
-  else
-  {
-    totalFrames = 0x7FFF;
-  }
-
-  i = 0;
-  while(totalFrames)
-  {
-    
-    // read and pad Y
-    fread(temp_luma[0], sizeof(unsigned char), size_org,     infile);
-    PadImgHorizontal(temp_luma, Y1, height_org, width_org, Tap>>1);
-
-    // read and pad U
-    fread(temp_chroma[0], sizeof(unsigned char), size_org_c, infile);
-    PadImgHorizontal(temp_chroma, U1, height_org_c, width_org_c, Tap>>1);
-
-    // read and pad V
-    fread(temp_chroma[0], sizeof(unsigned char), size_org_c, infile);
-    PadImgHorizontal(temp_chroma, V1, height_org_c, width_org_c, Tap>>1);
-
-    if (feof(infile))
-    {
-      break;
-    }
-
-    fprintf(stdout,"Rescaling %dth frame\r", i);
-    fflush(stdout);
-
-    i ++;
-    totalFrames --;
-
-    FilterImg(Y1,tempY,Y2,height_org,  width_org,  M, N, phase_filter,Tap,log2_scaling_factor,0);
-    FilterImg(U1,tempU,U2,height_org_c,width_org_c,M, N, phase_filter,Tap,log2_scaling_factor,1);
-    FilterImg(V1,tempV,V2,height_org_c,width_org_c,M, N, phase_filter,Tap,log2_scaling_factor,2);
-
-    // write a sampled frame
-    fwrite(Y2[0], sizeof(unsigned char), size_sampled,     outfile);
-    fwrite(U2[0], sizeof(unsigned char), size_sampled_c, outfile);
-    fwrite(V2[0], sizeof(unsigned char), size_sampled_c, outfile);
-
-  }
-
-  printf("\nEnd of rescaling process.\n");
-
-  free_mem2DintWithPad (phase_filter, 0, 0);
-
-  free_mem2DPelWithPad (Y1, 0, Tap>>1);
-  free_mem2DPelWithPad (U1, 0, Tap>>1);
-  free_mem2DPelWithPad (V1, 0, Tap>>1);
-
-  free_mem2DintWithPad (tempY, Tap>>1, 0);
-  free_mem2DintWithPad (tempU, Tap>>1, 0);
-  free_mem2DintWithPad (tempV, Tap>>1, 0);
-
-  free_mem2DPelWithPad (Y2,0,0);
-  free_mem2DPelWithPad (U2,0,0);
-  free_mem2DPelWithPad (V2,0,0);
-
-  free_mem2DPelWithPad (temp_luma,  0,0);
-  free_mem2DPelWithPad (temp_chroma,0,0);
-
-  fclose(infile);
-  fclose(outfile);
-
+void
+  duplicateFrame( YuvFrame& f )
+{
+  duplicateColorComponent( f.y );
+  duplicateColorComponent( f.u );
+  duplicateColorComponent( f.v );
+}
+
+void
+  combineTopAndBottomInFrame( YuvFrame& f, Bool botField )
+{
+  combineTopAndBottomInColorComponent( f.y, botField );
+  combineTopAndBottomInColorComponent( f.u, botField );
+  combineTopAndBottomInColorComponent( f.v, botField );
+}
+
+void
+  writeFrame( YuvFrame& f, FILE* file, int width, int height, bool both = false )
+{
+  writeColorComponent( f.y, file, width,      height,      false );
+  writeColorComponent( f.u, file, width >> 1, height >> 1, false );
+  writeColorComponent( f.v, file, width >> 1, height >> 1, false );
+
+  if( both )
+  {
+    writeColorComponent( f.y, file, width,      height,      true );
+    writeColorComponent( f.u, file, width >> 1, height >> 1, true );
+    writeColorComponent( f.v, file, width >> 1, height >> 1, true );
+  }
+}
+
+
+void
+  print_usage_and_exit( int test, const char* name, const char* message = 0 )
+{
+  if( test )
+  {
+    if( message )
+    {
+      fprintf ( stderr, "\nERROR: %s\n", message );
+    }
+    fprintf (   stderr, "\nUsage: %s <win> <hin> <in> <wout> <hout> <out> [<t> [<skip> [<frms>]]] [[-phase <args>] ]\n\n", name );
+    fprintf (   stderr, "  win     : input width  (luma samples)\n" );
+    fprintf (   stderr, "  hin     : input height (luma samples)\n" );
+    fprintf (   stderr, "  in      : input file\n" );
+    fprintf (   stderr, "  wout    : output width  (luma samples)\n" );
+    fprintf (   stderr, "  hout    : output height (luma samples)\n" );
+    fprintf (   stderr, "  out     : output file\n" );
+    fprintf (   stderr, "\n--------------------------- OPTIONAL ---------------------------\n\n" );
+    fprintf (   stderr, "  t       : number of temporal downsampling stages (default: 0)\n" );
+    fprintf (   stderr, "  skip    : number of frames to skip at start (default: 0)\n" );
+    fprintf (   stderr, "  frms    : number of frames wanted in output file (default: max)\n" );
+    fprintf (   stderr, "\n-------------------------- OVERLOADED --------------------------\n\n" );
+    fprintf (   stderr, " -phase <in_uv_ph_x> <in_uv_ph_y> <out_uv_ph_x> <out_uv_ph_y>\n");
+    fprintf (   stderr, "   in_uv_ph_x : input  chroma phase shift in horizontal direction (default:-1)\n" );
+    fprintf (   stderr, "   in_uv_ph_y : input  chroma phase shift in vertical   direction (default: 0)\n" );
+    fprintf (   stderr, "   out_uv_ph_x: output chroma phase shift in horizontal direction (default:-1)\n" );
+    fprintf (   stderr, "   out_uv_ph_y: output chroma phase shift in vertical   direction (default: 0)\n" );
+    fprintf (   stderr, "\n\n");
+    exit    (   1 );
+  }
+}
+
+
+void
+  updateCropParametersFromFile( ResizeParameters& cRP, FILE* cropFile, int resamplingMethod, char* name )
+{
+  int crop_x0 = 0;
+  int crop_y0 = 0;
+  int crop_w  = 0;
+  int crop_h  = 0;
+  if( fscanf( cropFile, "%d,%d,%d,%d\n", &crop_x0, &crop_y0, &crop_w, &crop_h ) == 4 )
+  {
+    cRP.m_iLeftFrmOffset      = crop_x0;
+    cRP.m_iTopFrmOffset       = crop_y0;
+    cRP.m_iScaledRefFrmWidth  = crop_w;
+    cRP.m_iScaledRefFrmHeight = crop_h;
+  }
+  print_usage_and_exit( cRP.m_iLeftFrmOffset     & 1 || cRP.m_iTopFrmOffset       & 1,                                              name, "cropping parameters must be even values" );
+  print_usage_and_exit( cRP.m_iScaledRefFrmWidth & 1 || cRP.m_iScaledRefFrmHeight & 1,                                              name, "cropping parameters must be even values" );
+  print_usage_and_exit( resamplingMethod == 2 && cRP.m_iScaledRefFrmWidth  != gMin( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  ),  name, "crop dimensions must be the same as the minimal dimensions" );
+  print_usage_and_exit( resamplingMethod == 2 && cRP.m_iScaledRefFrmHeight != gMin( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight ),  name, "crop dimensions must be the same as the minimal dimensions" );
+  print_usage_and_exit( cRP.m_iScaledRefFrmWidth  > gMax( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  ),                            name, "wrong crop window size" );
+  print_usage_and_exit( cRP.m_iScaledRefFrmHeight > gMax( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight ),                            name, "wrong crop window size" );
+  print_usage_and_exit( cRP.m_iScaledRefFrmWidth  < gMin( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  ),                            name, "wrong crop window size" );
+  print_usage_and_exit( cRP.m_iScaledRefFrmHeight < gMin( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight ),                            name, "wrong crop window size" );
+  print_usage_and_exit( cRP.m_iLeftFrmOffset + cRP.m_iScaledRefFrmWidth  > gMax( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  ),     name, "wrong crop window size and origin" );
+  print_usage_and_exit( cRP.m_iTopFrmOffset  + cRP.m_iScaledRefFrmHeight > gMax( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight ),     name, "wrong crop window size and origin" );
+}
+
+
+void
+  resampleFrame( YuvFrame&          rcFrame,
+  DownConvert&       rcDownConvert,
+  ResizeParameters&  rcRP,
+  int                resamplingMethod,
+  int                resamplingMode,
+  bool               resampling,
+  bool               upsampling,
+  bool               bSecondInputFrame )
+{
+  assert( upsampling == 0 );
+
+  //===== downsampling =====
+  ResizeParameters cRP = rcRP;
+  {
+    Int iRefVerMbShift        = ( cRP.m_bRefLayerFrameMbsOnlyFlag ? 4 : 5 );
+    Int iScaledVerShift       = ( cRP.m_bFrameMbsOnlyFlag         ? 1 : 2 );
+    Int iHorDiv               = ( cRP.m_iFrameWidth    <<               1 );
+    Int iVerDiv               = ( cRP.m_iFrameHeight   << iScaledVerShift );
+    Int iRefFrmW              = ( ( cRP.m_iFrameWidth   + ( 1 <<               4 ) - 1 ) >>               4 ) <<               4;        // round to next multiple of 16
+    Int iRefFrmH              = ( ( cRP.m_iFrameHeight  + ( 1 <<  iRefVerMbShift ) - 1 ) >>  iRefVerMbShift ) <<  iRefVerMbShift;        // round to next multiple of 16 or 32 (for interlaced)
+    Int iScaledRefFrmW        = ( ( cRP.m_iScaledRefFrmWidth  * iRefFrmW + ( iHorDiv >> 1 ) ) / iHorDiv ) <<               1;  // scale and round to next multiple of  2
+    Int iScaledRefFrmH        = ( ( cRP.m_iScaledRefFrmHeight * iRefFrmH + ( iVerDiv >> 1 ) ) / iVerDiv ) << iScaledVerShift;  // scale and round to next multiple of  2 or  4 (for interlaced)
+    cRP.m_iFrameWidth         = iRefFrmW;
+    cRP.m_iFrameHeight        = iRefFrmH;
+    cRP.m_iScaledRefFrmWidth  = iScaledRefFrmW;
+    cRP.m_iScaledRefFrmHeight = iScaledRefFrmH;
+  }
+  assert( resamplingMethod == 0 );
+  if( resamplingMode < 4 )
+  {
+    rcDownConvert.downsamplingSVC       ( rcFrame.y.data,  rcFrame.y.stride, rcFrame.u.data,  rcFrame.u.stride, rcFrame.v.data,  rcFrame.v.stride, &cRP, resamplingMode == 3 );
+    return;
+  }
+}
+
+
+
+int
+  main( int argc, char *argv[] )
+{
+  //===== set standard resize parameters =====
+  ResizeParameters cRP;
+  cRP.m_bRefLayerFrameMbsOnlyFlag   = true;
+  cRP.m_bFrameMbsOnlyFlag           = true;
+  cRP.m_bRefLayerFieldPicFlag       = false;
+  cRP.m_bFieldPicFlag               = false;
+  cRP.m_bRefLayerBotFieldFlag       = false;
+  cRP.m_bBotFieldFlag               = false;
+  cRP.m_bRefLayerIsMbAffFrame       = false;
+  cRP.m_bIsMbAffFrame               = false;
+#if ZERO_PHASE
+  cRP.m_iRefLayerChromaPhaseX       = 0;
+  cRP.m_iRefLayerChromaPhaseY       = 1;
+  cRP.m_iChromaPhaseX               = 0;
+  cRP.m_iChromaPhaseY               = 1;
+#else
+  cRP.m_iRefLayerChromaPhaseX       = -1;
+  cRP.m_iRefLayerChromaPhaseY       = 0;
+  cRP.m_iChromaPhaseX               = -1;
+  cRP.m_iChromaPhaseY               = 0;
+#endif
+  cRP.m_iRefLayerFrmWidth           = 0;
+  cRP.m_iRefLayerFrmHeight          = 0;
+  cRP.m_iScaledRefFrmWidth          = 0;
+  cRP.m_iScaledRefFrmHeight         = 0;
+  cRP.m_iFrameWidth                 = 0;
+  cRP.m_iFrameHeight                = 0;
+  cRP.m_iLeftFrmOffset              = 0;
+  cRP.m_iTopFrmOffset               = 0;
+  //cRP.m_iExtendedSpatialScalability = 0;
+  cRP.m_iLevelIdc                   = 0;
+
+  //===== init parameters =====
+  FILE* inputFile                   = 0;
+  FILE* outputFile                  = 0;
+  FILE* croppingParametersFile      = 0;
+  int   resamplingMethod            = 0;
+  int   resamplingMode              = 0;
+  bool  croppingInitialized         = false;
+  bool  phaseInitialized            = false;
+  bool  methodInitialized           = false;
+  bool  resampling                  = false;
+  bool  upsampling                  = false;
+  int   numSpatialDyadicStages      = 0;
+  int   skipBetween                 = 0;
+  int   skipAtStart                 = 0;
+  int   maxNumOutputFrames          = 0;
+
+
+  //===== read input parameters =====
+  print_usage_and_exit( ( argc < 7 || argc > 24 ), argv[0], "wrong number of arguments" );
+  cRP.m_iRefLayerFrmWidth   = atoi  ( argv[1] );
+  cRP.m_iRefLayerFrmHeight  = atoi  ( argv[2] );
+  inputFile                 = fopen ( argv[3], "rb" );
+  cRP.m_iFrameWidth         = atoi  ( argv[4] );
+  cRP.m_iFrameHeight        = atoi  ( argv[5] );
+  outputFile                = fopen ( argv[6], "wb" );
+  print_usage_and_exit( ! inputFile,  argv[0], "failed to open input file" );
+  print_usage_and_exit( ! outputFile, argv[0], "failed to open input file" );
+  print_usage_and_exit( cRP.m_iRefLayerFrmWidth > cRP.m_iFrameWidth && cRP.m_iRefLayerFrmHeight < cRP.m_iFrameHeight, argv[0], "mixed upsampling and downsampling not supported" );
+  print_usage_and_exit( cRP.m_iRefLayerFrmWidth < cRP.m_iFrameWidth && cRP.m_iRefLayerFrmHeight > cRP.m_iFrameHeight, argv[0], "mixed upsampling and downsampling not supported" );
+  for( int i = 7; i < argc; )
+  {
+    if( ! strcmp( argv[i], "-phase" ) )
+    {
+      print_usage_and_exit( resamplingMethod != 0,          argv[0], "phases only supported in normative resampling" );
+      print_usage_and_exit( phaseInitialized || argc < i+5, argv[0], "wrong number of phase parameters" );
+      phaseInitialized = true;
+      i++;
+      cRP.m_iRefLayerChromaPhaseX = atoi( argv[i++] );
+      cRP.m_iRefLayerChromaPhaseY = atoi( argv[i++] );
+      cRP.m_iChromaPhaseX         = atoi( argv[i++] );
+      cRP.m_iChromaPhaseY         = atoi( argv[i++] );
+      print_usage_and_exit( cRP.m_iRefLayerChromaPhaseX > 0 || cRP.m_iRefLayerChromaPhaseX < -1, argv[0], "wrong phase x parameters (range : [-1, 0])");
+      print_usage_and_exit( cRP.m_iRefLayerChromaPhaseY > 1 || cRP.m_iRefLayerChromaPhaseY < -1, argv[0], "wrong phase x parameters (range : [-1, 1])");
+      print_usage_and_exit( cRP.m_iChromaPhaseX         > 0 || cRP.m_iChromaPhaseX         < -1, argv[0], "wrong phase x parameters (range : [-1, 0])");
+      print_usage_and_exit( cRP.m_iChromaPhaseY         > 1 || cRP.m_iChromaPhaseY         < -1, argv[0], "wrong phase x parameters (range : [-1, 1])");
+    }
+    else if (i == 7)
+    {
+      methodInitialized = true;
+      resamplingMethod  = atoi( argv[i++] );
+      print_usage_and_exit( resamplingMethod < 0 || resamplingMethod > 4, argv[0], "unsupported method" );
+      if( resamplingMethod > 2 )
+      {
+        print_usage_and_exit( cRP.m_iRefLayerFrmWidth  > cRP.m_iFrameWidth,  argv[0], "method 3 and 4 are not supported for downsampling" );
+        print_usage_and_exit( cRP.m_iRefLayerFrmHeight > cRP.m_iFrameHeight, argv[0], "method 3 and 4 are not supported for downsampling" );
+      }
+      if( resamplingMethod != 2 )
+      {
+        resampling  = true;
+        upsampling  = ( cRP.m_iRefLayerFrmWidth < cRP.m_iFrameWidth ) || ( cRP.m_iRefLayerFrmHeight < cRP.m_iFrameHeight );
+      }
+      if( resamplingMethod == 1 )
+      {
+        if( upsampling )
+        {
+          int      div  = cRP.m_iFrameWidth / cRP.m_iRefLayerFrmWidth;
+          if     ( div == 1) numSpatialDyadicStages =  0;
+          else if( div == 2) numSpatialDyadicStages =  1;
+          else if( div == 4) numSpatialDyadicStages =  2;
+          else if( div == 8) numSpatialDyadicStages =  3;
+          else               numSpatialDyadicStages = -1;
+          print_usage_and_exit( numSpatialDyadicStages < 0,                           argv[0], "ratio not supported for dyadic upsampling method" );
+          print_usage_and_exit( div * cRP.m_iRefLayerFrmWidth  != cRP.m_iFrameWidth,  argv[0], "ratio is not dyadic in dyadic mode" );
+          print_usage_and_exit( div * cRP.m_iRefLayerFrmHeight != cRP.m_iFrameHeight, argv[0], "different horizontal and vertical ratio in dyadic mode" );
+        }
+        else
+        {
+          int      div  = cRP.m_iRefLayerFrmWidth / cRP.m_iFrameWidth;
+          if     ( div == 1) numSpatialDyadicStages =  0;
+          else if( div == 2) numSpatialDyadicStages =  1;
+          else if( div == 4) numSpatialDyadicStages =  2;
+          else if( div == 8) numSpatialDyadicStages =  3;
+          else               numSpatialDyadicStages = -1;
+          print_usage_and_exit( numSpatialDyadicStages < 0,                           argv[0], "ratio not supported for dyadic downsampling method" );
+          print_usage_and_exit( div * cRP.m_iFrameWidth  != cRP.m_iRefLayerFrmWidth,  argv[0], "ratio is not dyadic in dyadic mode" );
+          print_usage_and_exit( div * cRP.m_iFrameHeight != cRP.m_iRefLayerFrmHeight, argv[0], "different horizontal and vertical ratio in dyadic mode" );
+        }
+      }
+    }
+    else if( i == 8 )
+    {
+      int TStages = atoi( argv[i++] );
+      skipBetween = ( 1 << TStages ) - 1;
+      print_usage_and_exit( TStages < 0,              argv[0], "negative number of temporal stages" );
+    }
+    else if( i == 9 )
+    {
+      skipAtStart = atoi( argv[i++] );
+      print_usage_and_exit( skipAtStart < 0,          argv[0], "negative number of skipped frames at start" );
+    }
+    else if( i == 10 )
+    {
+      maxNumOutputFrames = atoi( argv[i++] );
+      print_usage_and_exit( maxNumOutputFrames < 0 ,  argv[0], "negative number of output frames" );
+    }
+    else
+    {
+      print_usage_and_exit( true, argv[0], "error in command line parameters" );
+    }
+  }
+  if( ! methodInitialized )
+  {
+    resampling  = true;
+    upsampling  = ( cRP.m_iRefLayerFrmWidth < cRP.m_iFrameWidth ) || ( cRP.m_iRefLayerFrmHeight < cRP.m_iFrameHeight );
+  }
+  if( ! croppingInitialized )
+  {
+    if( resamplingMethod == 2 )
+    {
+      cRP.m_iScaledRefFrmWidth  = gMin( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  );
+      cRP.m_iScaledRefFrmHeight = gMin( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight );
+    }
+    else
+    {
+      cRP.m_iScaledRefFrmWidth  = gMax( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  );
+      cRP.m_iScaledRefFrmHeight = gMax( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight );
+    }
+  }
+
+  //===== set basic parameters for resampling control =====
+  if( resamplingMethod == 0 )
+  {
+    if( resamplingMode == 1 )
+    {
+      cRP.m_bRefLayerFrameMbsOnlyFlag = false;
+      cRP.m_bFrameMbsOnlyFlag         = false;
+    }
+    else if( resamplingMode == 2 || resamplingMode == 3 )
+    {
+      cRP.m_bFrameMbsOnlyFlag     = false;
+      if( ! upsampling )
+      {
+        cRP.m_bFieldPicFlag       = true;
+        cRP.m_bBotFieldFlag       = ( resamplingMode == 3 );
+      }
+    }
+    else if( resamplingMode == 4 || resamplingMode == 5 )
+    {
+      cRP.m_bRefLayerFrameMbsOnlyFlag = false;
+      cRP.m_bRefLayerFieldPicFlag     = true;
+    }
+  }
+
+  //===== initialize classes =====
+  YuvFrame    cFrame;
+  DownConvert cDownConvert;
+  {
+    int maxWidth  = gMax( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  );
+    int maxHeight = gMax( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight );
+    int minWidth  = gMin( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  );
+    int minHeight = gMin( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight );
+    int minWRnd16 = ( ( minWidth  + 15 ) >> 4 ) << 4;
+    int minHRnd32 = ( ( minHeight + 31 ) >> 5 ) << 5;
+    maxWidth      = ( ( maxWidth  * minWRnd16 + ( minWidth  << 4 ) - 1 ) / ( minWidth  << 4 ) ) << 4;
+    maxHeight     = ( ( maxHeight * minHRnd32 + ( minHeight << 4 ) - 1 ) / ( minHeight << 4 ) ) << 4;
+    createFrame( cFrame, maxWidth, maxHeight );
+    cDownConvert.init(   maxWidth, maxHeight );
+  }
+
+  printf("Resampler\n\n");
+
+  //===== loop over frames =====
+  int   skip              = skipAtStart;
+  int   writtenFrames     = 0;
+  int   numInputFrames    = ( resamplingMode >= 4 && ! upsampling ? 2 : 1 );
+  int   numOutputFrames   = ( resamplingMode >= 4 &&   upsampling ? 2 : 1 );
+  bool  bFinished         = false;
+  long  startTime         = clock();
+  while( ! bFinished )
+  {
+    for( int inputFrame = 0; inputFrame < numInputFrames && ! bFinished; inputFrame++ )
+    {
+      //===== read input frame =====
+      for( int numToRead = skip + 1; numToRead > 0 && ! bFinished; numToRead-- )
+      {
+        bFinished = ( readFrame( cFrame, inputFile, cRP.m_iRefLayerFrmWidth, cRP.m_iRefLayerFrmHeight, inputFrame != 0 ) != 0 );
+      }
+      skip = skipBetween;
+      if( cRP.m_iExtendedSpatialScalability == 2 && ! bFinished )
+      {
+        updateCropParametersFromFile( cRP, croppingParametersFile, resamplingMethod, argv[0] );
+      }
+
+      //===== set resampling parameter =====
+      if( resamplingMethod != 0 &&
+        cRP.m_iScaledRefFrmWidth  == gMin( cRP.m_iRefLayerFrmWidth,  cRP.m_iFrameWidth  ) &&
+        cRP.m_iScaledRefFrmHeight == gMin( cRP.m_iRefLayerFrmHeight, cRP.m_iFrameHeight )   )
+      {
+        resampling = false;
+      }
+      else
+      {
+        resampling = true;
+      }
+
+      //===== resample input frame =====
+      if( ! bFinished )
+      {
+        resampleFrame( cFrame, cDownConvert, cRP, resamplingMethod, resamplingMode, resampling, upsampling, inputFrame != 0 );
+      }
+    }
+
+    //===== write output frame =====
+    if( ! bFinished )
+    {
+      Bool bWriteTwoFrames = ( numOutputFrames == 2 && ( maxNumOutputFrames == 0 || writtenFrames + 1 < maxNumOutputFrames ) );
+      writeFrame( cFrame, outputFile, cRP.m_iFrameWidth, cRP.m_iFrameHeight, bWriteTwoFrames );
+      writtenFrames += ( bWriteTwoFrames ? 2 : 1 );
+      bFinished      = ( maxNumOutputFrames != 0 && writtenFrames == maxNumOutputFrames );
+      fprintf( stderr, "\r%6d frames converted", writtenFrames );
+    }
+  }
+  long  endTime           = clock();
+
+  deleteFrame( cFrame );
+  fclose     ( inputFile );
+  fclose     ( outputFile );
+  if( croppingParametersFile )
+  {
+    fclose   ( croppingParametersFile );
+  }
+
+  fprintf( stderr, "\n" );
+  double deltaInSecond = (double)( endTime - startTime) / (double)CLOCKS_PER_SEC;
+  fprintf( stderr, "in %.2lf seconds => %.0lf ms/frame\n", deltaInSecond, deltaInSecond / (double)writtenFrames * 1000.0 );
+  if( writtenFrames < maxNumOutputFrames )
+  {
+    fprintf( stderr, "\nNOTE: less output frames generated than specified!!!\n\n" );
+  }
   return 0;
 }
-
-//! \}