ref_roi_common.c

JPEG2000实现的源码

    assert(width == (((last_col-b)>>1) - ((first_col+1-b)>>1) + 1));
    row_idx = (self->next_branch_row[b])++;
    roi_buffer__access_rows(&(base->buffer),base,row_idx,1,&(src));
    roi_buffer__release_rows(&(base->buffer),row_idx,1,1);
    neg = base->branch_neg_supports[b];
    pos = base->branch_pos_supports[b];
    for (n=(first_col & 1)^b; width > 0; width--, n += 2)
      {
        for (max=0, k=-neg; k <= pos; k++)
          {
            idx = n + k;
            if ((idx >= 0) && (idx < tile_cols) && (src[idx] > max))
              max = src[idx];
          }
        *(mask++) = max;
      }
  }
  /* SAIC General Decomp. End mods */
}

/*****************************************************************************/
/* STATIC                    vertical__get_mask_line                         */
/*****************************************************************************/

static void
  vertical__get_mask_line(roi_stage_ref base, roi_stage_ref requester,
                          std_byte *mask, int width)
{
  roi_vertical_ref self = (roi_vertical_ref) base;
  int b, row_idx, neg, pos, skip, support, k, n;
  std_byte **bufs, *sp, *mp;

  /* SAIC General Decomp. Begin mods */
  if (base->vert_limit > 1) {
    b = (base->branches[0] == requester)?0:1;
    assert(base->branches[b] == requester);
    assert(width == base->buffer.tile_dims.cols);
    row_idx = self->next_branch_row[b]++;
    row_idx = (row_idx<<1) + ((base->buffer.tile_dims.top_row & 1) ^ b);
    bufs = self->bufs;
    neg = base->branch_neg_supports[b];
    pos = base->branch_pos_supports[b];
    support = neg+pos+1;
    roi_buffer__access_rows(&(base->buffer),base,row_idx-neg,support,bufs);
    roi_buffer__release_rows(&(base->buffer),row_idx-neg,2,1);
    skip = -(row_idx-neg);
    if (skip <= 0)
      skip = 0;
    else
      { bufs += skip; support -= skip; neg -= skip; assert(neg >= 0); }
    skip = (row_idx+pos) - (base->buffer.tile_dims.rows-1);
    if (skip <= 0)
      skip = 0;
    else
      { support -= skip; pos -= skip; assert(pos >= 0); }
    memset(mask,0,(size_t) width);
    for (k=0; k < support; k++)
      {
        assert(bufs[k] != NULL);
        for (sp=bufs[k], mp=mask, n=width; n > 0; n--, sp++, mp++)
          if (*sp > *mp)
            *mp = *sp;
      }
  }
  /* SAIC General Decomp. End mods */
}

/* Begin ROIrect */
/*****************************************************************************/
/* STATIC                   horizontal__get_mask_rects                       */
/*****************************************************************************/

static roi_region_ptr
  horizontal__get_mask_rects(roi_stage_ref base, roi_stage_ref requester)
{
  roi_region_ptr list, elt, scan;
  roi_rectangle_ptr rect;
  int b, neg, pos;
  int boundary, tile_left, tile_right;

  if (base->regions == NULL)
    base->regions = base->parent->get_mask_rects(base->parent,base);
  b = (base->branches[0] == requester)?0:1;
  assert(base->branches[b] == requester);
  neg = base->branch_neg_supports[b];
  pos = base->branch_pos_supports[b];
  list = NULL;
  for (scan=base->regions; scan != NULL; scan=scan->next)
    {
      tile_left = base->buffer.tile_dims.left_col;
      tile_right = tile_left + base->buffer.tile_dims.cols - 1;
      if ((scan->rect.left > tile_right) || (scan->rect.right < tile_left))
        continue; /* Region does not intersect current tile. */
      
      elt = (roi_region_ptr)
        local_malloc(ROI_MEM_KEY,sizeof(roi_region));
      *elt = *scan;
      elt->next = list;
      list = elt;
      rect = &(elt->rect);

      /* Compute changes in the left hand boundary. */

      boundary = rect->left - pos;
      if (boundary < tile_left)
        boundary = tile_left;
      rect->left = (boundary+1-b)>>1; /* Map back to smallest column in band
                   whose location is >= left boundary in synthesized domain. */

      /* Find the tiles in which the left and right hand boundaries
         fall. */

      /* Now compute changes in the right hand boundary. */

      boundary = rect->right + neg;
      if (boundary > tile_right)
        boundary = tile_right;
      rect->right = (boundary-b)>>1; /* Map back to largest column in band
                  whose location is <= right boundary in synthesized domain. */
    }
  return(list);
}

