ffglobals.cpp.svn-base

来自「ffshow源码」· SVN-BASE 代码 · 共 1,552 行 · 第 1/3 页

   s->aspected_width = pixel_aspect[s->aspect_ratio_info][0];
   s->aspected_height= pixel_aspect[s->aspect_ratio_info][1];
 }
 return 0;
}

bool decodeMPEG4pictureHeader(const unsigned char *hdr,size_t len,TffPictBase &pict)
{
    int startcode, v;
    GetBitContext gb;
    MPEG4context s;
    init_get_bits(&gb, hdr, (int)len*8);

    /* search next start code */
    align_get_bits(&gb);
    startcode = 0xff;
    for(;;) {
        v = get_bits(&gb, 8);
        startcode = ((startcode << 8) | v) & 0xffffffff;
        
        if(get_bits_count(&gb) >= gb.size_in_bits){
                return false; //end of stream
        }

        if((startcode&0xFFFFFF00) != 0x100)
            continue; //no startcode
        
        switch(startcode){
        case 0x120:
            if(decode_vol_header(&s, &gb) < 0) 
             return false;
            else 
             {
              pict.setSar(Rational(s.aspected_width,s.aspected_height));
              return true;
             } 
/*            
#define VOS_STARTCODE        0x1B0
#define USER_DATA_STARTCODE  0x1B2
#define GOP_STARTCODE        0x1B3
#define VOP_STARTCODE        0x1B6
        case USER_DATA_STARTCODE:
            decode_user_data(s, gb);
            break;
        case GOP_STARTCODE:
            mpeg4_decode_gop_header(s, gb);
            break;
        case VOP_STARTCODE:
            return decode_vop_header(s, gb);
*/            
        default:
            break;
        }

        align_get_bits(&gb);
        startcode = 0xff;
    }
}

// encoding
const char_t *encQuantTypes[]=
{
 _l("H.263"),
 _l("MPEG"),
 _l("Modulated"),
 _l("Modulated new"),
 _l("Custom"),
 _l("JVT")
};

const Taspect displayAspects[]=
{
 _l("1:1")   , 1.0f,1.0f,
 _l("4:3")   , 4.0f,3.0f,
 _l("16:9")  ,16.0f,9.0f,
 _l("2.21:1"),2.21f,1.0f,
 NULL,0
};
const Taspect sampleAspects[]=
{
 _l("Square")   , 1.0f, 1.0f,
 _l("4:3 PAL")  ,12.0f,11.0f,
 _l("4:3 NTSC") ,10.0f,11.0f,
 _l("16:9 PAL") ,16.0f,11.0f,
 _l("16:9 NTSC"),40.0f,33.0f,
 NULL,0
};

//======================== YUVcolor ==========================
YUVcolor::YUVcolor(COLORREF rgb,bool vob)
{
 unsigned int r=GetRValue(rgb),g=GetGValue(rgb),b=GetBValue(rgb);
 if (!vob)
  {
   Y=(uint8_t)((((uint16_t) ((0.299)   * (1L << 8) + 0.5)) * r +
                ((uint16_t) ((0.587)   * (1L << 8) + 0.5)) * g +
                ((uint16_t) ((0.114)   * (1L << 8) + 0.5)) * b) >> 8);
   U=(int8_t)((-((int16_t)  ((0.16874) * (1L << 8) + 0.5)) * r -
                ((int16_t)  ((0.33126) * (1L << 8) + 0.5)) * g +
                ((int16_t)  ((0.50000) * (1L << 8) + 0.5)) * b) >> 9);// + 128;
   V=(int8_t)(( ((int16_t)  ((0.50000) * (1L << 8) + 0.5)) * r -
                ((int16_t)  ((0.41869) * (1L << 8) + 0.5)) * g -
                ((int16_t)  ((0.08131) * (1L << 8) + 0.5)) * b) >> 9);// + 128;
  }
 else
  {
   Y=(uint8_t)((((uint16_t) (( 0.1494 ) * (1L << 8) + 0.5)) * r +
                ((uint16_t) (( 0.6061 ) * (1L << 8) + 0.5)) * g +
                ((uint16_t) (( 0.2445 ) * (1L << 8) + 0.5)) * b) >> 8);
   U=(int8_t) ((((int16_t)  (( 0.6066 ) * (1L << 8) + 0.5)) * r -
                ((int16_t)  (( 0.4322 ) * (1L << 8) + 0.5)) * g -
                ((int16_t)  (( 0.1744 ) * (1L << 8) + 0.5)) * b) >> 8) + 128;
   V=(int8_t) ((((int16_t)  ((-0.08435) * (1L << 8) + 0.5)) * r -
                ((int16_t)  (( 0.3422 ) * (1L << 8) + 0.5)) * g +
                ((int16_t)  (( 0.4266 ) * (1L << 8) + 0.5)) * b) >> 8) + 128;
  }                
}

