sc_route.i

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

 wchar_t * __cdecl wcscpy(wchar_t *, const wchar_t *);
 size_t __cdecl wcscspn(const wchar_t *, const wchar_t *);
 size_t __cdecl wcslen(const wchar_t *);
 wchar_t * __cdecl wcsncat(wchar_t *, const wchar_t *, size_t);
 int __cdecl wcsncmp(const wchar_t *, const wchar_t *, size_t);
 wchar_t * __cdecl wcsncpy(wchar_t *, const wchar_t *, size_t);
 wchar_t * __cdecl wcspbrk(const wchar_t *, const wchar_t *);
 wchar_t * __cdecl wcsrchr(const wchar_t *, wchar_t);
 size_t __cdecl wcsspn(const wchar_t *, const wchar_t *);
 wchar_t * __cdecl wcsstr(const wchar_t *, const wchar_t *);
 wchar_t * __cdecl wcstok(wchar_t *, const wchar_t *);

 wchar_t * __cdecl _wcsdup(const wchar_t *);
 int __cdecl _wcsicmp(const wchar_t *, const wchar_t *);
 int __cdecl _wcsnicmp(const wchar_t *, const wchar_t *, size_t);
 wchar_t * __cdecl _wcsnset(wchar_t *, wchar_t, size_t);
 wchar_t * __cdecl _wcsrev(wchar_t *);
 wchar_t * __cdecl _wcsset(wchar_t *, wchar_t);

 wchar_t * __cdecl _wcslwr(wchar_t *);
 wchar_t * __cdecl _wcsupr(wchar_t *);
 size_t __cdecl wcsxfrm(wchar_t *, const wchar_t *, size_t);
 int __cdecl wcscoll(const wchar_t *, const wchar_t *);
 int __cdecl _wcsicoll(const wchar_t *, const wchar_t *);
 int __cdecl _wcsncoll(const wchar_t *, const wchar_t *, size_t);
 int __cdecl _wcsnicoll(const wchar_t *, const wchar_t *, size_t);







 wchar_t * __cdecl wcsdup(const wchar_t *);
 int __cdecl wcsicmp(const wchar_t *, const wchar_t *);
 int __cdecl wcsnicmp(const wchar_t *, const wchar_t *, size_t);
 wchar_t * __cdecl wcsnset(wchar_t *, wchar_t, size_t);
 wchar_t * __cdecl wcsrev(wchar_t *);
 wchar_t * __cdecl wcsset(wchar_t *, wchar_t);
 wchar_t * __cdecl wcslwr(wchar_t *);
 wchar_t * __cdecl wcsupr(wchar_t *);
 int __cdecl wcsicoll(const wchar_t *, const wchar_t *);

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


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

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


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

#line 239 "D:/Progra~1/Micros~2/VC98/Include\\string.h"
#line 26 "D:/working/tools/isim\\string.hpp"

#line 1 "D:/working/tools/isim\\libapi.hpp"







































































#line 28 "D:/working/tools/isim\\string.hpp"

class __declspec(dllexport) String {
  struct srep {
    char *str;     
    int n;         
    srep() { str=0; n=1; }
  };
  srep *p;

  int ok(char *proc, int lineno) const;

 public:
  
  String();

  
  String(const int i, const int base = 10);
  String(const unsigned int i, const int base = 10);
  String(const long i, const int base = 10);
  String(const unsigned long i, const int base = 10);

  
  String(const char c);

  
  String(const char *cs);

  
  String(const String& s);

  ~String();

  
  
  String substring(unsigned int lo, unsigned int hi) const;

  String& operator=(const char *cs);
  String& operator=(const String& s);

  int length() const;

  char& operator[](unsigned i);
  const char& operator[](unsigned i) const;

  String operator+(const char *cs);
  String operator+(const String &s);

  char *char_ptr() const;
  static void delete_char_ptr(char *cs);

  
  void uppercase();
  void lowercase();

  
  int asint() const;

  
  void deleteMyTrailingWhiteSpace();
  void deleteMyLeadingWhiteSpace();

  friend __declspec(dllexport) ostream& operator<<(ostream& os, const String& s);
  friend __declspec(dllexport) istream& operator>>(istream& is, String& s);

  bool operator==(const String& s2) const { 
    return !strcmp(p->str, s2.p->str); 
  }
  bool operator==(const char *s2) const { 
    return !strcmp(p->str, s2); 
  }

  bool operator!=(const String& s2) const {
    return (strcmp(p->str, s2.p->str) != 0);
  }
  bool operator!=(const char *s2) const { 
    return (strcmp(p->str, s2) != 0);
  }

  bool operator<(const String& s2) const { 
    return strcmp(p->str, s2.p->str) < 0; 
  }
  bool operator<(const char *s2) const { 
    return strcmp(p->str, s2) < 0; 
  }
  void streamIO(istream* i, ostream* o, unsigned int indent, 
    bool includeLength = true);
};

#line 117 "D:/working/tools/isim\\string.hpp"

#line 11 "D:/working/tools/isim\\misc.hpp"
#line 1 "D:/Progra~1/Micros~2/VC98/Include\\fstream.h"















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








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





#pragma pack(push,8)

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











































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

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
















#pragma warning(disable:4514) 

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

typedef int filedesc;

class  filebuf : public streambuf {
public:
static  const int       openprot;       


static  const int       sh_none;        
static  const int       sh_read;        
static  const int       sh_write;       



static  const int       binary;
static  const int       text;

                        filebuf();
                        filebuf(filedesc);
                        filebuf(filedesc, char *, int);
                        ~filebuf();

