idb_streamc.i

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

#pragma warning(disable:4514) 

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


typedef long streamoff, streampos;

class  istream : virtual public ios {

public:
    istream(streambuf*);
    virtual ~istream();

    int  ipfx(int =0);
    void isfx() { unlockbuf(); unlock(); }

    inline istream& operator>>(istream& (__cdecl * _f)(istream&));
    inline istream& operator>>(ios& (__cdecl * _f)(ios&));
    istream& operator>>(char *);
    inline istream& operator>>(unsigned char *);
    inline istream& operator>>(signed char *);
    istream& operator>>(char &);
    inline istream& operator>>(unsigned char &);
    inline istream& operator>>(signed char &);
    istream& operator>>(short &);
    istream& operator>>(unsigned short &);
    istream& operator>>(int &);
    istream& operator>>(unsigned int &);
    istream& operator>>(long &);
    istream& operator>>(unsigned long &);
    istream& operator>>(float &);
    istream& operator>>(double &);
    istream& operator>>(long double &);
    istream& operator>>(streambuf*);

    int get();

    inline istream& get(         char *,int,char ='\n');
    inline istream& get(unsigned char *,int,char ='\n');
    inline istream& get(  signed char *,int,char ='\n');

    istream& get(char &);
    inline istream& get(unsigned char &);
    inline istream& get(  signed char &);

    istream& get(streambuf&,char ='\n');
    inline istream& getline(         char *,int,char ='\n');
    inline istream& getline(unsigned char *,int,char ='\n');
    inline istream& getline(  signed char *,int,char ='\n');

    inline istream& ignore(int =1,int =(-1));
    istream& read(char *,int);
    inline istream& read(unsigned char *,int);
    inline istream& read(signed char *,int);

    int gcount() const { return x_gcount; }
    int peek();
    istream& putback(char);
    int sync();

    istream& seekg(streampos);
    istream& seekg(streamoff,ios::seek_dir);
    streampos tellg();

    void eatwhite();

protected:
    istream();
    istream(const istream&);    
    istream& operator=(streambuf* _isb); 
    istream& operator=(const istream& _is) { return operator=(_is.rdbuf()); }
    istream& get(char *, int, int);
     int do_ipfx(int);

private:
    istream(ios&);
    int getint(char *);
    int getdouble(char *, int);
    int _fGline;
    int x_gcount;
};

    inline istream& istream::operator>>(istream& (__cdecl * _f)(istream&)) { (*_f)(*this); return *this; }
    inline istream& istream::operator>>(ios& (__cdecl * _f)(ios&)) { (*_f)(*this); return *this; }

    inline istream& istream::operator>>(unsigned char * _s) { return operator>>((char *)_s); }
    inline istream& istream::operator>>(  signed char * _s) { return operator>>((char *)_s); }

    inline istream& istream::operator>>(unsigned char & _c) { return operator>>((char &) _c); }
    inline istream& istream::operator>>(  signed char & _c) { return operator>>((char &) _c); }

    inline istream& istream::get(         char * _b, int _lim, char _delim) { return get(        _b, _lim, (int)(unsigned char)_delim); }
    inline istream& istream::get(unsigned char * _b, int _lim, char _delim) { return get((char *)_b, _lim, (int)(unsigned char)_delim); }
    inline istream& istream::get(signed   char * _b, int _lim, char _delim) { return get((char *)_b, _lim, (int)(unsigned char)_delim); }

    inline istream& istream::get(unsigned char & _c) { return get((char &)_c); }
    inline istream& istream::get(  signed char & _c) { return get((char &)_c); }

    inline istream& istream::getline(         char * _b,int _lim,char _delim) { lock(); _fGline++; get(        _b, _lim, (int)(unsigned char)_delim); unlock(); return *this; }
    inline istream& istream::getline(unsigned char * _b,int _lim,char _delim) { lock(); _fGline++; get((char *)_b, _lim, (int)(unsigned char)_delim); unlock(); return *this; }
    inline istream& istream::getline(  signed char * _b,int _lim,char _delim) { lock(); _fGline++; get((char *)_b, _lim, (int)(unsigned char)_delim); unlock(); return *this; }

    inline istream& istream::ignore(int _n,int _delim) { lock(); _fGline++; get((char *)0, _n+1, _delim); unlock(); return *this; }

    inline istream& istream::read(unsigned char * _ptr, int _n) { return read((char *) _ptr, _n); }
    inline istream& istream::read(  signed char * _ptr, int _n) { return read((char *) _ptr, _n); }