// Copyright (C) 1995,1998,1999 DJ Delorie
static bool isslash(char_t c) {return c=='\\' || c=='/';}
static const char_t *find_slash(const char_t *s)
{
 while (*s)
  {
   if (isslash(*s))
    return s;
   s++;
  }
 return 0;
}
struct Ttoupper
{
 template<class T> inline int operator()(T c) {return tchar_traits<char_t>::toupper((tchar_traits<char_t>::toupper_t)c);}
};
static const char_t *rangematch(const char_t *pattern, char_t test, int nocase)
{
 char_t c, c2;
 int negate, ok;

 if ((negate = (*pattern == '!'))!=NULL)
  ++pattern;

 for (ok = 0; (c = *pattern++) != ']';)
  {
   if (c == 0)
    return 0;/* illegal pattern */
   if (*pattern == '-' && (c2 = pattern[1]) != 0 && c2 != ']')
    {
     if (c <= test && test <= c2)
      ok = 1;
     if (nocase && Ttoupper()(c) <= Ttoupper()(test) && Ttoupper()(test) <= Ttoupper()(c2))
      ok = 1;
     pattern += 2;
    }
   else if (c == test)
    ok = 1;
   else if (nocase && (Ttoupper()(c) == Ttoupper()(test)))
    ok = 1;
  }
 return ok == negate ? NULL : pattern;
}
bool fnmatch(const char_t *pattern, const char_t *string, int flags)
{
 char_t c;
 char_t test;

 for (;;)
  switch ((c = *pattern++))
   {
    case 0:
     return *string == 0 ? true : false;
    case '?':
     if ((test = *string++) == 0 || (isslash(test) && (flags & FNM_PATHNAME)))
      return false;
     break;
    case '*':
     c = *pattern;
     // collapse multiple stars 
     while (c=='*')
      c=*++pattern;
     // optimize for pattern with * at end or before /
     if (c == 0)
      {
       if (flags & FNM_PATHNAME)
        return find_slash(string) ? false : true;
       else
        return true;
      }
     else if (isslash(c) && flags & FNM_PATHNAME)
      {
       if ((string = find_slash(string)) == NULL)
        return false;
       break;
      }

     // general case, use recursion 
     while ((test = *string) != 0)
      {
       if (fnmatch(pattern, string, flags) == true)
        return true;
       if (isslash(test) && flags & FNM_PATHNAME)
        break;
       ++string;
      }
     return false;
    case '[':
     if ((test = *string++) == 0 || (isslash(test) && flags & FNM_PATHNAME))
      return false;
     if ((pattern = rangematch(pattern, test, flags & FNM_NOCASE)) == NULL)
      return false;
     break;
    case '\\':
     if (!(flags & FNM_NOESCAPE) && pattern[1] && strchr("*?[\\", pattern[1]))
      {
       if ((c = *pattern++) == 0)
        {
         c = '\\';
         --pattern;
        }
       if (c != *string++)
        return false;
       break;
      }
      // FALLTHROUGH 
    default:
     if (isslash(c) && isslash(*string))
      {
       string++;
       break;
      }
     if (flags & FNM_NOCASE)
      {
       if (Ttoupper()(c) != Ttoupper()(*string++))
        return false;
      }
     else
      {
       if (c != *string++)
        return false;
      }
     break;
   }
}

template<class tchar> const tchar* stristr(const tchar *haystack,const tchar *needle) 
{
 if (!(haystack && needle)) return NULL;

 size_t len=strlen(needle);
 const tchar *p=haystack;
 while (*p != '\0')
  {
   if (_strnicmp(p,needle,len)==0) return p;
   p++;
  }
 return NULL;
}

template<class tchar> const tchar* strnistr(const tchar *haystack,size_t n,const tchar *needle) 
{
 if (!(haystack && needle)) return NULL;

 size_t len=strlen(needle);n-=len-1;
 const tchar *p=haystack;
 while (*p && n--)
  {
   if (_strnicmp(p,needle,len)==0) return (tchar*)p;
   p++;
  }
 return NULL;
}

template<class tchar> const tchar* strnstr(const tchar *haystack,size_t n,const tchar *needle) 
{
 if (!(haystack && needle)) return NULL;

 size_t len=strlen(needle);n-=len-1;
 const tchar *p=haystack;
 while (*p && n--)
  {
   if (strncmp(p,needle,len)==0) return (tchar*)p;
   p++;
  }
 return NULL;
}

