sc_route.i

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

#line 1 "D:/working/tools/isim\\vector.cpp"




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















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



















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































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













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












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



















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




















typedef void (__cdecl * new_handler) ();
 new_handler __cdecl set_new_handler(new_handler);
#line 72 "D:/Progra~1/Micros~2/VC98/Include\\new.h"



inline void *__cdecl operator new(size_t, void *_P)
        {return (_P); }

inline void __cdecl operator delete(void *, void *)
	{return; }
#line 81 "D:/Progra~1/Micros~2/VC98/Include\\new.h"
#line 82 "D:/Progra~1/Micros~2/VC98/Include\\new.h"






 int __cdecl _query_new_mode( void );
 int __cdecl _set_new_mode( int );


typedef int (__cdecl * _PNH)( size_t );

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

 _PNH __cdecl _query_new_handler( void );
 _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 39 "D:/working/tools/isim\\misc.hpp"







int __declspec(dllexport) divRoundUp(int a, int b);

int __declspec(dllexport) exactLog2(int a);
int __declspec(dllexport) ceilLog2(int a);

int __declspec(dllexport) bitReverse(int numBits, int a);

void __declspec(dllexport) test_error(bool condition, char* error_msg, ...);
void __declspec(dllexport) test_warning(bool condition, char* error_msg, ...);

void __declspec(dllexport) swap(int& a, int& b);

int __declspec(dllexport) roundUpToNearest(int a, int b);

String __declspec(dllexport) cutTo(String& main, const String& sub);

void __declspec(dllexport) printIndent(ostream& out, int indent);

void __declspec(dllexport) expandFSpec(String fspec, vector<String>& fnames); 












template<class T>
void deleteVectObjPtr(vector<T*>& vect) 


{ 
  int vectSize = vect.size(); 
  if (true) for (int i = 0; i < vectSize; ++i) {
    T* obj = vect[i];
    delete obj; 
	vect[i] = 0; 
  }
  vect.clear();  
}



template <class T>
void streamIOBasic(T& t, istream* i, ostream* o, unsigned int indent)

{
  if (i) {
    *i >> t;
  } else {
    *o << t << " ";
  }
}

#pragma warning (disable: 4800)


template <class T>
void streamIOEnum(T& t, istream* i, ostream* o, unsigned int indent)

{
  if (i) {
    unsigned int dummy;
    *i >> dummy;
    t = (T)dummy;
  } else {
    unsigned int dummy = (unsigned int)t;
    *o << dummy << " ";
  }
}

#line 122 "D:/working/tools/isim\\misc.hpp"

#line 7 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
__declspec(dllexport) int istreamSpecial(char* x);
__declspec(dllexport) void istreamPrint(int x);
__declspec(dllexport) void istreamRouteArg(StreamRoute* r);






int newRouteUID = 0;


StreamRoute::StreamRoute(int _source, int _dest, const char* _route):


  valid(true), source(_source), dest(_dest)



{
  
  UID = newRouteUID++;
  

  unsigned int max_hops = istreamSpecial("MAX_HOPS");
  route = new int[max_hops];
#line 34 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
  int i = 0;
  while (_route[i] != 0) {
    int val = _route[i] - '0';
    test_error(val >= 0 && (val <= 3 || val == 4 && i == 0),
               "Invalid character in route!\n"
               "First hop: 0 = north, 1 = south, 2 = west, 3 = east, 4 = loopback\n" 
               "Subsequent hops: 0 = eject, 1 = right, 2 = left, 3 = straight\n");

    route[i] = val;


#line 46 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
    i++;
  }

  istreamRouteArg(this);
#line 51 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
}


void StreamRoute::initCopy(const StreamRoute& r2)


{
  valid = r2.valid;
  if (valid) {
    UID = r2.UID;
    valid = r2.valid;
    source = r2.source;
    dest = r2.dest;
    tag = r2.tag;

    unsigned int max_hops = istreamSpecial("MAX_HOPS");
    route = new int[max_hops];
    if (true) for (int i = 0; i < max_hops; i++) {
      route[i] = route[i];
    }
#line 72 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
  }
}



StreamRoute::StreamRoute(const StreamRoute& r2)


{
  initCopy(r2);
}



StreamRoute& StreamRoute::operator=(const StreamRoute& r2) {



  if (valid) {
    delete[] route;
  }
#line 94 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
  initCopy(r2);
  return(*this);
}


StreamRoute::~StreamRoute()

{

  if (valid) {
    delete[] route;
  }
#line 107 "D:/working/tools/isim/isimhostdll2/sc_route.cpp"
}