class  istream_withassign : public istream {
        public:
            istream_withassign();
            istream_withassign(streambuf*);
            ~istream_withassign();
    istream& operator=(const istream& _is) { return istream::operator=(_is); }
    istream& operator=(streambuf* _isb) { return istream::operator=(_isb); }
};

extern  istream_withassign cin;

inline  istream& __cdecl ws(istream& _ins) { _ins.eatwhite(); return _ins; }

 ios&        __cdecl dec(ios&);
 ios&        __cdecl hex(ios&);
 ios&        __cdecl oct(ios&);



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

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

#line 189 "D:/Progra~1/Micros~2/VC98/Include\\istream.h"
#line 57 "D:/Progra~1/Micros~2/VC98/Include\\iostream.h"

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















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








#line 27 "D:/Progra~1/Micros~2/VC98/Include\\ostream.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\\ostream.h"

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
















#pragma warning(disable:4514) 

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

typedef long streamoff, streampos;

class  ostream : virtual public ios {

public:
        ostream(streambuf*);
        virtual ~ostream();

        ostream& flush();
        int  opfx();
        void osfx();

inline  ostream& operator<<(ostream& (__cdecl * _f)(ostream&));
inline  ostream& operator<<(ios& (__cdecl * _f)(ios&));
        ostream& operator<<(const char *);
inline  ostream& operator<<(const unsigned char *);
inline  ostream& operator<<(const signed char *);
inline  ostream& operator<<(char);
        ostream& operator<<(unsigned char);
inline  ostream& operator<<(signed char);
        ostream& operator<<(short);
        ostream& operator<<(unsigned short);
        ostream& operator<<(int);
        ostream& operator<<(unsigned int);
        ostream& operator<<(long);
        ostream& operator<<(unsigned long);
inline  ostream& operator<<(float);
        ostream& operator<<(double);
        ostream& operator<<(long double);
        ostream& operator<<(const void *);
        ostream& operator<<(streambuf*);
inline  ostream& put(char);
        ostream& put(unsigned char);
inline  ostream& put(signed char);
        ostream& write(const char *,int);
inline  ostream& write(const unsigned char *,int);
inline  ostream& write(const signed char *,int);
        ostream& seekp(streampos);
        ostream& seekp(streamoff,ios::seek_dir);
        streampos tellp();

protected:
        ostream();
        ostream(const ostream&);        
        ostream& operator=(streambuf*); 
        ostream& operator=(const ostream& _os) {return operator=(_os.rdbuf()); }
        int do_opfx(int);               
        void do_osfx();                 

private:
        ostream(ios&);
        ostream& writepad(const char *, const char *);
        int x_floatused;
};

inline ostream& ostream::operator<<(ostream& (__cdecl * _f)(ostream&)) { (*_f)(*this); return *this; }
inline ostream& ostream::operator<<(ios& (__cdecl * _f)(ios& )) { (*_f)(*this); return *this; }

inline  ostream& ostream::operator<<(char _c) { return operator<<((unsigned char) _c); }
inline  ostream& ostream::operator<<(signed char _c) { return operator<<((unsigned char) _c); }

inline  ostream& ostream::operator<<(const unsigned char * _s) { return operator<<((const char *) _s); }
inline  ostream& ostream::operator<<(const signed char * _s) { return operator<<((const char *) _s); }

inline  ostream& ostream::operator<<(float _f) { x_floatused = 1; return operator<<((double) _f); }

inline  ostream& ostream::put(char _c) { return put((unsigned char) _c); }
inline  ostream& ostream::put(signed char _c) { return put((unsigned char) _c); }

inline  ostream& ostream::write(const unsigned char * _s, int _n) { return write((char *) _s, _n); }
inline  ostream& ostream::write(const signed char * _s, int _n) { return write((char *) _s, _n); }