template<class tchar> const void* memnstr(const void *haystack,size_t n,const tchar *needle)
{
 if (!(haystack && needle)) return NULL;
 
 int step=sizeof(tchar);
 size_t len=strlen(needle)*step;n-=len-step;
 const tchar *p=(const tchar*)haystack;
 while (n-=step)
  {
   if (memcmp(p,needle,len)==0) return p;
   p+=step;
  }
 return NULL;
}

template<class tchar> const tchar *strnchr(const tchar *s,size_t n,int c)
{
 while (n-- && *s)
  if (*s==c)
   return s;
  else
   s++; 
 return NULL;  
}
template<class char_t> char_t* strrmchar(char_t *s,int c)
{
 char_t *p1=s;
 for (const char_t *p2=p1;*p2;*p1=*p2,p2++,p1+=*p1!=c);
 *p1='\0';
 return s;
} 

int countbits(uint32_t x)
{
 static const int numbits[256]=
  {
   0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,
   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
   1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
   2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
   3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
   4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
  };
 return numbits[((uint8_t*)&x)[0]]+
        numbits[((uint8_t*)&x)[1]]+
        numbits[((uint8_t*)&x)[2]]+
        numbits[((uint8_t*)&x)[3]];
}

void setThreadName(DWORD dwThreadID,LPCSTR szThreadName)
{
#ifdef DEBUG
 struct THREADNAME_INFO
  {
   DWORD dwType;     // must be 0x1000
   LPCSTR szName;    // pointer to name (in user addr space)
   DWORD dwThreadID; // thread ID (-1=caller thread)
   DWORD dwFlags;    // reserved for future use, must be zero
  } info;
 info.dwType=0x1000;
 info.szName=szThreadName;
 info.dwThreadID=dwThreadID;
 info.dwFlags=0;
 __try
  {
   RaiseException(0x406D1388,0,sizeof(info)/sizeof(DWORD),(ULONG_PTR*)&info);
  }
 __except(EXCEPTION_CONTINUE_EXECUTION)
  {
  }
#endif
}

char_t *guid2str(const GUID &riid,char_t *dest)
{
 LPOLESTR str;
 StringFromIID(riid,&str);
 text<char_t>(str,dest);
 CoTaskMemFree(str);
 return dest;
}

FOURCC hdr2fourcc(const BITMAPINFOHEADER *hdr,const GUID *subtype)
{
 if (subtype && *subtype==MEDIASUBTYPE_QTRle) return FOURCC_QRLE;
 if (hdr->biCompression==0)
  {
   if (subtype)
    {
     if      (*subtype==MEDIASUBTYPE_RGB555) return FOURCC_RGB5;
     else if (*subtype==MEDIASUBTYPE_RGB565) return FOURCC_RGB6;
     else if (*subtype==MEDIASUBTYPE_RGB24 ) return FOURCC_RGB2;
     else if (*subtype==MEDIASUBTYPE_RGB32 || *subtype==MEDIASUBTYPE_ARGB32) return FOURCC_RGB3;
    } 
   switch (hdr->biBitCount)
    {
     case 1:return FOURCC_PAL1;break;
     case 4:return FOURCC_PAL4;break;
     case 8:return FOURCC_PAL8;break;
     case 15:return FOURCC_RGB5;break;
     case 16:return FOURCC_RGB6;break;
     case 24:return FOURCC_RGB2;break;
     case 32:return FOURCC_RGB3;break;
    }
  }
 return hdr->biCompression;
}

const char_t *fourcc2str(FOURCC fcc,char_t *name,size_t namelength)
{
 switch (fcc)
  {
   case FOURCC_PAL1:strncpy(name,_l("2 colors"),namelength);break;
   case FOURCC_PAL4:strncpy(name,_l("16 colors"),namelength);break;
   case FOURCC_PAL8:strncpy(name,_l("256 colors"),namelength);break;
   case FOURCC_RGB15MPLAYER:
   case FOURCC_RGB5:strncpy(name,_l("RGB555"),namelength);break;
   case FOURCC_RGB16MPLAYER:
   case FOURCC_RGB6:strncpy(name,_l("RGB565"),namelength);break;
   case FOURCC_RGB24MPLAYER:
   case FOURCC_RGB2:strncpy(name,_l("RGB24") ,namelength);break;
   case FOURCC_RGB32MPLAYER:
   case FOURCC_RGB3:strncpy(name,_l("RGB32") ,namelength);break;
   case FOURCC_RLE4:strncpy(name,_l("MSRLE4"),namelength);break;
   case FOURCC_RLE8:strncpy(name,_l("MSRLE8"),namelength);break;
   case FOURCC_1001:strncpy(name,_l("MPEG1") ,namelength);break;
   case FOURCC_1002:strncpy(name,_l("MPEG2") ,namelength);break;
   case FOURCC_BITFIELDS:strncpy(name,_l("bitfields"),namelength);break;
   default:
    {
     char nameA[5];
     memcpy(nameA,&fcc,std::min(namelength,(size_t)4));nameA[std::min(namelength,(size_t)4)]='\0';
     text<char_t>(nameA,name);
     break;
    } 
  }
 name[namelength-1]='\0';
 return name;
}

