common.i

H.264完整的C语言代码和DCT的代码

 _PNH __cdecl _set_new_handler( _PNH );











#line 110 "D:/Progra~1/Micros~2/VC98/Include\\new.h"

#line 112 "D:/Progra~1/Micros~2/VC98/Include\\new.h"

#line 114 "D:/Progra~1/Micros~2/VC98/Include\\new.h"
#line 7 "D:/working/tools/isim\\vector.cpp"



template<class T>
VPtr<T>::VPtr(const VPtr& p) 
{
  idx = p.idx;
  v   = p.v;
}

template<class T>
VPtr<T>& VPtr<T>::operator=(const VPtr& p)
{
  idx = p.idx;
  v   = p.v;
  return *this;
}  

template<class T>
VPtr<T>& VPtr<T>::operator++()
{
  if (v)
  {
    ((void)0);
    idx++;
    if (idx >= (int)v->used)
    {
      idx = -1;
      v   = 0;
    }
  }
  return *this;
}

template<class T>
VPtr<T>& VPtr<T>::operator--()
{
  if (v)
  {
    ((void)0);
    idx--;
    if (idx < 0)
    {
      idx = -1;
      v   = 0;
    }
  }
  return *this;
}

template<class T>
T& VPtr<T>::operator*()
{
  if (v)
  {
    ((void)0);
    return v->data[idx];
  }
  ((void)0);
  return v->data[0]; 
}

template<class T>
T *VPtr<T>::operator->()
{
  if (v)
  {
    ((void)0);
    return &(v->data[idx]);
  }
  ((void)0);
  return &(v->data[0]); 
}

template<class T>
bool VPtr<T>::valid()
{
  if (v)
  {
    ((void)0);
    if ((idx < 0) || (idx >= (int)v->used))
    {
      idx = -1;
      v   = 0;
      return false;
    }
    return true;
  }

  return false;
}

template<class T>
bool VPtr<T>::operator==(const VPtr& p)
{
  if (valid() && p.valid())
  {
    if (idx == p.idx)
      return true;
    else
      return false;
  }

  return false;
}

template<class T>
bool VPtr<T>::operator!=(const VPtr& p)
{
  return !(*this == p);
}

template<class T>
bool VPtr<T>::operator<(const VPtr& p)
{
  valid();
  p.valid();
  ((void)0);
  return idx < p.idx;
}

template<class T>
bool VPtr<T>::operator>(const VPtr& p)
{
  valid();
  p.valid();
  ((void)0);
  return idx > p.idx;
}


template<class T>
T *vector<T>::allocate(unsigned int n)
{
  T *ptr = 0;
  if (n > 0)
  {
    
    ptr = ((T *) operator new(n * sizeof(T)));
  }

  return ptr;
}

template<class T>
void vector<T>::destroy()
{
  
  clear();
}

template<class T>
void vector<T>::copy(const vector& v)
{
  sz   = v.used;
  used = v.used;
  data = 0;

  data = allocate(sz);
  delop = &operator delete;

  T *ptr = data;
  for(unsigned int i=0; i<used; i++, ptr++)
    ptr = new ((void *) ptr) T(v.data[i]);
}

template<class T>
vector<T>::vector()
{
  sz   = 0;
  used = 0;
  data = 0;
}

template<class T>
vector<T>::vector(const unsigned int n, const T& el)
{
  sz   = n;
  used = n;
  data = 0;

  data = allocate(sz);
  delop = &operator delete;

  T *ptr = data;
  for (unsigned int i=0; i<n; i++, ptr++)
    ptr = new ((void *) ptr) T(el);
}

template<class T>
vector<T>::vector(const vector& v): data(0), sz(0), used(0)
{
  copy(v);
}

