ffglobals.h.svn-base

来自「ffshow源码」· SVN-BASE 代码 · 共 619 行 · 第 1/2 页

#ifndef _FFGLOBALS_H_
#define _FFGLOBALS_H_

#define FFDSHOW            _l("ffdshow")
#define FFDSHOWDECVIDEO    _l("ffdshow")
#define FFDSHOWDECVIDEOVFW _l("ffdshow_vfw")
#define FFDSHOWDECAUDIO    _l("ffdshow_audio")
#define FFDSHOWDECAUDIORAW _l("ffdshow_audio_raw")
#define FFDSHOWENC         _l("ffdshow_enc")

extern const char_t *FFDSHOW_VER;

#undef min
#undef max

#ifndef FFDEFS_STRICT

#if !defined(INFINITY) && defined(HUGE_VAL)
#define INFINITY HUGE_VAL
#endif

#ifdef __GNUC__
typedef const TCHAR *PCTSTR;
#endif

#ifndef __GNUC__
 extern "C" LONG  __cdecl _InterlockedIncrement(LONG volatile *Addend);
 #pragma intrinsic (_InterlockedIncrement)
 #define InterlockedIncrement _InterlockedIncrement

 extern "C" LONG  __cdecl _InterlockedDecrement(LONG volatile *Addend);
 #pragma intrinsic (_InterlockedDecrement)
 #define InterlockedDecrement _InterlockedDecrement

 extern "C" LONG  __cdecl _InterlockedExchange(LONG volatile *Target, LONG Value); 
 #pragma intrinsic (_InterlockedExchange)
 #define InterlockedExchange _InterlockedExchange  
 
 extern "C" LONG  __cdecl _InterlockedCompareExchange(LONG volatile *Dest, LONG Exchange, LONG Comp);
 #pragma intrinsic (_InterlockedCompareExchange)
 #define InterlockedCompareExchange _InterlockedCompareExchange
#endif

#define DEG2RAD 0.017453292519943295769236907684886

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#ifndef M_E
#define M_E 2.7182818284590452354
#endif

#ifndef M_SQRT1_2
#define M_SQRT1_2 0.70710678118654752440
#endif

#ifndef M_SQRT2
#define M_SQRT2	1.41421356237309504880
#endif

#define REF_SECOND_MULT 10000000LL
#define REFTIME_INVALID _I64_MIN

#define countof(array) (sizeof(array)/sizeof(array[0]))

#define STRINGIFY(s) TOSTRING(s)
#define TOSTRING(s) #s

typedef std::vector<HWND> THWNDs;
struct Tstrptrs : std::vector<const char_t*> {};
template<class tchar> struct Tstrpart : std::pair<const tchar*,size_t>
{
 Tstrpart(const tchar *p,size_t len):std::pair<const tchar*,size_t>(p,len) {}
 Tstrpart(const tchar *p):std::pair<const tchar*,size_t>(p,strlen(p)) {}
};
typedef std::vector<int> ints;

