/*

 * H.265 video codec.

 * Copyright (c) 2013-2014 struktur AG, Dirk Farin <farin@struktur.de>

 *

 * This file is part of libde265.

 *

 * libde265 is free software: you can redistribute it and/or modify

 * it under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation, either version 3 of

 * the License, or (at your option) any later version.

 *

 * libde265 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 Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with libde265.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "scan.h"

static position scan0 = { 0,0 };

static position scan_h_1[ 2* 2], scan_v_1[ 2* 2], scan_d_1[ 2* 2];

static position scan_h_2[ 4* 4], scan_v_2[ 4* 4], scan_d_2[ 4* 4];

static position scan_h_3[ 8* 8], scan_v_3[ 8* 8], scan_d_3[ 8* 8];

static position scan_h_4[16*16], scan_v_4[16*16], scan_d_4[16*16];

static position scan_h_5[32*32], scan_v_5[32*32], scan_d_5[32*32];

static position* scan_h[7] = { &scan0,scan_h_1,scan_h_2,scan_h_3,scan_h_4,scan_h_5 };

static position* scan_v[7] = { &scan0,scan_v_1,scan_v_2,scan_v_3,scan_v_4,scan_v_5 };

static position* scan_d[7] = { &scan0,scan_d_1,scan_d_2,scan_d_3,scan_d_4,scan_d_5 };

static void init_scan_h(position* scan, int blkSize)

{

  int i=0;

  for (int y=0;y<blkSize;y++)

    for (int x=0;x<blkSize;x++)

      {

        scan[i].x = x;

        scan[i].y = y;

        i++;

      }

}

static void init_scan_v(position* scan, int blkSize)

{

  int i=0;

  for (int x=0;x<blkSize;x++)

    for (int y=0;y<blkSize;y++)

      {

        scan[i].x = x;

        scan[i].y = y;

        i++;

      }

}

static void init_scan_d(position* scan, int blkSize)

{

  int i=0;

  int x=0,y=0;

  do {

    while (y>=0) {

      if (x<blkSize && y<blkSize) {

        scan[i].x = x;

        scan[i].y = y;

        i++;

      }

      y--;

      x++;

    }

    y=x;

    x=0;

  } while (i < blkSize*blkSize);

}

const position* get_scan_order(int log2BlockSize, int scanIdx)

{

  switch (scanIdx) {

  case 0: return scan_d[log2BlockSize];

  case 1: return scan_h[log2BlockSize];

  case 2: return scan_v[log2BlockSize];

  default: return 0; // should never happen

  }

}

static scan_position scanpos_h_2[ 4* 4], scanpos_v_2[ 4* 4], scanpos_d_2[ 4* 4];

static scan_position scanpos_h_3[ 8* 8], scanpos_v_3[ 8* 8], scanpos_d_3[ 8* 8];

static scan_position scanpos_h_4[16*16], scanpos_v_4[16*16], scanpos_d_4[16*16];

static scan_position scanpos_h_5[32*32], scanpos_v_5[32*32], scanpos_d_5[32*32];

static scan_position* scanpos[3][6] =

  { { 0,0,scanpos_d_2,scanpos_d_3,scanpos_d_4,scanpos_d_5 },

    { 0,0,scanpos_h_2,scanpos_h_3,scanpos_h_4,scanpos_h_5 },

    { 0,0,scanpos_v_2,scanpos_v_3,scanpos_v_4,scanpos_v_5 } };

scan_position get_scan_position(int x,int y, int scanIdx, int log2BlkSize)

{

  return scanpos[scanIdx][log2BlkSize][ y*(1<<log2BlkSize) + x ];

}

static void fill_scan_pos_table(scan_position* pos, int scanIdx, int log2TrafoSize)

{

  int numSubBlocks = (1<<(log2TrafoSize-2)) * (1<<(log2TrafoSize-2));

  int blkSize = 1 << log2TrafoSize;

  const position* ScanOrderSub = get_scan_order(log2TrafoSize-2, scanIdx);

  const position* ScanOrderPos = get_scan_order(2, scanIdx);

  for (int sb = 0; sb < numSubBlocks; sb++)

    {

      position S = ScanOrderSub[sb];

      for (int sp = 0; sp < 16; sp++)

        {

          int xC = (S.x<<2) + ScanOrderPos[sp].x;

          int yC = (S.y<<2) + ScanOrderPos[sp].y;

          pos[yC * blkSize + xC].subBlock = sb;

          pos[yC * blkSize + xC].scanPos  = sp;

        }

    }

}

void init_scan_orders()

{

  for (int log2size=1;log2size<=5;log2size++)

    {

      init_scan_h(scan_h[log2size], 1<<log2size);

      init_scan_v(scan_v[log2size], 1<<log2size);

      init_scan_d(scan_d[log2size], 1<<log2size);

    }

  for (int log2size=2;log2size<=5;log2size++)

    for (int scanIdx=0;scanIdx<3;scanIdx++)

      fill_scan_pos_table(scanpos[scanIdx][log2size], scanIdx, log2size);

}