/*****************************************************************************/
/* STATIC                    vertical__get_mask_rects                        */
/*****************************************************************************/

static roi_region_ptr
  vertical__get_mask_rects(roi_stage_ref base, roi_stage_ref requester)
{
  roi_region_ptr list, elt, scan;
  roi_rectangle_ptr rect;
  int b, neg, pos;
  int boundary, tile_top, tile_bottom;

  if (base->regions == NULL)
    base->regions = base->parent->get_mask_rects(base->parent,base);
  b = (base->branches[0] == requester)?0:1;
  assert(base->branches[b] == requester);
  neg = base->branch_neg_supports[b];
  pos = base->branch_pos_supports[b];
  list = NULL;
  for (scan=base->regions; scan != NULL; scan=scan->next)
    {
      tile_top = base->buffer.tile_dims.top_row;
      tile_bottom = tile_top + base->buffer.tile_dims.rows - 1;
      if ((scan->rect.top > tile_bottom) || (scan->rect.bottom < tile_top))
        continue; /* Region does not intersect current tile. */

      elt = (roi_region_ptr)
        local_malloc(ROI_MEM_KEY,sizeof(roi_region));
      *elt = *scan;
      elt->next = list;
      list = elt;
      rect = &(elt->rect);

      /* Compute changes in the top boundary first. */

      boundary = rect->top - pos;
      if (boundary < tile_top)
        boundary = tile_top;
      rect->top = (boundary+1-b)>>1; /* Map back to smallest row in band
                    whose location is >= top boundary in synthesized domain. */
      
      /* Now compute changes in the bottom boundary. */

      boundary = rect->bottom + neg;
      if (boundary > tile_bottom)
        boundary = tile_bottom;
      rect->bottom = (boundary-b)>>1; /* Map back to largest row in band
                 whose location is <= bottom boundary in synthesized domain. */
    }
  return(list);
}
/* End ROIrect */

/*****************************************************************************/
/* STATIC                          __terminate                               */
/*****************************************************************************/

static void
  __terminate(roi_stage_ref self)
{
  roi_stage_ref branch;
  roi_region_ptr reg; /* ROIrect */
  int b;

  roi_buffer__terminate(&(self->buffer));
  for (b=0; b < 2; b++)
    if ((branch = self->branches[b]) != NULL)
      branch->terminate(branch);
  /* Begin ROIrect */
  while ((reg=self->regions) != NULL)
    {
      self->regions = reg->next;
      local_free(reg);
    }
  /* End ROIrect */
  local_free(self);
}

/*****************************************************************************/
/* STATIC                        vertical__terminate                         */
/*****************************************************************************/

static void
  vertical__terminate(roi_stage_ref base)
{
  roi_vertical_ref self = (roi_vertical_ref) base;

  if (self->bufs != NULL)
    local_free(self->bufs);
  __terminate(base);
}


/* ========================================================================= */
/* ---------------------------- External Functions ------------------------- */
/* ========================================================================= */

/*****************************************************************************/
/* EXTERN                ref_roi_create_horizontal_stage                     */
/*****************************************************************************/

roi_stage_ref
  ref_roi_create_horizontal_stage(void)
{
  roi_horizontal_ref result;

  result = (roi_horizontal_ref)
    local_malloc(ROI_MEM_KEY,sizeof(roi_horizontal_obj));
  result->base.initialize = horizontal__initialize;
  result->base.get_mask_line = horizontal__get_mask_line;
  result->base.get_mask_rects = horizontal__get_mask_rects; /* ROIrect */
  result->base.terminate = __terminate;
  return(&(result->base));
}

/*****************************************************************************/
/* EXTERN                 ref_roi_create_vertical_stage                      */
/*****************************************************************************/

roi_stage_ref
  ref_roi_create_vertical_stage(void)
{
  roi_vertical_ref result;

  result = (roi_vertical_ref)
    local_malloc(ROI_MEM_KEY,sizeof(roi_vertical_obj));
  result->base.initialize = vertical__initialize;
  result->base.get_mask_line = vertical__get_mask_line;
  result->base.get_mask_rects = vertical__get_mask_rects; /* ROIrect */
  result->base.terminate = vertical__terminate;
  return(&(result->base));
}

