endecode.cpp

设计并实现了两种分层多描述视频编码器.通过对小波域的运动估计算法进行了分析和研究

//只分割最小位平面分送2个描述				再去掉final_bit
//Bit Rate     0.25		0.50	1.00		0.25	0.50	1.00
//center PSNR 32.50		35.51	38.58		32.34	35.32	38.38
//PSNR 1      30.67		33.68	36.66		30.74	33.73	36.81
//PSNR 2      30.53		33.60	36.82		30.68	33.76	36.84
//factor      0.504		0.967	1.9			0.53	1.024	2.006
// - - Inclusion - - - - - - - - - - - - - - - - - - - - - - - - - - - -

//#define ENCODER 1

#include "general.h"
#include "image_bw.h"

#include "aritcode.h"

#define fix(a) ((int)((a)>=0)?((int)a):-((int)-(a)))
int pass;


static const int NumbTap = 4;

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

inline double Filter_L(const double * f, double * v)
{
  return f[0] * v[0] +
    f[1] * (v[1] + v[-1]) + f[2] * (v[2] + v[-2]) +
    f[3] * (v[3] + v[-3]) + f[4] * (v[4] + v[-4]);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

inline double Filter_H(const double * f, double * v)
{
  return f[0] * v[0] +
    f[1] * (v[1] + v[-1]) + f[2] * (v[2] + v[-2]) +
    f[3] * (v[3] + v[-3]);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void Reflection(double * h, double * t)
{  
  for (int i = 1; i <= NumbTap; i++) {
    h[-i] = h[i];  t[i] = t[-i]; }
}

//------------------------------------------------------------------------



static const double T_LowPass[5] =
  { 8.526986790094022e-01,  3.774028556126537e-01, -1.106244044184226e-01, -2.384946501937986e-02, 3.782845550699535e-02 };

static const double T_HighPass[5] =
  { 7.884856164056651e-01, -4.180922732222124e-01, -4.068941760955867e-02,  6.453888262893856e-02, 0.0 };

static const double R_LowPass[5] =
  { 8.526986790094022e-01,  4.180922732222124e-01, -1.106244044184226e-01, -6.453888262893856e-02, 3.782845550699535e-02 };

static const double R_HighPass[5] =
  { 7.884856164056651e-01, -3.774028556126537e-01, -4.068941760955867e-02,  2.384946501937986e-02, 0.0 };



// - - Definitions - - - - - - - - - - - - - - - - - - - - - - - - - - -

struct Tree_Node
{
  Image_Coord coord;
  long state;
  Tree_Node * next;
};


// - - Static variables  - - - - - - - - - - - - - - - - - - - - - - - -


const int SHF_x[4] = { 0, 0, 1, 1 }, SHF_y[4] = { 0, 1, 0, 1 };

char names[3][80], * pic_f_name = names[0], * cod_f_name = names[1],
      * new_f_name = names[3];

Chronometer code_time, total_time;

int pel_bytes, threshold_bits, min_bits, mdc, out_mark;

int last_mark;

long mean, byte_budget, root_code, remean;

Pel_Type act_value,threshold;

double bit_rate, rate_mult, factor1;


Tree_Node * LISP_head, * LISP_end; //* LISP_head1, * LISP_end1, * LISP_head2, * LISP_end2, 

Image_Coord dimension, root_dim;

Image_BW image;


  Encoder data_file;

  Decoder dedata_file;

  Image_BW max_image;


  Adaptive_Model group_model[5], node_model[34], desc_model[34];



  Image_Coord LSP_dim;

  int LSP_plane, LSP_part, LSP_idx;

  double bias[32],* LSP_mark[32], *** LSP_mtx, ** LSP_ptr;
  double *** LSP_mtx1, ** LSP_ptr1;

  double w1[2][2][144][176], w2[4][4][144/2][176/2], w3[8][8][144/4][176/4], w[2][3][144][176];
  double avpsnr0=0,avpsnr1=0,avpsnr2=0,avbit;
  int mv[9][11][2], remv[9][11][2];

  FILE * output0,* output1,* output2;

// - - Function prototypes - - - - - - - - - - - - - - - - - - - - - - -

boolean Sorting_Pass(void);

boolean DeSorting_Pass(void);

boolean Refinement_Pass(void);

boolean DeRefinement_Pass(void);

void Node_Test(Tree_Node *);

void DeNode_Test(Tree_Node *);

void Desc_Test(Tree_Node *);

void DeDesc_Test(Tree_Node *);

void last_layer(void);

void final_bit(void);

void Definal_bit(void);

  int Node_Transition(int, const Image_Coord &, int *);

  int DeNode_Transition(int, const Image_Coord &, int *);

  int Desc_Transition(int, const Image_Coord &);

  int DeDesc_Transition(int, const Image_Coord &);

void list_separating(void);

void Delist_separating(void);

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//  Function Implementations

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

inline double Magn_Val(double & p, int & s) { return fabs(p); }

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

boolean Sorting_Pass(void)
{
  Tree_Node * prev = LISP_head, * node = prev;

  for (; node = node->next; prev = node)
    if ((node->state & 0x55L) != 0x55L) {//LIP处理
      Node_Test(node);//若node中有IP项，输出Sn。若有系数>门限，输出该系数的符号，并移出LIP表放入LSP
      if (data_file.bytes_used() >= byte_budget) return true; }
  for (node = prev = LISP_head; node = node->next; prev = node) {//LIP处理
    if ((node->state & 0xAAL) != 0xAAL) {//LIS处理
      Desc_Test(node);//零树测试，输出树结构
      if (data_file.bytes_used() >= byte_budget) return true; }
    if ((node->state & 0xFFL) == 0xFFL) {//删去已处理好(LSP,不在LIS)的节点
      if (LISP_end == node) LISP_end = prev;
      prev->next = node->next;  delete node;  node = prev; }
  }
  return false;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
boolean DeSorting_Pass(void)
{
  act_value = threshold + (bias[LSP_plane] = 0.38 * threshold);//设定死区，实际门限＝1.38倍门限
  Tree_Node * prev = LISP_head, * node = prev;

  for (; node = node->next; prev = node)
    if ((node->state & 0x55L) != 0x55L) {//LIP处理
      DeNode_Test(node);//若node中有IP项，输出Sn。若有系数>门限，输出该系数的符号，并移出LIP表放入LSP
      if (dedata_file.bytes_used() >= byte_budget) return true; }
  for (node = prev = LISP_head; node = node->next; prev = node) {//LIP处理
    if ((node->state & 0xAAL) != 0xAAL) {//LIS处理
      DeDesc_Test(node);//零树测试，输出树结构
      if (dedata_file.bytes_used() >= byte_budget) return true; }
    if ((node->state & 0xFFL) == 0xFFL) {//删去已处理好(LSP,不在LIS)的节点
      if (LISP_end == node) LISP_end = prev;
      prev->next = node->next;  delete node;  node = prev; }
  }
  return false;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void last_layer(void)
{
  Tree_Node * prev = LISP_head, * node=prev;
//分割队列，两取一
  if (mdc-1) {
	  LISP_head = LISP_head->next; 
	  delete prev; }
  for (prev = LISP_head; node = prev->next; ) {
	  prev->next = node->next;
	  if (LISP_end == node) LISP_end = prev; 
	  else prev = prev->next;
	   delete node;}

  for (node = prev = LISP_head; node = node->next; prev = node) 
    if ((node->state & 0x55L) != 0x55L)	Node_Test(node);

  for (node = prev = LISP_head; node = node->next; prev = node) {
	  if ((node->state & 0xAAL) != 0xAAL) Desc_Test(node);
	  if ((node->state & 0xFFL) == 0xFFL) {
		if (LISP_end == node) LISP_end = prev;
		prev->next = node->next;  delete node;  node = prev; }}
}

void list_separating(void)
{
  Tree_Node * prev = LISP_head, * node=prev;
//分割队列，两取一
  if (mdc-1) {
	  LISP_head = LISP_head->next; 
	  delete prev; }
  for (prev = LISP_head; node = prev->next; ) {
	  prev->next = node->next;
	  if (LISP_end == node) LISP_end = prev; 
	  else prev = prev->next;
	   delete node;}
}

void Delist_separating(void)
{
  Tree_Node * prev = LISP_head, * node=prev;
//分割队列，两取一
  if (mdc-1) {
	  LISP_head = LISP_head->next; 
	  delete prev; }
  for (prev = LISP_head; node = prev->next; ) {
	  prev->next = node->next;
	  if (LISP_end == node) LISP_end = prev; 
	  else prev = prev->next;
	   delete node;}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

void Process_Image(void)
{
  threshold = pow(2, threshold_bits);  //min_bits = -32;
  LSP_idx = LSP_part = LSP_plane = 0;  LSP_ptr = 0;
  LSP_dim.x = dimension.x >> 2;  LSP_dim.y = dimension.y << 2;
  NEW_VECTOR(LSP_mtx, LSP_dim.x, double **, "LSP");

  int i, j, k, n = -1, t;
  for (i = 0; i <= 4; i++) {
    group_model[i].set_symbols(2);
    for (j = 0; j <= 4 - i; j++)
      for (k = 0;  k <= 4 - i - j; k++, n++)
        if (n >= 0) {
          if (t = i + k) node_model[n].set_symbols(1 << t);
          if (t = i + j) desc_model[n].set_symbols(1 << t); } }

  Image_Coord cd;
  Tree_Node * prev, * node;
  NEW_OBJECT(node, Tree_Node, "LISP entry");
  LISP_head = LISP_end = node;

  int m = image.pyramid_levels();
  root_dim.x = dimension.x >> m;  root_dim.y = dimension.y >> m;
  long st = 0x2L + (root_code = long(m + 1) << 9);
  for (cd.x = 0; cd.x < root_dim.x; cd.x += 2)
    for (cd.y = 0; cd.y < root_dim.y; cd.y += 2) {
      NEW_OBJECT(node, Tree_Node, "LISP entry");
      node->coord = cd;  node->state = st;
      LISP_end->next = node;  LISP_end = node; }
  LISP_end->next = NULL;
  out_mark=1;
  for (pass=0;--threshold_bits > min_bits; pass++,threshold /= 2) {
	Sorting_Pass();
    if (Refinement_Pass()) break; 
  }
//  last_layer();
  list_separating();//队列分割
  Sorting_Pass();
  final_bit();
  for (m = LSP_part; m > 0;) delete [] LSP_mtx[--m];
  delete [] LSP_mtx;
  code_time.stop();

  for (node = LISP_head; node;) {
    prev = node;  node = node->next;  delete prev; }
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

void DeProcess_Image(void)
{
  threshold = pow(2, threshold_bits);  //min_bits = -32;
  LSP_idx = LSP_part = LSP_plane = 0;  LSP_ptr = 0;
  LSP_dim.x = dimension.x >> 2;  LSP_dim.y = dimension.y << 2;
  NEW_VECTOR(LSP_mtx, LSP_dim.x, double **, "LSP");
  NEW_VECTOR(LSP_mtx1, LSP_dim.x, double **, "LSP");

  int i, j, k, n = -1, t;
  for (i = 0; i <= 4; i++) {
    group_model[i].set_symbols(2);
    for (j = 0; j <= 4 - i; j++)
      for (k = 0;  k <= 4 - i - j; k++, n++)
        if (n >= 0) {
          if (t = i + k) node_model[n].set_symbols(1 << t);
          if (t = i + j) desc_model[n].set_symbols(1 << t); } }

  Image_Coord cd;
  Tree_Node * prev, * node;
  NEW_OBJECT(node, Tree_Node, "LISP entry");
  LISP_head = LISP_end = node;

  int m = image.pyramid_levels();
  long nn; 
  root_dim.x = dimension.x >> m;  root_dim.y = dimension.y >> m;
  long st = 0x2L + (root_code = long(m + 1) << 9);
  for (cd.x = 0; cd.x < root_dim.x; cd.x += 2)
    for (cd.y = 0; cd.y < root_dim.y; cd.y += 2) {
      NEW_OBJECT(node, Tree_Node, "LISP entry");
      node->coord = cd;  node->state = st;
      LISP_end->next = node;  LISP_end = node; }
  LISP_end->next = NULL;
  last_mark=0; out_mark=1;
  for (pass=0;--threshold_bits > min_bits; pass++,threshold /= 2) {
	act_value = threshold + (bias[LSP_plane] = 0.38 * threshold);
	DeSorting_Pass();
	DeRefinement_Pass();
  }
  last_mark=1;
  act_value = threshold + (bias[LSP_plane] = 0.38 * threshold);
//  last_layer();
  Delist_separating();//队列分割
  DeSorting_Pass();
  Definal_bit();
  
  for (m = LSP_part; m > 0;) { 
	  delete [] LSP_mtx[--m];
	  delete [] LSP_mtx1[m];}
  delete [] LSP_mtx; delete [] LSP_mtx1;  

  for (node = LISP_head; node;) {
    prev = node;  node = node->next;  delete prev; }
}


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// - - Arithmetic coding functions - - - - - - - - - - - - - - - - - - -

void Output_Signs(int nb, int sd, const Image_Coord & pc)
{//输出主系数的符号，并把该SP放入LSP
  Image_Coord nc;
  int m = 1/*负号*/, b = 0;

  for (int i = 0; i < 4; i++, sd >>= 2)
    if (sd & 1) {
    nc.x = pc.x + SHF_x[i];  nc.y = pc.y + SHF_y[i];
      if (!LSP_idx) {//若LSP队列满，申请一块内存链入
        NEW_VECTOR(LSP_ptr, LSP_dim.y, double *, "LSP");
        LSP_mtx[LSP_part++] = LSP_ptr;  LSP_idx = LSP_dim.y; }
      double * ptr = LSP_ptr[--LSP_idx] = image.address(nc);
      if (*ptr < 0) b |= m; //设定符号位
      *ptr = fabs(*ptr) - threshold;
      m <<= 1; }

  data_file.code_bits(nb, b);
}

// - - Arithmetic coding functions - - - - - - - - - - - - - - - - - - -

void DeOutput_Signs(int nb, int sd, const Image_Coord & pc)
{//输出主系数的符号，并把该SP放入LSP
  Image_Coord nc;
  double *ptr, *ptr1;
  int m = 1, b = dedata_file.decode_bits(nb);

  for (int i = 0; i < 4; i++, sd >>= 2)
    if (sd & 1) {
	  nc.x = pc.x + SHF_x[i];  nc.y = pc.y + SHF_y[i];
      if (!LSP_idx) {//若LSP队列满，申请一块内存链入
        NEW_VECTOR(LSP_ptr, LSP_dim.y, double *, "LSP");
        LSP_mtx[LSP_part] = LSP_ptr;  LSP_idx = LSP_dim.y; 
        NEW_VECTOR(LSP_ptr1, LSP_dim.y, double *, "LSP");
        LSP_mtx1[LSP_part++] = LSP_ptr1;  }
      ptr = LSP_ptr[--LSP_idx] = image.address(nc);