template<class T>
vector<T>::vector(const portable_vector& pv)
{
  ((void)0);

  sz   = pv.len;
  used = pv.len;
  data = 0;

  data = allocate(sz);
  delop = &operator delete;

  T *ptr = data;
  T *el  = (T *) pv.data;
  for (unsigned int i=0; i<sz; i++, ptr++, el++)
    ptr = new ((void *) ptr) T(*el);
}

template<class T>
vector<T>::~vector()
{
  destroy();
  sz   = 0;
  used = 0;
}

template<class T>
void vector<T>::clear_portable_vector(portable_vector& pv)
{
  if (pv.data)
  {
    ((void)0);

    T *ptr = (T *)pv.data;
    
    for (unsigned int i=0; i<pv.len; i++, ptr++)
      ptr->~T();

    pv.delop(pv.data);
    pv.delop = 0;
  }
  pv.data   = 0;
  pv.datasz = 0;
  pv.len    = 0;
}

template<class T>
vector<T>& vector<T>::operator=(const vector& v)
{
  destroy();
  sz   = 0;
  used = 0;
  copy(v);

  return *this;
}

template<class T>
void vector<T>::clear()
{
  
  T *ptr = data;
  for (unsigned int i=0; i<used; i++, ptr++)
    ptr->~T();

  used = 0;

  
  if (data) {
    delop(data);
    delop = &operator delete;
  }
  data = 0;
  sz   = 0;
}

template<class T>
T& vector<T>::back()
{
  ((void)0);
  return data[used-1];
}

template<class T>
T& vector<T>::front()
{
  ((void)0);
  return data[0];
}











template<class T>
void vector<T>::push_back(const T& el)
{
  T *ptr;
  if (used == sz)
  {
    sz = sz ? (sz*2) : 4;
    T *newdata = allocate(sz);
    ptr = newdata;
    for (unsigned int i=0; i<used; i++, ptr++)
      ptr = new ((void *) ptr) T(data[i]);

    int newsize = sz;
    int newused = used;
    destroy();

    delop = &operator delete;

    sz   = newsize;
    used = newused;
    data = newdata;
  }
  ptr = &data[used++];
  ptr = new ((void *) ptr) T(el);
}

template<class T>
void vector<T>::push_back(const vector<T>& v)
{
  for (int i = 0; i < v.size(); i++) {
    push_back(v[i]);
  }
}

template<class T>
T vector<T>::pop_back()
{
  ((void)0);
  T *ptr = &data[--used];
  T val = *ptr;
  ptr->~T();

  if ((used < (sz/4)) && (sz > 4))
  {
    sz /= 2;
    T *newdata = allocate(sz);
    ptr = newdata;
    for (unsigned int i=0; i<used; i++, ptr++)
      ptr = new ((void *) ptr) T(data[i]);

    int newsize = sz;
    int newused = used;
    destroy();

    delop = &operator delete;

    sz   = newsize;
    used = newused;
    data = newdata;
  }
  return val;
}

template<class T>
T& vector<T>::operator[](const unsigned int i)
{
  ((void)0);
  return data[i];
}

template<class T>
const T& vector<T>::operator[](const unsigned int i) const
{
  ((void)0);
  return data[i];
}

template<class T>
VPtr<T> vector<T>::begin()
{
  VPtr<T> p;

  if (used)
  {
    p.idx = 0;
    p.v   = this;
  }

  return p;
}

template<class T>
VPtr<T> vector<T>::end()
{
  VPtr<T> p;

  if (used)
  {
    p.idx = used-1;
    p.v   = this;
  }

  return p;
}

template<class T>
VPtr<T> vector<T>::getPtr(const unsigned int i)
{
  VPtr<T> p;

  if (i < used)
  {
    p.idx = i;
    p.v   = this;
  }

  return p;
}

template<class T>
vector<T>::operator portable_vector() const
{
  portable_vector pv;

  pv.datasz = sizeof(T);
  pv.len    = used;
  pv.data   = operator new(used * sizeof(T));
  pv.delop  = &operator delete;

  T *ptr = data;
  T *el  = (T *) pv.data;
  for (unsigned int i=0; i<sz; i++, ptr++, el++)
    el = new ((void *) el) T(*ptr);

  return pv;
}