        filebuf*        attach(filedesc);
        filedesc        fd() const { return (x_fd==-1) ? (-1) : x_fd; }
        int             is_open() const { return (x_fd!=-1); }
        filebuf*        open(const char *, int, int = filebuf::openprot);
        filebuf*        close();
        int             setmode(int = filebuf::text);

virtual int             overflow(int=(-1));
virtual int             underflow();

virtual streambuf*      setbuf(char *, int);
virtual streampos       seekoff(streamoff, ios::seek_dir, int);

virtual int             sync();

private:
        filedesc        x_fd;
        int             x_fOpened;
};

class  ifstream : public istream {
public:
        ifstream();
        ifstream(const char *, int =ios::in, int = filebuf::openprot);
        ifstream(filedesc);
        ifstream(filedesc, char *, int);
        ~ifstream();

        streambuf * setbuf(char *, int);
        filebuf* rdbuf() const { return (filebuf*) ios::rdbuf(); }

        void attach(filedesc);
        filedesc fd() const { return rdbuf()->fd(); }

        int is_open() const { return rdbuf()->is_open(); }
        void open(const char *, int =ios::in, int = filebuf::openprot);
        void close();
        int setmode(int mode = filebuf::text) { return rdbuf()->setmode(mode); }
};

class  ofstream : public ostream {
public:
        ofstream();
        ofstream(const char *, int =ios::out, int = filebuf::openprot);
        ofstream(filedesc);
        ofstream(filedesc, char *, int);
        ~ofstream();

        streambuf * setbuf(char *, int);
        filebuf* rdbuf() const { return (filebuf*) ios::rdbuf(); }

        void attach(filedesc);
        filedesc fd() const { return rdbuf()->fd(); }

        int is_open() const { return rdbuf()->is_open(); }
        void open(const char *, int =ios::out, int = filebuf::openprot);
        void close();
        int setmode(int mode = filebuf::text) { return rdbuf()->setmode(mode); }
};
        
class  fstream : public iostream {
public:
        fstream();
        fstream(const char *, int, int = filebuf::openprot);
        fstream(filedesc);
        fstream(filedesc, char *, int);
        ~fstream();

        streambuf * setbuf(char *, int);
        filebuf* rdbuf() const { return (filebuf*) ostream::rdbuf(); }

        void attach(filedesc);
        filedesc fd() const { return rdbuf()->fd(); }

        int is_open() const { return rdbuf()->is_open(); }
        void open(const char *, int, int = filebuf::openprot);
        void close();
        int setmode(int mode = filebuf::text) { return rdbuf()->setmode(mode); }
};
        

inline  ios& binary(ios& _fstrm) \
   { ((filebuf*)_fstrm.rdbuf())->setmode(filebuf::binary); return _fstrm; }
inline  ios& text(ios& _fstrm) \
   { ((filebuf*)_fstrm.rdbuf())->setmode(filebuf::text); return _fstrm; }


#pragma pack(pop)
#line 167 "D:/Progra~1/Micros~2/VC98/Include\\fstream.h"

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

#line 171 "D:/Progra~1/Micros~2/VC98/Include\\fstream.h"
#line 12 "D:/working/tools/isim\\misc.hpp"









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













typedef unsigned int             uint;
typedef unsigned __int32         uint32;

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




















#line 1 "D:/working/tools/isim\\error.hpp"




















#line 1 "D:/working/tools/isim\\string.hpp"





















































































































#line 22 "D:/working/tools/isim\\error.hpp"












void __declspec(dllexport) _error(String file_name, int line_no, String msg);















#line 51 "D:/working/tools/isim\\error.hpp"








#line 60 "D:/working/tools/isim\\error.hpp"
#line 22 "D:/working/tools/isim\\vector.hpp"
#line 1 "D:/working/tools/isim\\libapi.hpp"







































































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

#pragma warning( disable : 4284 )
#pragma warning(disable: 4786)








template<class T> class vector;

template<class T>
class VPtr {
  int        idx;
  vector<T> *v;

 public:
  VPtr(): idx(-1), v(0) {}
  VPtr(const VPtr& p);

  ~VPtr() { idx = -1; v = 0; }

  VPtr& operator=(const VPtr& p);

  VPtr& operator++();
  
  VPtr& operator--();
  

  T& operator*();
  T *operator->();

  bool valid();

  bool operator==(const VPtr& p);
  bool operator!=(const VPtr& p);
  
  bool operator<(const VPtr& p);
  bool operator>(const VPtr& p);

  friend class vector<T>;
};

struct __declspec(dllexport) portable_vector {
  void *data;    
  int   datasz;  

  int   len;     

  portable_vector(): data(0), datasz(0), len(0) {}

  void (*delop)(void*);
};


template<class T>
class vector {
  T  *data;
  unsigned int sz;
  unsigned int used;
  void (*delop)(void*);

  inline T   *allocate(unsigned int n);  
  inline void destroy();                 

  void copy(const vector& v);

 public:
  vector();
  vector(const unsigned int n, const T& el = T());
  vector(const vector& v);
  vector(const portable_vector& pv);
  ~vector();

  void clear_portable_vector(portable_vector& pv);

  vector& operator=(const vector& v);

  int size() const { return used; }
  void clear();

  T& back();
  T& front();
  void push_back(const T& el);
  void push_back(const vector<T>& v);
  


  T pop_back();

  inline T& operator[](const unsigned int i);
  inline const T& operator[](const unsigned int i) const;

  VPtr<T> begin();
  VPtr<T> end();
  VPtr<T> getPtr(const unsigned int i); 

  operator portable_vector() const;

  
  
  
  char* writeBin(const unsigned int bin_size);
  
  
  char* readBin(unsigned int& bin_size);

  friend class VPtr<T>;
};