TI Compiler optimization: Linux vs. PC

typedef struct {
  void* restrict dest;
  const void* restrict src;
  void* restrict dest_base;      /* set in main setups so we can use offsets */
  const void* restrict src_base; /* in later code to avoid passing in original pointers */
  unsigned short num_bytes;   /* bytes in a single block */
  unsigned short num_blocks;  /* number of blocks in an array */
  unsigned short block_stride;  /* number of bytes between blocks in an array transfer */
} memxfr_struct;

static void memxfr_set_dest(memxfr_struct* spec, void* dest)
{
  spec->dest = dest;
}

static void memxfr_set_src(memxfr_struct* spec, const void* src)
{
  spec->src = src;
}

static void* memxfr_get_dest(memxfr_struct* spec)
{
  return spec->dest;
}

static const void* memxfr_get_src(memxfr_struct* spec)
{
  return spec->src;
}

static void memxfr_set_num_bytes(memxfr_struct* spec, unsigned short num_bytes)
{
  spec->num_bytes = num_bytes;
}

static void memxfr_set_block_stride(memxfr_struct* spec, unsigned short block_stride)
{
  spec->block_stride = block_stride;
}

static void memxfr_set_num_blocks(memxfr_struct* spec, unsigned short num_blocks)
{
  spec->num_blocks = num_blocks;
}

static int memxfr_block_setup(memxfr_struct* spec, 
                                      const void* src, void* dest, unsigned short num_bytes)
{
  spec->src = spec->src_base = src;
  spec->dest = spec->dest_base = dest;
  spec->num_bytes = num_bytes;
  spec->num_blocks = 1;
  spec->block_stride = 0;

  return 0;
}

static int memxfr_array_setup(memxfr_struct* spec, 
                                      const void* src, void* dest,
                                      unsigned short num_bytes,
                                      unsigned short num_blocks,
                                      unsigned short block_stride)
{
  spec->src = spec->src_base = src;
  spec->dest = spec->dest_base = dest;
  spec->num_bytes = num_bytes;
  if (num_blocks < 1)
    num_blocks = 1;
  spec->num_blocks = num_blocks;
  spec->block_stride = block_stride;

  return 0;
}

static int memxfr_start(memxfr_struct* spec)
{
  return 0;
}

static int memxfr_wait(memxfr_struct* spec, int timeout)
{
  unsigned short i;
  unsigned char* restrict dest = spec->dest;
  const unsigned char* restrict src = spec->src;

  for (i=0;i<spec->num_blocks;i++) {
  /* CRITICAL SECTION */
#if 1
    memcpy(dest, src, spec->num_bytes);
#endif
    src += spec->block_stride;
    dest += spec->num_bytes;
  }

  return 0;
}

static int memxfr_release(memxfr_struct* spec)
{
  return 0;
}

#define RAW_IMAGE_WIDTH 1280
#define RAW_IMAGE_HEIGHT 960
#define OUTPUT_HEIGHT 720
#define BUFFER_OUTPUT_HEIGHT 960

/* CRITICAL: switch if you want to change efficiency */
static inline void downsample_line(const unsigned short* src, unsigned char* dest)
//void downsample_line(const unsigned short* src, unsigned char* dest)
{
  short i;

  for (i=0;i<RAW_IMAGE_WIDTH;i++) {
    /* swap bytes and shift by 4 simultaneously */
    dest[i] = ((src[i] & 0xFF) << 4) | ((src[i] >> 12));
  }
}