template<class T>
char* vector<T>::writeBin(const unsigned int bin_size)
{
  destroy();
  unsigned int T_size = bin_size / sizeof(T) + (bin_size % sizeof(T) == 0 ? 0 : 1);
  sz = T_size + 4;
  used = T_size;
  data = allocate(sz);
  delop = &operator delete;
  
  return((char*)data);
}

template<class T>
char* vector<T>::readBin(unsigned int& bin_size)
{
  bin_size = used * sizeof(T);

  return((char*)data);
}
#line 145 "D:/working/tools/isim\\vector.hpp"

#line 147 "D:/working/tools/isim\\vector.hpp"
#line 23 "D:/working/tools/common.hpp"


enum CacheType {
  Cache_None, Cache_Writeback, Cache_Writethrough
};


enum sc_dep_method { sc_dm_none,

                     
                     explicit_scoreboard,

                     
                     hw_bruteforce,

                     
                     
                     hw_bruteforce_early_start,

                     sc_dm_invalid };



enum sc_issue_method { sc_im_none, no_concurrency, sc_sequential, out_of_order,
                       sc_im_invalid };


enum sc_netsb_alloc_type { netsb_alloc_none, netsb_alloc_static,
                           netsb_alloc_dynamic, netsb_alloc_invalid };



enum rts_esb_type { rts_esb_none,
                    rts_esb_dynamic_entry_alloc_first_free,
                    rts_esb_dynamic_entry_alloc_round_robin,
                    rts_esb_static_entry_alloc,
                    rts_esb_invalid };


enum kerneltype { kerneltype_invalid, kerneltype_uc, kerneltype_lis,
                  kerneltype_raw };



class Mach_Des;
typedef Mach_Des                  MachineDescription;




String __declspec(dllexport) strip_last_name(const String& nm, int num = 1);
String __declspec(dllexport) get_last_name(const String& nm, int num = 1);
unsigned __declspec(dllexport) extract_bits(int i, int j, unsigned k);

String __declspec(dllexport) get_next_word(char **s);   
int __declspec(dllexport) get_next_num(char **s);
int __declspec(dllexport) get_next_int(char **s);
unsigned int __declspec(dllexport) get_next_uint(char **s);
float __declspec(dllexport) get_next_float(char **s);
bool __declspec(dllexport) is_end_of_args(char **s);

__declspec(dllexport) int rtny(int x, int y);
__declspec(dllexport) int num_blocks(int records, int rec_len = 1);
__declspec(dllexport) void next(int *addr, int records, int rec_len = 1);
__declspec(dllexport) int nextpowerof2( int n );

kerneltype __declspec(dllexport) getKernelType(String fname);



__declspec(dllexport) void wide_write(vector<unsigned int>& d, int low, int len,
                         unsigned int data);
__declspec(dllexport) unsigned int wide_read(vector<unsigned int>& d, int low, int len);


#line 99 "D:/working/tools/common.hpp"
#line 16 "D:/working/tools/common.cpp"
#line 1 "D:/working/tools/isim\\error.hpp"



























































#line 17 "D:/working/tools/common.cpp"





String strip_last_name(const String& nm, int num)
{
  int i;
  int cnt = 0;
  for (i = nm.length()-1; i >= 1; i--) {
    if (nm[i] == '/') {
      if (++cnt == num) {
        return (nm.substring(0, i-1));
      }
    }
  }
  return (nm);
}


String get_last_name(const String& nm, int num)
{
  int i;
  int cnt = 0;
  for (i = nm.length()-1; i >= 1; i--) {
    if (nm[i] == '/') {
      if (++cnt == num) {
        return (nm.substring(i+1, nm.length()-1));
      }
    }
  }
  return (nm);
}