void* memsetd(void *dest,uint32_t c,size_t bytes);
char_t* strcatf(char_t *dst,const char_t *fmt,...);
char_t* strncatf(char_t *dst,size_t dstsize,const char_t *fmt,...);
char_t* strcpyf(char_t *dst,const char_t *fmt,...);
char_t* strncpyf(char_t *dst,size_t dstsize,const char_t *fmt,...);
template<class tchar,class TlistElem> void strtok(const tchar *s,const tchar *delim,std::vector<TlistElem> &list,bool add_empty=false,size_t max_parts=std::numeric_limits<size_t>::max());
template<class tchar> void strtok(const tchar *s,const tchar *delim,ints &list,bool add_empty=false,size_t max_parts=std::numeric_limits<size_t>::max());
void mergetok(char_t *dst,size_t dstlen,const char_t *delim,const strings &list);
template<class char_t> const char_t* stristr(const char_t *haystack,const char_t *needle);
template<class char_t> const char_t* strnstr(const char_t *haystack,size_t n,const char_t *needle);
template<class char_t> const char_t* strnistr(const char_t *haystack,size_t n,const char_t *needle);
template<class char_t> const char_t* strnchr(const char_t *s,size_t n,int c);
template<class char_t> char_t* strrmchar(char_t *s,int c);
template<class char_t> const void* memnstr(const void *haystack,size_t n,const char_t *needle);
bool dlgGetDir(HWND owner,char_t *dir,const char_t *capt);
bool dlgGetFile(bool save,HWND owner,const char_t *capt,const char_t *filter,const char_t *defext,char_t *flnm,const char_t *initdir,DWORD flags,DWORD *filterIndex=NULL);
bool dlgOpenFiles(HWND owner,const char_t *capt,const char_t *filter,const char_t *defext,strings &files,const char_t *initdir,DWORD flags);
void findFiles(const char_t *mask,strings &list,bool fullpaths=true);
bool fileexists(const char_t *flnm),directoryexists(const char_t *dir);
inline bool operator !=(const FILETIME &t1,const FILETIME &t2)
{
 return t1.dwHighDateTime!=t2.dwHighDateTime || t1.dwLowDateTime!=t2.dwLowDateTime;
}
FILETIME fileLastWriteTime(const char_t *flnm);
void extractfilepath(const char_t *flnm,char_t *path);
void extractfilename(const char_t *flnm,char_t *nameext);
void extractfilenameWOext(const char_t *flnm,char_t *name);
void extractfileext (const char_t *flnm,char_t *ext); //without the .
int nCopyAnsiToWideChar(WCHAR *pWCStr,PCTSTR pAnsiIn,int cchAnsi=0);
char *unicode16toAnsi(const WCHAR *data16,int data16len=-1,char *data8=NULL);
char *utf8toAnsi(const char *data,int datalen=-1,char *data8=NULL);
wchar_t *utf8toUnicode(const char *data,int datalen,wchar_t *data16=NULL);
unsigned int ff_sqrt(unsigned int a);
int av_log2(unsigned int v);
int64_t lavc_gcd(int64_t a, int64_t b);
int lavc_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max);
void saveFrame(unsigned int num,const unsigned char *buf,size_t len);
char_t *readTextFile(const char_t *filename);
struct TffPictBase;
bool decodeMPEGsequenceHeader(bool mpeg2,const unsigned char *hdr,size_t len,TffPictBase &pict,bool *isH264);
bool decodeMPEG4pictureHeader(const unsigned char *hdr,size_t len,TffPictBase &pict);
bool decodeH264SPS(const unsigned char *hdr,size_t len,TffPictBase &pict);
void getChildWindows(HWND h,THWNDs &lst);
void randomize(void);
int countbits(uint32_t x);
enum
{
 FNM_NOESCAPE=0x01,
 FNM_PATHNAME=0x02,
 FNM_NOCASE  =0x08
};
bool fnmatch(const char_t *pattern, const char_t *string, int flags=FNM_NOCASE|FNM_NOESCAPE);
void setThreadName(DWORD dwThreadID,LPCSTR szThreadName);
char_t *guid2str(const GUID &riid,char_t *dest);
inline FOURCC FCCupper(FOURCC fourCC)
{
 return toupper(fourCC&0xFF)+(toupper((fourCC>>8)&0xFF)<<8)+(toupper((fourCC>>16)&0xFF)<<16)+(toupper((fourCC>>24)&0xFF)<<24);
}
const char_t *fourcc2str(FOURCC fcc,char_t *name,size_t namelength);
FOURCC hdr2fourcc(const BITMAPINFOHEADER *hdr,const GUID *subtype);
void fixMPEGinAVI(FOURCC &fcc);
HWND createInvisibleWindow(HINSTANCE hi,const char_t *classname,const char_t *windowname,WNDPROC wndproc,void* lparam,ATOM *atom);
void getCLSIDname(const CLSID &clsid,char_t *buf,size_t buflen);

template<class T> inline T ff_abs(const T &x) 
{ 
 return (x<0)?T(-x):T(x);
}

inline int ff_round(double x) {return int(x+(x>0.0?0.5:-0.5));} 
inline int ff_round(float x) {return int(x+(x>0.0f?0.5f:-0.5f));} 

template<class T> inline T roundRshift(const T &x,int s)
{
 return (x+(1<<s)/2)>>s;
}
template<class T> inline T roundDiv(const T &a, const T &b)
{
 return (a>0?a+(b>>1):a-(b>>1))/b;
}

template<class T> inline T sqr(const T &a)
{
 return a*a;
}

template <class Tin,class Tout> inline Tout mapRange(Tin in,const std::pair<Tin,Tin> &inrange,const std::pair<Tout,Tout> &outrange)
{
 if (inrange.first!=inrange.second && outrange.first!=outrange.second)
  return Tout((outrange.second-outrange.first)*(in-inrange.first)/(inrange.second-inrange.first)+outrange.first);
 else
  return Tout(0);
}