class  ostream_withassign : public ostream {
        public:
                ostream_withassign();
                ostream_withassign(streambuf* _is);
                ~ostream_withassign();
    ostream& operator=(const ostream& _os) { return ostream::operator=(_os.rdbuf()); }
    ostream& operator=(streambuf* _sb) { return ostream::operator=(_sb); }
};

extern ostream_withassign  cout;
extern ostream_withassign  cerr;
extern ostream_withassign  clog;

inline  ostream& __cdecl flush(ostream& _outs) { return _outs.flush(); }
inline  ostream& __cdecl endl(ostream& _outs) { return _outs << '\n' << flush; }
inline  ostream& __cdecl ends(ostream& _outs) { return _outs << char('\0'); }

 ios&           __cdecl dec(ios&);
 ios&           __cdecl hex(ios&);
 ios&           __cdecl oct(ios&);



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

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

#line 159 "D:/Progra~1/Micros~2/VC98/Include\\ostream.h"
#line 59 "D:/Progra~1/Micros~2/VC98/Include\\iostream.h"



#pragma warning(disable:4514) 

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

class  iostream : public istream, public ostream {
public:
        iostream(streambuf*);
        virtual ~iostream();
protected:
        iostream();
        iostream(const iostream&);
inline iostream& operator=(streambuf*);
inline iostream& operator=(iostream&);
private:
        iostream(ios&);
        iostream(istream&);
        iostream(ostream&);
};

inline iostream& iostream::operator=(streambuf* _sb) { istream::operator=(_sb); ostream::operator=(_sb); return *this; }

inline iostream& iostream::operator=(iostream& _strm) { return operator=(_strm.rdbuf()); }

class  Iostream_init {
public:
        Iostream_init();
        Iostream_init(ios &, int =0);   
        ~Iostream_init();
};






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

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

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

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















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








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






#pragma pack(push,8)

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












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











































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



#pragma warning(disable:4514)           

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

class  strstreambuf : public streambuf  {
public:
                strstreambuf();
                strstreambuf(int);
                strstreambuf(char *, int, char * = 0);
                strstreambuf(unsigned char *, int, unsigned char * = 0);
                strstreambuf(signed char *, int, signed char * = 0);
                strstreambuf(void * (*a)(long), void (*f) (void *));
                ~strstreambuf();

        void    freeze(int =1);
        char * str();

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

protected:
virtual int     doallocate();
private:
        int     x_dynamic;
        int     x_bufmin;
        int     _fAlloc;
        int     x_static;
        void * (* x_alloc)(long);
        void    (* x_free)(void *);
};

class  istrstream : public istream {
public:
                istrstream(char *);
                istrstream(char *, int);
                ~istrstream();

inline  strstreambuf* rdbuf() const { return (strstreambuf*) ios::rdbuf(); }
inline  char * str() { return rdbuf()->str(); }
};

class  ostrstream : public ostream {
public:
                ostrstream();
                ostrstream(char *, int, int = ios::out);
                ~ostrstream();

inline  int     pcount() const { return rdbuf()->out_waiting(); }
inline  strstreambuf* rdbuf() const { return (strstreambuf*) ios::rdbuf(); }
inline  char *  str() { return rdbuf()->str(); }
};

class  strstream : public iostream {    
public:
                strstream();
                strstream(char *, int, int);
                ~strstream();

inline  int     pcount() const { return rdbuf()->out_waiting(); } 
inline  strstreambuf* rdbuf() const { return (strstreambuf*) ostream::rdbuf(); }
inline  char * str() { return rdbuf()->str(); }
};



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

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

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


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















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






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