void fixMPEGinAVI(FOURCC &fcc)
{
 FOURCC fccu=FCCupper(fcc);
 if (fccu==FOURCC_1001 || fccu==FOURCC_1002 || fccu==FOURCC_MPG1 || fccu==FOURCC_MPG2)
  fcc=FOURCC_MPEG;
}

HWND createInvisibleWindow(HINSTANCE hi,const char_t *classname,const char_t *windowname,WNDPROC wndproc,void* lparam,ATOM *atom)
{
 if (!atom || !*atom)
  {
   WNDCLASS wndclass;
   wndclass.style        =0;
   wndclass.lpfnWndProc  =wndproc;
   wndclass.cbClsExtra   =0;
   wndclass.cbWndExtra   =0;
   wndclass.hInstance    =hi;
   wndclass.hIcon        =NULL;
   wndclass.hCursor      =NULL;
   wndclass.hbrBackground=NULL;
   wndclass.lpszMenuName =NULL;
   wndclass.lpszClassName=classname;
   ATOM at=RegisterClass(&wndclass);
   if (atom) *atom=at;
  } 

 return CreateWindow(classname,
                     windowname,
                     WS_OVERLAPPEDWINDOW,
                     CW_USEDEFAULT,
                     CW_USEDEFAULT,
                     CW_USEDEFAULT,
                     CW_USEDEFAULT,
                     NULL,
                     NULL,
                     hi,
                     lparam);
}

void getCLSIDname(const CLSID &clsid,char_t *buf,size_t buflen)
{
 LPOLESTR sclsidW;
 StringFromIID(clsid,&sclsidW);
 char_t reg[MAX_PATH];
 tsprintf(reg,_l("\\CLSID\\%s"),(const char_t*)text<char_t>(sclsidW));
 CoTaskMemFree(sclsidW);
 TregOpRegRead t(HKEY_CLASSES_ROOT,reg);
 t._REG_OP_S(0,_l(""),buf,buflen,_l(""));
}

const TmultipleInstances multipleInstances[]=
{
 0,_l("no limitations"),
 1,_l("only one - check previous filter only"),
 3,_l("only one - check all previous filters"),
 2,_l("only one - check all filters in graph"),
 4,_l("none - disabled"),
 0,NULL
};

template const char* stristr(const char *haystack,const char *needle);
template const char* strnstr(const char *haystack,size_t n,const char *needle);
template const char* strnistr(const char *haystack,size_t n,const char *needle);
template const char *strnchr(const char *s,size_t n,int c);
template char* strrmchar(char *s,int c);
template void strtok(const char *s,const char *delim,std::vector<DwString<char> > &lst,bool add_empty,size_t max_parts);
template void strtok(const char *s,const char *delim,std::vector<Tstrpart<char> > &lst,bool add_empty,size_t max_parts);
template void strtok(const char *s,const char *delim,ints &lst,bool add_empty,size_t max_parts);
template const void* memnstr(const void *haystachk,size_t n,const char *needle);

template const wchar_t* stristr(const wchar_t *haystack,const wchar_t *needle);
template const wchar_t* strnstr(const wchar_t *haystack,size_t n,const wchar_t *needle);
template const wchar_t* strnistr(const wchar_t *haystack,size_t n,const wchar_t *needle);
template const wchar_t *strnchr(const wchar_t *s,size_t n,int c);
template void strtok(const wchar_t *s,const wchar_t *delim,std::vector<DwString<wchar_t> > &lst,bool add_empty,size_t max_parts);
template void strtok(const wchar_t *s,const wchar_t *delim,std::vector<Tstrpart<wchar_t> > &lst,bool add_empty,size_t max_parts);
template void strtok(const wchar_t *s,const wchar_t *delim,ints &lst,bool add_empty,size_t max_parts);
template wchar_t* strrmchar(wchar_t *s,int c);
template const void* memnstr(const void *haystachk,size_t n,const wchar_t *needle);