template<class T> inline const T& limit(const T& val,const T& min,const T& max)
{
 if (val<min) return min;
 else if (val>max) return max;
 else return val;
}
static inline uint8_t limit_uint8(int a)
{
 if (a&(~255)) return uint8_t((-a)>>31);
 else          return uint8_t(a);
}

template<class T> inline bool isIn(const T& x,const T& min,const T& max)
{
 return (min<=x && x<=max);
}

template<class T> inline bool isIn(const std::vector<T> &v,const T& a)
{
 return std::find(v.begin(),v.end(),a)!=v.end();
}

template<class T> inline char sign(const T& x)
{
 if (x<0) return -1;
 else if (x>0) return 1;
 else return 0;
}

template<class T> inline bool odd(T x)
{
 return x&1;
}
template<class T> inline bool even(T x)
{
 return (x&1)==0;
}

static inline double value2db(double value) {return value>0?log10(value)*20.0:0.0;} 
static inline double db2value(double db) {return pow(10.0,db/20.0);}
static inline double db2value(double db,int mul) {return pow(10.0,db/(mul*20.0));}

static inline float value2db(float value) {return value>0?log10f(value)*20.0f:0.0f;} 
static inline float db2value(float db) {return powf(10.0f,db/20.0f);}
static inline float db2value(float db,int mul) {return powf(10.0f,db/(mul*20.0f));}

template<typename T> inline const T& bswap(T& var)
{
 BYTE* s = (BYTE*)&var;
 for(BYTE* d = s + sizeof(var)-1; s < d; s++, d--)
  *s ^= *d, *d ^= *s, *s ^= *d;
 return var; 
}

#if defined(__INTEL_COMPILER) || defined(__GNUC__) || (_MSC_VER>=1300)
template<typename T,typename U> struct IsSameType
{
 enum {value=false};
};
template<typename T> struct IsSameType<T,T>
{
 enum {value=true};
};

template<bool is,typename T,typename U> struct selectType
{
 typedef T result;
};
template<typename T,typename U> struct selectType<false,T,U>
{
 typedef U result;
};

template<int v> struct intToVal
{
 static const int value=v;
};
#endif

void dumpBytes(const char_t *flnm,const unsigned char *buf,size_t len);

inline double psnr(double d)
{
 if (d==0) return -1;
 return -10.0*log(d)/log(10.0);
}

template<class Tptr> inline Tptr* lpwAlign(Tptr* pIn)
{
 DWORD_PTR ul;
 ul = (DWORD_PTR) pIn;
 ul +=3;
 ul >>=2;
 ul <<=2;
 return (Tptr*)ul;
}

template<template <class> class alloc> struct TbyteBufferBase :public std::vector<unsigned char,alloc<unsigned char> >
{
 TbyteBufferBase(void) {}
 TbyteBufferBase(size_t Isize):std::vector<typename TbyteBufferBase<alloc>::value_type,typename TbyteBufferBase<alloc>::allocator_type>(Isize) {}
 TbyteBufferBase(const void *ptr,size_t len)
  {
   append(ptr,len);
  }
 template<class Ta> void append(const Ta &b) 
  {
   insert(this->end(),(const unsigned char*)&b,(const unsigned char*)&b+sizeof(Ta));
  }
 void append(const void *ptr,size_t len)
  {
   insert(this->end(),(const unsigned char*)ptr,(const unsigned char*)ptr+len);
  }
};
typedef TbyteBufferBase<std::allocator> TbyteBuffer;
typedef TbyteBufferBase<aligned_allocator> TbyteBufferA;

class Tbuffer
{
private:
 void *buf;size_t buflen;
public: 
 Tbuffer(void):buf(NULL),buflen(0),free(true) {}
 Tbuffer(size_t Ibuflen):buf(NULL),buflen(0),free(true) {alloc(Ibuflen);}
 ~Tbuffer() {if (free) clear();}
 bool free;
 void clear(void)
  {
   if (buf) aligned_free(buf);
   buf=NULL;buflen=0;
  }
 size_t size(void) const {return buflen;} 
 void* alloc(size_t Ibuflen)
  {
   if (buflen<Ibuflen)
    buf=aligned_realloc(buf,buflen=Ibuflen);
   return buf; 
  }