unsigned extract_bits(int i, int j, unsigned k)
{
  return(((1<<j)-1) & (k>>((unsigned int)i)));
}



String get_next_word(char **s)
{
  String word;
  while (isspace(**s) && (**s != 0)) ++(*s);
  while (!isspace(**s) && (**s != 0)) {
    word = word + String(**s);
    ++(*s);
  }
  word.lowercase();
  return (word);
}

int get_next_num(char **s)
{
  int sign = 1;
  int num = -1;
  while (isspace(**s) && (**s != 0)) { (*s)++; }
  if (**s == '-') {
    (*s)++;
    sign = -1;
  }
  if (((*s)[0] == '0') && ((*s)[1] == 'x')) {
    (*s) += 2;
    sscanf(*s, "%x", &num);
  } else {
    istrstream istr(*s);
    istr >> dec >> num;
  }
  while (!isspace(**s) && (**s != 0)) { (*s)++; }
  num *= sign;
  return (num);
}

int get_next_int(char **s)
{
  istrstream n(*s);
  int num;
  n >> num;
  get_next_word(s);
  return(num);
}

unsigned int get_next_uint(char **s)
{
  istrstream n(*s);
  unsigned int num;
  n >> num;
  get_next_word(s);
  return(num);
}

float get_next_float(char **s)
{
  istrstream n(*s);
  float num;
  n >> num;
  get_next_word(s);
  return(num);
}

bool __declspec(dllexport) is_end_of_args(char **s)
{
  while (isspace(**s) && (**s != 0)) { (*s)++; }
  return(**s == 0);
}



















void wide_fn_checks(vector<unsigned int>& d, int low, int len)
{
  if (low < 0) { _error("D:/working/tools/common.cpp", 145, "error -- no negative parameters allowed"); }
  if (len <= 0) { _error("D:/working/tools/common.cpp", 146, "error -- no negative parameters allowed"); }
  if (len > 32) { _error("D:/working/tools/common.cpp", 147, "error -- len out of range"); }
  if ((low + len) >= (d.size() * 32)) { _error("D:/working/tools/common.cpp", 148, "params out of range"); }
}



void wide_write(vector<unsigned int>& d, int low, int len, unsigned int data)
{
  wide_fn_checks(d, low, len);
  data &= (0xffffffff >> (32-len));
  int n = low/32;
  d[n] = (d[n] & ~(0xffffffff << (low%32))) | data << (low % 32);
  if (n != (low+len-1)/32) {
    d[n+1] = (d[n+1] & (0xffffffff << ((len + low) % 32))) | (data >> (32 - (low % 32)));
  }
}

unsigned int wide_read(vector<unsigned int>& d, int low, int len)
{
  wide_fn_checks(d, low, len);
  int n = low/32;
  unsigned int data = ((d[n] & (0xffffffff << (low%32))) >> (low%32));
  if (n != (low+len-1)/32) {
    data |= (d[n+1] << (32 - (low%32)));
  }
  data &= (0xffffffff >> (32-len));
  return (data);
}



int rtny(int x, int y)


{
  int z = ((x / y) + (((x % y) == 0) ? 0 : 1)) * y;
  return (z);
}




__declspec(dllexport) int istreamSpecial(char* x);
#line 191 "D:/working/tools/common.cpp"

int num_blocks(int records, int rec_len)

{
  int length = records * rec_len;
  int block_size =



          istreamSpecial("SRF_BLOCK_SIZE");    
#line 202 "D:/working/tools/common.cpp"
  return( rtny(length, block_size) / block_size );
}


void next(int *addr, int records, int rec_len)

{
  *addr += num_blocks(records, rec_len);
}


int nextpowerof2( int n )

{
  int i = 0, j = 0;

  
  n >>= 1;
  while ( n ) { 
    j += (n & 0x1); 
    n >>= 1; 
    ++i;
  }

  return ( j > 1 ) ? 1 << ( i + 1 ) : 1 << i;
}