hplx_hor_synthesis_by_convolution.c

JPEG2000实现的源码

      synthesis_end_filter(&branch_bufs[0][width/2-1],
                           &branch_bufs[1][width/2-1],
                           &branch_bufs[0][width/2-1]);
  }
  /* LANL Even Length End */

  /**** Start Point Symmetric SSWT ****/
  /* Data rearrangement is required for even length input data */
  if ((base->usePsExtension) && ((width % 2) == 0))
  {
    float dp0;
    float* low  = branch_bufs[0];
    float* high = branch_bufs[1];

    assert(width >= 4);
    dp0 = low[width / 2 - 1];
    low[width / 2 - 1] = (high[width / 2 - 1] + 0.75F * dp0
                          + 0.25F * low[width / 2 - 2]);
    high[width / 2 - 1] = 0;
  }
  /**** End Point Symmetric SSWT ****/

  /* First, apply the symmetric extension policy described in "ifc.h". */

  if (base->usePsExtension)
    {
      if (first_sample_odd)
        local_error("Cannot start image, tile or frame with an odd indexed "
                    "sample when using the PSE!  Use regular symmetric "
                    "extension!");
      for (b=0; b < base->horiz_limit; b++)
        {
          int odd_left, odd_right, band_cols;
          float sp0, dp0=0.0F;

          odd_left = 1-b;
          odd_right = (width + b) & 1;
          band_cols = (width+1-b)>>1;
          sp = branch_bufs[b];
          dp = sp + band_cols - 1;
          if (b == 1)
            sp0 = dp0 = 0.0F;
          else
            sp0 = sp[0];
          if (odd_left) /* Interleave right extensions before left. */
            for (n=1; n <= self->extend; n++)
              { dp[n] = 2 * dp0 - dp[-n+1-odd_right];
                sp[-n] = 2 * sp0 - sp[n-1+odd_left]; }
          else /* Interleave left extensions before right. */
            for (n=1; n <= self->extend; n++)
              { sp[-n] = 2 * sp0 - sp[n-1+odd_left];
                dp[n] = 2 * dp0 - dp[-n+1-odd_right]; }
        }
    }
  else if (self->even_taps)
    {
      /* LANL Even Length Begin */
      /* Disable odd indexing even filter error message in modified code */
      /* LANL Even Length End */
      for (b=0; b < base->horiz_limit; b++)
        {
          int odd_right, band_cols;
          float sign_flip;
          
          /* LANL Even Length Begin */
          /* Additional flags for odd extensions on the left */
          int odd_left = 0, asym_odd_left = 0;
          /* LANL Even Length End */

          sign_flip = (b==1)?-1.0F:1.0F;

          /* LANL Even Length Begin */
          band_cols = (width+1-b)>>1;
          /* Modify subband sizes in the even length input, even input
             offset case */
          if (!(width%2) && !first_sample_odd)
            band_cols += b?-1:+1;
          /* LANL Even Length End */

          sp = branch_bufs[b];
          dp = sp + band_cols - 1;
          odd_right = (width & 1);

          /* LANL Even Length Begin */
          /* Set up extension flags depending on input length and offset
             parity, and insert zeroes where "special" extension
             required */
          odd_left = 0;
          asym_odd_left = 0;
          if (width%2) {
            if (first_sample_odd) {
              if (b)
              *(++dp) = 0.0F;
            } else {
              odd_right = 0;
              odd_left = 1;
              oddevencase = 1;
              if (b) {
                *(sp-1) = 0.0F;
                asym_odd_left = 1;
              }
            }
          } else {
            if (!first_sample_odd) {
              odd_right = 1;
              odd_left = 1;
              evenevencase = 1;
            }
            if (b)
              *(++dp) = 0.0F;
          }
          /* LANL Even Length End */

          for (n=1; n <= self->extend; n++)
            { 
              /* LANL Even Length Begin */
              /* Correctly handle odd left symmetric extension */
              dp[n] =  sign_flip * dp[-n+1-odd_right];
              if (odd_left && b && (n==1))
                continue;
              sp[-n] = sign_flip * sp[n-1+odd_left-asym_odd_left];
              /* LANL Even Length End */
            }

        }

      /* LANL Even Length Begin */
      /* Correct filter alignment for even length filters is achieved
         by lying to the synthesis convolution about input offset parity */
      first_sample_odd = 0;
      /* LANL Even Length End */

    }
  else
    { /* Odd length filters with symmetric extension.  This is the nice
         easy case, which also is most flexible. */
      for (b=0; b < base->horiz_limit; b++)
        {
          int odd_left, odd_right, band_cols;

          odd_left = 1-(b^first_sample_odd);
          odd_right = (width + (b^first_sample_odd)) & 1;
          band_cols = (width+1-(b^first_sample_odd))>>1;
          sp = branch_bufs[b];
          dp = sp + band_cols - 1;
          if (odd_left) /* Interleave right extensions before left. */
            for (n=1; n <= self->extend; n++)
              { dp[n] = dp[-n+1-odd_right];
                sp[-n] = sp[n-1+odd_left]; }
          else /* Interleave left extensions before right. */
            for (n=1; n <= self->extend; n++)
              { sp[-n] = sp[n-1+odd_left];
                dp[n] = dp[-n+1-odd_right]; }
        }
    }

  /* Now apply each of the four polyphase synthesis kernels. */

  for (b=0; b < base->horiz_limit; b++)
    { /* Generate the b'th output sub-sequence: b=0 for even; b=1 for odd. */
      hplx_polyphase_kernel_ptr kernel;
      float *taps, sum;
      int subseq_cols, neg, pos, k;

      if (b == 0)
        kernel = self->branch_to_even;
      else
        kernel = self->branch_to_odd;
      subseq_cols = (width+1-(b^first_sample_odd))>>1;

      /* LANL Even Length Begin */
      /* For even length filters with filter centres at (1/2,1/2),
         switch polyphase kernels to get correct effective filter
         alignment */
      if (oddevencase || evenevencase) {
        if (b == 1)
          kernel = self->branch_to_even;
        else
          kernel = self->branch_to_odd;
      }
      /* LANL Even Length End */

      /* Apply kernel from low-pass band to get initial output samples. */

      sp = branch_bufs[0];
      if (b && first_sample_odd)
        sp--; /* Low pass sample corresponding to first odd sample. */
      neg = kernel->neg_support;
      pos = kernel->pos_support;
      taps = kernel->taps;

      /* LANL Even Length Begin */
      /* Kludge to get correct effective filter alignment for even
         length filters with filter centres at (1/2,1/2) */
      if ((oddevencase || evenevencase) && b)
        sp++;
      /* LANL Even Length End */

      for (dp=out_buf+(b^first_sample_odd),
           n=subseq_cols; n > 0; n--, dp+=2, sp++)
        {
          for (sum=0.0F, k=-neg; k <= pos; k++)
            sum += taps[k] * sp[k];
          *dp = sum;
        }

      /* Apply kernel from high-pass band and add to initial output samples. */

      kernel++;
      sp = branch_bufs[1];
      if ((!b) && first_sample_odd)
        sp++; /* High pass sample corresponding to first even sample. */
      neg = kernel->neg_support;
      pos = kernel->pos_support;
      taps = kernel->taps;

        /* LANL Even Length Begin */
        /* Kludge to get correct effective filter alignment for even
           length filters with filter centres at (1/2,1/2) */
      if ((oddevencase || evenevencase) && !b)
        sp--;
        /* LANL Even Length End */

      for (dp=out_buf+(b^first_sample_odd),
           n=subseq_cols; n > 0; n--, dp+=2, sp++)
        {
          for (sum=0.0F, k=-neg; k <= pos; k++)
            sum += taps[k] * sp[k];
          *dp += sum;
        }
    }
}


/* ========================================================================= */
/* ------------------ Implementation of Interface Functions ---------------- */
/* ========================================================================= */

/*****************************************************************************/
/* STATIC                         __initialize                               */
/*****************************************************************************/

static void
  __initialize(hplx_synthesis_stage_ref base, reverse_info_ref info,
               canvas_dims_ptr dims, canvas_dims_ptr frame_dims)