extern "C" {
#line 30 "D:/Progra~1/Micros~2/VC98/Include\\string.h"

















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








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



typedef unsigned int size_t;

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




typedef unsigned short wchar_t;

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




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
























        void *  __cdecl memcpy(void *, const void *, size_t);
        int     __cdecl memcmp(const void *, const void *, size_t);
        void *  __cdecl memset(void *, int, size_t);
        char *  __cdecl _strset(char *, int);
        char *  __cdecl strcpy(char *, const char *);
        char *  __cdecl strcat(char *, const char *);
        int     __cdecl strcmp(const char *, const char *);
        size_t  __cdecl strlen(const char *);
#line 110 "D:/Progra~1/Micros~2/VC98/Include\\string.h"
 void *  __cdecl _memccpy(void *, const void *, int, unsigned int);
 void *  __cdecl memchr(const void *, int, size_t);
 int     __cdecl _memicmp(const void *, const void *, unsigned int);





 void *  __cdecl memmove(void *, const void *, size_t);
#line 120 "D:/Progra~1/Micros~2/VC98/Include\\string.h"


 char *  __cdecl strchr(const char *, int);
 int     __cdecl _strcmpi(const char *, const char *);
 int     __cdecl _stricmp(const char *, const char *);
 int     __cdecl strcoll(const char *, const char *);
 int     __cdecl _stricoll(const char *, const char *);
 int     __cdecl _strncoll(const char *, const char *, size_t);
 int     __cdecl _strnicoll(const char *, const char *, size_t);
 size_t  __cdecl strcspn(const char *, const char *);
 char *  __cdecl _strdup(const char *);
 char *  __cdecl _strerror(const char *);
 char *  __cdecl strerror(int);
 char *  __cdecl _strlwr(char *);
 char *  __cdecl strncat(char *, const char *, size_t);
 int     __cdecl strncmp(const char *, const char *, size_t);
 int     __cdecl _strnicmp(const char *, const char *, size_t);
 char *  __cdecl strncpy(char *, const char *, size_t);
 char *  __cdecl _strnset(char *, int, size_t);
 char *  __cdecl strpbrk(const char *, const char *);
 char *  __cdecl strrchr(const char *, int);
 char *  __cdecl _strrev(char *);
 size_t  __cdecl strspn(const char *, const char *);
 char *  __cdecl strstr(const char *, const char *);
 char *  __cdecl strtok(char *, const char *);
 char *  __cdecl _strupr(char *);
 size_t  __cdecl strxfrm (char *, const char *, size_t);














 void * __cdecl memccpy(void *, const void *, int, unsigned int);
 int __cdecl memicmp(const void *, const void *, unsigned int);
 int __cdecl strcmpi(const char *, const char *);
 int __cdecl stricmp(const char *, const char *);
 char * __cdecl strdup(const char *);
 char * __cdecl strlwr(char *);
 int __cdecl strnicmp(const char *, const char *, size_t);
 char * __cdecl strnset(char *, int, size_t);
 char * __cdecl strrev(char *);
        char * __cdecl strset(char *, int);
 char * __cdecl strupr(char *);

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







 wchar_t * __cdecl wcscat(wchar_t *, const wchar_t *);
 wchar_t * __cdecl wcschr(const wchar_t *, wchar_t);
 int __cdecl wcscmp(const wchar_t *, const wchar_t *);
 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 25 "D:/working/tools/isim/isimhostdll2/sc_program.hpp"





class ProtoScheduler;
class StreamDispatcherInterface;
class StreamDispatcher;
class ImagineDBOp;
class RunTimeSchedulerInterface;
enum SchedulerTypeEnum {
  scdInvalid,
  scdRunTimeScheduler,
  scdPlaybackScheduler,
  scdStreamDispatcher
};



#line 45 "D:/working/tools/isim/isimhostdll2/sc_program.hpp"

typedef void (*StreamProgFn)(ProtoScheduler& scd, String args);

struct StreamProg;

__declspec(dllexport) StreamProg* addOrGetStreamProg(StreamProg* StreamProg, String n = "");

struct StreamProg {
  String name;
  StreamProgFn fn;


  SchedulerTypeEnum schedulerType;
  
  bool opsLoaded;
  int numOps;
  ImagineDBOp* ops;
  bool minimumAgeEnabled;

  StreamProg() {}
  StreamProg(String _name, void (*_fn)(StreamDispatcher& dis, String args)): 
    name(_name), fn((StreamProgFn)_fn), schedulerType(scdStreamDispatcher), 
    opsLoaded(false), numOps(0), ops(0), minimumAgeEnabled(true)
    {