int ds_bayer_to_yuv420sp_fast(const unsigned short * restrict pusBayer_Raw_Img, unsigned char *restrict pucyuv420sp_ImgBuffer, short row_start)
{
  memxfr_struct imgxfr;
  memxfr_struct Yxfr, UVxfr;
  unsigned short raw_img_data[RAW_IMAGE_WIDTH];
  unsigned char img_data[RAW_IMAGE_WIDTH*2];
  unsigned char Y[RAW_IMAGE_WIDTH], UV[RAW_IMAGE_WIDTH];
  short r, c;
  short red, green, blue;
  unsigned char* restrict cur;
  unsigned char* restrict next;
  unsigned char* tmp;

  /* make sure row start is in bounds */
  if (row_start < 1 || row_start >= RAW_IMAGE_HEIGHT-OUTPUT_HEIGHT-1)
    return 0;

  if (memxfr_block_setup(&imgxfr, 0L, raw_img_data,
                         RAW_IMAGE_WIDTH*sizeof(unsigned short))) {
    return -1;
  }
  if (memxfr_block_setup(&Yxfr, Y, 0L, sizeof(Y))) {
    return -1;
  }
  if (memxfr_block_setup(&UVxfr, UV, 0L, sizeof(UV))) {
    return -1;
  }

  memxfr_set_src(&imgxfr, pusBayer_Raw_Img + (row_start+1)*RAW_IMAGE_WIDTH);
  memxfr_start(&imgxfr);

  cur = &img_data[0];
  next = &img_data[RAW_IMAGE_WIDTH];

  downsample_line(pusBayer_Raw_Img + (row_start)*RAW_IMAGE_WIDTH, cur);

  for (r=row_start;r<row_start+OUTPUT_HEIGHT;r++) {
    /* if necessary, wait for the transfer of the Bayer patter from DDR */
    if (memxfr_wait(&imgxfr, 10)) {
      return -1;
    }

    /* make a down sampled copy of the next row */
    downsample_line(raw_img_data, next);

    /* start transferring the next image data while processing data */
    if (r != row_start+OUTPUT_HEIGHT-1) {
      memxfr_set_src(&imgxfr, pusBayer_Raw_Img+ (r+2)*RAW_IMAGE_WIDTH);
      memxfr_start(&imgxfr);
    }

    /* make sure we have finished writing from previous time */
    if (r != row_start) {
      if (memxfr_wait(&Yxfr, 1)) {
        return -1;
      }
    }

    /* calculate the bilinearly interpolated Y value */
    /* on even rows we also do U and V */
    if (!(r & 1)) {
      /* make sure we are finished transferring the UV outputs */
      if (r != row_start) {
        if (memxfr_wait(&UVxfr, 1)) {
          return -1;
        }
      }

      for (c=0;c<RAW_IMAGE_WIDTH-2;c+=2) {
        red = cur[c+1];
        green = (cur[c] + next[c+1])/2;
        blue = next[c];
      
        Y[c] = (red+green+blue)/3;
        UV[c] = red;
        UV[c+1] = blue;

        Y[c+1] = (red+green+blue)/3;
      }
      /* have to handle the last cell separately so we don't read beyond the
         end of the line */
      c = RAW_IMAGE_WIDTH-2;
      red = cur[c+1];
      green = (cur[c] + next[c+1])/2;
      blue = next[c];
      
      Y[c+1] = Y[c] = (red+green+blue)/3;
      UV[c] = red;
      UV[c+1] = green;

      /* start the transfer of the UV values to DDR */
      memxfr_set_dest(&UVxfr,
              pucyuv420sp_ImgBuffer + RAW_IMAGE_WIDTH*BUFFER_OUTPUT_HEIGHT +
              (r-row_start)*RAW_IMAGE_WIDTH/2);
      memxfr_start(&UVxfr);
    } else {
      /* odd rows, no U and V */
      for (c=0;c<RAW_IMAGE_WIDTH-2;c+=2) {
        Y[c] = (next[c+1]+(cur[c+1] + next[c])/2+cur[c])/3;
        Y[c+1] = (next[c+1]+(cur[c+1] + next[c+2])/2+cur[c+2])/3;
      }
      /* have to handle the last cell separately so we don't read beyond the
         end of the line */
      c = RAW_IMAGE_WIDTH-2;
      Y[c+1] = Y[c] = (next[c+1]+(cur[c+1] + next[c])/2+cur[c])/3;
    }

    /* start the transfer of the Y values to DDR */
    memxfr_set_dest(&Yxfr, pucyuv420sp_ImgBuffer + (r-row_start)*RAW_IMAGE_WIDTH);
    memxfr_start(&Yxfr);

    /* swap image data buffers */
    tmp = cur;
    cur = next;
    next = tmp;
  }

  /* make sure all output transfers are done */
  memxfr_wait(&Yxfr, 1);
  memxfr_wait(&UVxfr, 1);

  /* and clean up memory transfers */
  memxfr_release(&imgxfr);
  memxfr_release(&Yxfr);
  memxfr_release(&UVxfr);

  return 1;
}