/*****************************************************************************/
/* EXTERN                   ref_roi_create_band_stage                        */
/*****************************************************************************/

roi_stage_ref
  ref_roi_create_band_stage(void)
{
  roi_band_ref result;

  result = (roi_band_ref)
    local_malloc(ROI_MEM_KEY,sizeof(roi_band_obj));
  result->base.initialize = band__initialize;
  result->base.get_mask_line = NULL; /* This function should not be called. */
  result->base.get_mask_rects = NULL; /* ROIrect */
  result->base.terminate = __terminate;
  return(&(result->base));
}

/*****************************************************************************/
/* EXTERN                     ref_roi_get_band_mask                          */
/*****************************************************************************/

void
  ref_roi_get_band_mask(roi_band_ref band, int block_rows, int block_cols,
                        int top_row, int left_col, std_byte *mask[],
                        roi_component_info_ptr comp_info) /* ROIrect */
{
  roi_stage_ref base = &(band->base);
  int r;

  if (!comp_info->is_rectangular) /* ROIrect */
    { /* Generic recursive line-based computation. */
      roi_buffer__access_rows(&(base->buffer),base,top_row,block_rows,mask);
      roi_buffer__release_rows(&(base->buffer),top_row,block_rows,block_cols);
      for (r=0; r < block_rows; r++)
        mask[r] += left_col;
    }
  /* Begin ROIrect */
  else
    {
      roi_region_ptr reg;
      roi_rectangle_ptr rect;
      int mask_size;
      int top, left, right, bottom, c;

      if ((base->regions == NULL) && (base->parent != NULL))
        base->regions = base->parent->get_mask_rects(base->parent,base);
      assert(((top_row+block_rows) <= base->buffer.tile_dims.rows) &&
             ((left_col+block_cols) <= base->buffer.tile_dims.cols));
      mask_size = block_rows*block_cols;
      if (mask_size > comp_info->mask_buf_size)
        {
          comp_info->mask_buf_size = mask_size;
          if (comp_info->mask_buf == NULL)
            comp_info->mask_buf = (std_byte *)
              local_malloc(ROI_MEM_KEY,mask_size);
          else
            comp_info->mask_buf = (std_byte *)
              local_realloc(comp_info->mask_buf,mask_size);
        }
      for (mask[0]=comp_info->mask_buf, r=1; r < block_rows; r++)
        mask[r] = mask[r-1] + block_cols;
      memset(mask[0],0,(size_t) mask_size);
      top = base->buffer.tile_dims.top_row + top_row;
      bottom = top + block_rows - 1;
      left = base->buffer.tile_dims.left_col + left_col;
      right = left + block_cols - 1;
      for (reg=base->regions; reg != NULL; reg = reg->next)
        {
          int intersect_left, intersect_right, intersect_top, intersect_bottom;
          std_byte *mp, boost;

          rect = &(reg->rect);
          intersect_left = (left>rect->left)?left:rect->left;
          intersect_right = (right<rect->right)?right:rect->right;
          intersect_top = (top>rect->top)?top:rect->top;
          intersect_bottom = (bottom<rect->bottom)?bottom:rect->bottom;
          if ((intersect_left > intersect_right) ||
              (intersect_top > intersect_bottom))
            continue;
          boost = (std_byte)(reg->boost);
          for (r=intersect_top-top;
               intersect_top <= intersect_bottom; intersect_top++, r++)
            for (mp=mask[r]+intersect_left-left,
                 c=intersect_right-intersect_left; c >= 0; c--, mp++)
              if (*mp < boost)
                *mp = boost;
        }
    }
  /* End ROIrect */
}

/*****************************************************************************/
/* EXTERN                  ref_roi_terminate_component                       */
/*****************************************************************************/

void
  ref_roi_terminate_component(roi_component_info_ptr comp)
{
  roi_level_info_ptr lev;
  int n;

  if (comp->levels != NULL)
    {
      for (n=0; n <= comp->num_levels; n++)
        {
          lev = comp->levels + n;
          if (lev->bands != NULL)
            local_free(lev->bands);
        }
      local_free(comp->levels);
    }
  comp->levels = NULL;
  if (comp->mask_buf != NULL)
    local_free(comp->mask_buf);
  comp->mask_buf = NULL;
  comp->mask_buf_size = 0;
  if (comp->root != NULL)
    comp->root->terminate(comp->root);
}